Security Requirements and Controls
API Stability Short-Term

The createRepository() GraphQL mutation may be used to create a new repository in LogScale.

There are a few mutations for making changes to a repository. You can use the updateRepositoryType() mutation to change the type (e.g., PERSONAL). The updateRepositoryDataType() mutation can be used to change the data type (e.g., ANYDATA).

Use either the deleteSearchDomain() or the deleteSearchDomainById() mutation to delete a repository. To get information on a repository after created, use the repository() query. To get a list of repositories, use repositories().

For more information on creating a repository, see the Creating a Repository or View documentation page. You may also want to look at the Manage Repositories and Views and Repositories pages for related information.

Syntax

graphql
createRepository(
     name: string!,
     description: string,
     retentionInMillis: long,
     retentionInIngestSizeBytes: long,
     retentionInStorageSizeBytes: long,
     organizationId: string, 
     type: RepositoryType, 
     repositoryId: string, 
     dataType: RepositoryDataType,
     limitId: string
   ): CreateRepositoryMutation!

The limitId is the limit to which the repository should be attached. This is only a cloud feature.

Example

Below is an example of how this mutation field might be used:

Raw
graphql
mutation {
  createRepository(
        name: "my-repository",
        description: "My Repository",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}
Mac OS or Linux (curl)
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}"
}
EOF
Mac OS or Linux (curl) One-line
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql \
    -H "Authorization: Bearer $TOKEN" \
    -H "Content-Type: application/json" \
    -d @- << EOF
{"query" : "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}"
}
EOF
Windows Cmd and curl
shell
curl -v -X POST $YOUR_LOGSCALE_URL/graphql ^
    -H "Authorization: Bearer $TOKEN" ^
    -H "Content-Type: application/json" ^
    -d @'{"query" : "mutation { ^
  createRepository( ^
        name: \"my-repository\", ^
        description: \"My Repository\", ^
        type: PERSONAL, ^
        dataType: ANYDATA ^
      ) ^
  { repository { id } } ^
}" ^
} '
Windows Powershell and curl
powershell
curl.exe -X POST 
    -H "Authorization: Bearer $TOKEN"
    -H "Content-Type: application/json"
    -d '{"query" : "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}"
}'
    "$YOUR_LOGSCALE_URL/graphql"
Perl
perl
#!/usr/bin/perl

use HTTP::Request;
use LWP;

my $TOKEN = "TOKEN";

my $uri = '$YOUR_LOGSCALE_URL/graphql';

my $query = "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}";
$query =~ s/\n/ /g;
my $json = sprintf('{"query" : "%s"}',$query);
my $req = HTTP::Request->new("POST", $uri );

$req->header("Authorization" => "Bearer $TOKEN");
$req->header("Content-Type" => "application/json");

$req->content( $json );

my $lwp = LWP::UserAgent->new;

my $result = $lwp->request( $req );

print $result->{"_content"},"\n";
Python
python
#! /usr/local/bin/python3

import requests

url = '$YOUR_LOGSCALE_URL/graphql'
mydata = r'''{"query" : "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}"
}'''

resp = requests.post(url,
                     data = mydata,
                     headers = {
   "Authorization" : "Bearer $TOKEN",
   "Content-Type" : "application/json"
}
)

print(resp.text)
Node.js
javascript
const https = require('https');

const data = JSON.stringify(
    {"query" : "mutation {
  createRepository(
        name: \"my-repository\",
        description: \"My Repository\",
        type: PERSONAL,
        dataType: ANYDATA
      )
  { repository { id } }
}"
}
);


const options = {
  hostname: '$YOUR_LOGSCALE_URL',
  path: 'graphql',
  port: 443,
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': data.length,
    Authorization: 'BEARER ' + process.env.TOKEN,
    'User-Agent': 'Node',
  },
};

const req = https.request(options, (res) => {
  let data = '';
  console.log(`statusCode: ${res.statusCode}`);

  res.on('data', (d) => {
    data += d;
  });
  res.on('end', () => {
    console.log(JSON.parse(data).data);
  });
});

req.on('error', (error) => {
  console.error(error);
});

req.write(data);
req.end();
Example Responses
Success (HTTP Response Code 200 OK)
json
{
  "data": {
    "createRepository": {
      "repository": {
        "id": "my-repository"
      }
    }
  }
}

Regarding limitId , it's the limit to which the repository should be attached, only a cloud feature. If not specified, a default will be found and used.

Given Datatype

For this input datatype, you would provide the name of the view associated with the saved query to create, the query itself, and a few other factors. These are listed and explained, along with other parameters, in the table below:

Table: RepositoryType

ParameterTypeRequiredDefaultStabilityDescription
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: May 9, 2025
DEFAULT   Long-TermThe repository type is the default.
MANAGED   Long-TermThe repository is managed.
PERSONAL   Long-TermThe repository is personal.
SYSTEM   Long-TermThe repository is from the LogScale system.
TRIAL   Long-TermThe repository is for a trial account.

For this second input datatype, you would specify the type of data to be used by repository to create (e.g., Falcon data). The table below explains the choices:

Table: RepositoryDataType

ParameterTypeRequiredDefaultStabilityDescription
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: Oct 3, 2025
ANYDATA   Short-TermThe repository data is unrestricted to a particular datatype.
FALCON   Short-TermThe repository data is restricted to the Falcon datatype.

Returned Datatype

The returned datatype, through sub-datatypes, allows you to select many sub-parameters to get information on the repository. Since this mutation is used to create one, though, you may only want the unique identifier generated to use with other mutations and queries. Click on the link in the table below to get to the table containing sub-parameters:

Table: CreateRepositoryMutation

ParameterTypeRequiredDefaultStabilityDescription
Some arguments may be required, as indicated in the Required column. For return datatypes, this indicates that you must specify which fields you want returned in the results.
Table last updated: Sep 24, 2024
repositoryRepositoryyes Long-TermThe repository to create. See Repository.