• Make a REST API request
• Rate limits
• Response format
• Request requirements
  • Request payload
  • Path parameters
  • id vs iid
  • Encoding
    • Namespaced paths
    • File path, branches, and tags name
    • Array and hash types
      • array
      • hash
      • Array of hashes
    • Encoding + in ISO 8601 dates
• Evaluating a response
  • null vs false
  • Redirects
• Pagination
  • Offset-based pagination
    • Pagination Link header
    • Other pagination headers
  • Keyset-based pagination
    • Supported resources
  • Pagination response headers
• Versioning and deprecations

REST API

Use the GitLab REST API to retrieve data by using any compatible REST API client.

Make a REST API request

To make a REST API request:

• Submit a request to an API endpoint by using a REST API client.
• The GitLab instance responds to the request. It returns a status code and if applicable, the requested data. The status code indicates the outcome of the request and is useful when troubleshooting.

A REST API request must start with the root endpoint and the path.

• The root endpoint is the GitLab host name.
• The path must start with /api/v4 (v4 represents the API version).

In the following example, the API request retrieves the list of all projects on GitLab host example.com:

curl "https://example.com/api/v4/projects"

Access to some endpoints require authentication. For more information, see Authentication.

Rate limits

REST API requests are subject to rate limit settings. These settings reduce the risk of a GitLab instance being overloaded.

• For details, see Rate limits.
• For details of the rate limit settings used by GitLab.com, see GitLab.com-specific rate limits.

Response format

REST API responses are returned in JSON format. Some API endpoints also support plain text format. To confirm which content type an endpoint supports, see the REST API resources.

Request requirements

Some REST API requests have specific requirements, including the data format and encoding used.

Request payload

API requests can use parameters sent as query strings or as a payload body. GET requests usually send a query string, while PUT or POST requests usually send the payload body:

• Query string:

  curl --request POST "https://gitlab/api/v4/projects?name=<example-name>&description=<example-description>"
  

• Request payload (JSON):

  curl --request POST --header "Content-Type: application/json" \
       --data '{"name":"<example-name>", "description":"<example-description>"}' "https://gitlab/api/v4/projects"
  

URL encoded query strings have a length limitation. Requests that are too large result in a 414 Request-URI Too Large error message. This can be resolved by using a payload body instead.

Path parameters

If an endpoint has path parameters, the documentation displays them with a preceding colon.

For example:

DELETE /projects/:id/share/:group_id

The :id path parameter needs to be replaced with the project ID, and the :group_id needs to be replaced with the ID of the group. The colons : shouldn’t be included.

The resulting cURL request for a project with ID 5 and a group ID of 17 is then:

curl --request DELETE --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/projects/5/share/17"

Path parameters that are required to be URL-encoded must be followed. If not, it doesn’t match an API endpoint and responds with a 404. If there’s something in front of the API (for example, Apache), ensure that it doesn’t decode the URL-encoded path parameters.

id vs iid

Some API resources have two similarly-named fields. For example, issues, merge requests, and project milestones. The fields are:

• id: ID that is unique across all projects.
• iid: Additional, internal ID (displayed in the web UI) that’s unique in the scope of a single project.

If a resource has both the iid field and the id field, the iid field is usually used instead of id to fetch the resource.

For example, suppose a project with id: 42 has an issue with id: 46 and iid: 5. In this case:

• A valid API request to retrieve the issue is GET /projects/42/issues/5.
• An invalid API request to retrieve the issue is GET /projects/42/issues/46.

Not all resources with the iid field are fetched by iid. For guidance regarding which field to use, see the documentation for the specific resource.

Encoding

When making a REST API request, some content must be encoded to account for special characters and data structures.

Namespaced paths

If using namespaced API requests, make sure that the NAMESPACE/PROJECT_PATH is URL-encoded.

For example, / is represented by %2F:

GET /api/v4/projects/diaspora%2Fdiaspora

A project’s path isn’t necessarily the same as its name. A project’s path is found in the project’s URL or in the project’s settings, under General > Advanced > Change path.

File path, branches, and tags name

If a file path, branch or tag contains a /, make sure it is URL-encoded.

For example, / is represented by %2F:

GET /api/v4/projects/1/repository/files/src%2FREADME.md?ref=master
GET /api/v4/projects/1/branches/my%2Fbranch/commits
GET /api/v4/projects/1/repository/tags/my%2Ftag

Array and hash types

You can request the API with array and hash types parameters:

array

import_sources is a parameter of type array:

curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" \
-d "import_sources[]=github" \
-d "import_sources[]=bitbucket" \
"https://gitlab.example.com/api/v4/some_endpoint"

hash

override_params is a parameter of type hash:

curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" \
--form "namespace=email" \
--form "path=impapi" \
--form "file=@/path/to/somefile.txt" \
--form "override_params[visibility]=private" \
--form "override_params[some_other_param]=some_value" \
"https://gitlab.example.com/api/v4/projects/import"

Array of hashes

variables is a parameter of type array containing hash key/value pairs [{ 'key': 'UPLOAD_TO_S3', 'value': 'true' }]:

curl --globoff --request POST --header "PRIVATE-TOKEN: <your_access_token>" \
"https://gitlab.example.com/api/v4/projects/169/pipeline?ref=master&variables[0][key]=VAR1&variables[0][value]=hello&variables[1][key]=VAR2&variables[1][value]=world"

curl --request POST --header "PRIVATE-TOKEN: <your_access_token>" \
--header "Content-Type: application/json" \
--data '{ "ref": "master", "variables": [ {"key": "VAR1", "value": "hello"}, {"key": "VAR2", "value": "world"} ] }' \
"https://gitlab.example.com/api/v4/projects/169/pipeline"

Encoding + in ISO 8601 dates

If you need to include a + in a query parameter, you may need to use %2B instead, due to a W3 recommendation that causes a + to be interpreted as a space. For example, in an ISO 8601 date, you may want to include a specific time in ISO 8601 format, such as:

2017-10-17T23:11:13.000+05:30

The correct encoding for the query parameter would be:

2017-10-17T23:11:13.000%2B05:30

Evaluating a response

In some circumstances the API response may not be as you expect. Issues can include null values and redirection. If you receive a numeric status code in the response, see Status codes.

null vs false

In API responses, some boolean fields can have null values. A null boolean has no default value and is neither true nor false. GitLab treats null values in boolean fields the same as false.

In boolean arguments, you should only set true or false values (not null).

Redirects

After path changes the REST API might respond with a message noting that the endpoint has moved. When this happens, used the endpoint specified in the Location header.

Example of a project moved to a different path:

curl --verbose "https://gitlab.example.com/api/v4/projects/gitlab-org%2Fold-path-project"

The response is:

...
< Location: http://gitlab.example.com/api/v4/projects/81
...
This resource has been moved permanently to https://gitlab.example.com/api/v4/projects/81

Pagination

GitLab supports the following pagination methods:

• Offset-based pagination. The default method and available on all endpoints except, in GitLab 16.5 and later, the users endpoint.
• Keyset-based pagination. Added to selected endpoints but being progressively rolled out.

For large collections, you should use keyset pagination (when available) instead of offset pagination, for performance reasons.

Offset-based pagination

Sometimes, the returned result spans many pages. When listing resources, you can pass the following parameters:

In the following example, we list 50 namespaces per page:

curl --request GET --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/namespaces?per_page=50"

Pagination Link header

Link headers are returned with each response. They have rel set to prev, next, first, or last and contain the relevant URL. Be sure to use these links instead of generating your own URLs.

For GitLab.com users, some pagination headers may not be returned.

In the following cURL example, we limit the output to three items per page (per_page=3) and we request the second page (page=2) of comments of the issue with ID 8 which belongs to the project with ID 9:

curl --head --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/projects/9/issues/8/notes?per_page=3&page=2"

The response is:

HTTP/2 200 OK
cache-control: no-cache
content-length: 1103
content-type: application/json
date: Mon, 18 Jan 2016 09:43:18 GMT
link: <https://gitlab.example.com/api/v4/projects/8/issues/8/notes?page=1&per_page=3>; rel="prev", <https://gitlab.example.com/api/v4/projects/8/issues/8/notes?page=3&per_page=3>; rel="next", <https://gitlab.example.com/api/v4/projects/8/issues/8/notes?page=1&per_page=3>; rel="first", <https://gitlab.example.com/api/v4/projects/8/issues/8/notes?page=3&per_page=3>; rel="last"
status: 200 OK
vary: Origin
x-next-page: 3
x-page: 2
x-per-page: 3
x-prev-page: 1
x-request-id: 732ad4ee-9870-4866-a199-a9db0cde3c86
x-runtime: 0.108688
x-total: 8
x-total-pages: 3

Other pagination headers

GitLab also returns the following additional pagination headers:

For GitLab.com users, some pagination headers may not be returned.

Keyset-based pagination

Keyset-pagination allows for more efficient retrieval of pages and - in contrast to offset-based pagination - runtime is independent of the size of the collection.

This method is controlled by the following parameters. order_by and sort are both mandatory.

In the following example, we list 50 projects per page, ordered by id ascending.

curl --request GET --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/projects?pagination=keyset&per_page=50&order_by=id&sort=asc"

The response header includes a link to the next page. For example:

HTTP/1.1 200 OK
...
Link: <https://gitlab.example.com/api/v4/projects?pagination=keyset&per_page=50&order_by=id&sort=asc&id_after=42>; rel="next"
Status: 200 OK
...

The link to the next page contains an additional filter id_after=42 that excludes already-retrieved records.

As another example, the following request lists 50 groups per page ordered by name ascending using keyset pagination:

curl --request GET --header "PRIVATE-TOKEN: <your_access_token>" "https://gitlab.example.com/api/v4/groups?pagination=keyset&per_page=50&order_by=name&sort=asc"

The response header includes a link to the next page:

HTTP/1.1 200 OK
...
Link: <https://gitlab.example.com/api/v4/groups?pagination=keyset&per_page=50&order_by=name&sort=asc&cursor=eyJuYW1lIjoiRmxpZ2h0anMiLCJpZCI6IjI2IiwiX2tkIjoibiJ9>; rel="next"
Status: 200 OK
...

The link to the next page contains an additional filter cursor=eyJuYW1lIjoiRmxpZ2h0anMiLCJpZCI6IjI2IiwiX2tkIjoibiJ9 that excludes already-retrieved records.

The type of filter depends on the order_by option used, and we can have more than one additional filter.

When the end of the collection is reached and there are no additional records to retrieve, the Link header is absent and the resulting array is empty.

You should use only the given link to retrieve the next page instead of building your own URL. Apart from the headers shown, we don’t expose additional pagination headers.

Supported resources

Keyset-based pagination is supported only for selected resources and ordering options:

Pagination response headers

For performance reasons, if a query returns more than 10,000 records, GitLab doesn’t return the following headers:

• x-total.
• x-total-pages.
• rel="last" link

Versioning and deprecations

The REST API version complies with the semantic versioning specification. The major version number is 4. Backward-incompatible changes require this version number to change.

• The minor version isn’t explicit, which allows for a stable API endpoint.
• New features are added to the API in the same version number.
• Major API version changes, and removal of entire API versions, are done in tandem with major GitLab releases.
• All deprecations and changes between versions are noted in the documentation.

The following are excluded from the deprecation process and can be removed at any time without notice:

• Elements labeled in the REST API resources as experimental or beta.
• Fields behind a feature flag and disabled by default.