openapi.yaml

openapi: 3.1.2
info:
  title: Apify API
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0.html
  description: |

    The Apify API (version 2) provides programmatic access to the [Apify
    platform](https://docs.apify.com). The API is organized
    around [RESTful](https://en.wikipedia.org/wiki/Representational_state_transfer)
    HTTP endpoints.

    You can download the complete OpenAPI schema of Apify API in the [YAML](http://docs.apify.com/api/openapi.yaml) or [JSON](http://docs.apify.com/api/openapi.json) formats. The source code is also available on [GitHub](https://github.com/apify/apify-docs/tree/master/apify-api/openapi).

    All requests and responses (including errors) are encoded in
    [JSON](http://www.json.org/) format with UTF-8 encoding,
    with a few exceptions that are explicitly described in the reference.

    - To access the API using [Node.js](https://nodejs.org/en/), we recommend the [`apify-client`](https://docs.apify.com/api/client/js) [NPM
    package](https://www.npmjs.com/package/apify-client).
    - To access the API using [Python](https://www.python.org/), we recommend the [`apify-client`](https://docs.apify.com/api/client/python) [PyPI
    package](https://pypi.org/project/apify-client/).

    The clients' functions correspond to the API endpoints and have the same
    parameters. This simplifies development of apps that depend on the Apify
    platform.

    :::note Important Request Details

    - `Content-Type` header: For requests with a JSON body, you must include the `Content-Type: application/json` header.

    - Method override: You can override the HTTP method using the `method` query parameter. This is useful for clients that can only send `GET` requests. For example, to call a `POST` endpoint, append `?method=POST` to the URL of your `GET` request.

    :::

    ## Authentication
    <span id="/introduction/authentication"></span>

    You can find your API token on the
    [Integrations](https://console.apify.com/account#/integrations) page in the
    Apify Console.

    To use your token in a request, either:

    - Add the token to your request's `Authorization` header as `Bearer <token>`.
    E.g., `Authorization: Bearer xxxxxxx`.
    [More info](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Authorization).
    (Recommended).
    - Add it as the `token` parameter to your request URL. (Less secure).

    Using your token in the request header is more secure than using it as a URL
    parameter because URLs are often stored
    in browser history and server logs. This creates a chance for someone
    unauthorized to access your API token.

    **Do not share your API token or password with untrusted parties.**

    For more information, see our
    [integrations](https://docs.apify.com/platform/integrations) documentation.

    ## Basic usage
    <span id="/introduction/basic-usage"></span>

    To run an Actor, send a POST request to the [Run
    Actor](#/reference/actors/run-collection/run-actor) endpoint using either the
    Actor ID code (e.g. `vKg4IjxZbEYTYeW8T`) or its name (e.g.
    `janedoe~my-actor`):

    `https://api.apify.com/v2/acts/[actor_id]/runs`

    If the Actor is not runnable anonymously, you will receive a 401 or 403
    [response code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
    This means you need to add your [secret API
    token](https://console.apify.com/account#/integrations) to the request's
    `Authorization` header ([recommended](#/introduction/authentication)) or as a
    URL query parameter `?token=[your_token]` (less secure).

    Optionally, you can include the query parameters described in the [Run
    Actor](#/reference/actors/run-collection/run-actor) section to customize your
    run.

    If you're using Node.js, the best way to run an Actor is using the
    `Apify.call()` method from the [Apify
    SDK](https://sdk.apify.com/docs/api/apify#apifycallactid-input-options). It
    runs the Actor using the account you are currently logged into (determined
    by the [secret API token](https://console.apify.com/account#/integrations)).
    The result is an [Actor run
    object](https://sdk.apify.com/docs/typedefs/actor-run) and its output (if
    any).

    A typical workflow is as follows:

    1. Run an Actor or task using the [Run
    Actor](#/reference/actors/run-collection/run-actor) or [Run
    task](#/reference/actor-tasks/run-collection/run-task) API endpoints.
    2. Monitor the Actor run by periodically polling its progress using the [Get
    run](#/reference/actor-runs/run-object-and-its-storages/get-run) API
    endpoint.
    3. Fetch the results from the [Get
    items](#/reference/datasets/item-collection/get-items) API endpoint using the
    `defaultDatasetId`, which you receive in the Run request response.
    Additional data may be stored in a key-value store. You can fetch them from
    the [Get record](#/reference/key-value-stores/record/get-record) API endpoint
    using the `defaultKeyValueStoreId` and the store's `key`.

    **Note**: Instead of periodic polling, you can also run your
    [Actor](#/reference/actors/run-actor-synchronously) or
    [task](#/reference/actor-tasks/runs-collection/run-task-synchronously)
    synchronously. This will ensure that the request waits for 300 seconds (5
    minutes) for the run to finish and returns its output. If the run takes
    longer, the request will time out and throw an error.

    ## Response structure
    <span id="/introduction/response-structure"></span>

    Most API endpoints return a JSON object with the `data` property:

    ```
    {
        "data": {
            ...
        }
    }
    ```

    However, there are a few explicitly described exceptions, such as
    [Get dataset items](#/reference/datasets/item-collection/get-items) or
    Key-value store [Get record](#/reference/key-value-stores/record/get-record)
    API endpoints, which return data in other formats.
    In case of an error, the response has the HTTP status code in the range of
    4xx or 5xx and the `data` property is replaced with `error`. For example:

    ```
    {
        "error": {
            "type": "record-not-found",
            "message": "Store was not found."
        }
    }
    ```

    See [Errors](#/introduction/errors) for more details.

    ## Pagination
    <span id="/introduction/pagination"></span>

    All API endpoints that return a list of records
    (e.g. [Get list of
    Actors](#/reference/actors/actor-collection/get-list-of-actors))
    enforce pagination in order to limit the size of their responses.

    Most of these API endpoints are paginated using the `offset` and `limit`
    query parameters.
    The only exception is [Get list of
    keys](#/reference/key-value-stores/key-collection/get-list-of-keys),
    which is paginated using the `exclusiveStartKey` query parameter.

    **IMPORTANT**: Each API endpoint that supports pagination enforces a certain
    maximum value for the `limit` parameter,
    in order to reduce the load on Apify servers.
    The maximum limit could change in future so you should never
    rely on a specific value and check the responses of these API endpoints.

    ### Using offset
    <span id="/introduction/pagination/using-offset"></span>

    Most API endpoints that return a list of records enable pagination using the
    following query parameters:

    <table>
      <tr>
        <td><code>limit</code></td>
        <td>Limits the response to contain a specific maximum number of items, e.g. <code>limit=20</code>.</td>
      </tr>
      <tr>
        <td><code>offset</code></td>
        <td>Skips a number of items from the beginning of the list, e.g. <code>offset=100</code>.</td>
      </tr>
      <tr>
        <td><code>desc</code></td>
        <td>
        By default, items are sorted in the order in which they were created or added to the list.
        This feature is useful when fetching all the items, because it ensures that items
        created after the client started the pagination will not be skipped.
        If you specify the <code>desc=1</code> parameter, the items will be returned in the reverse order,
        i.e. from the newest to the oldest items.
        </td>
      </tr>
    </table>

    The response of these API endpoints is always a JSON object with the
    following structure:

    ```
    {
        "data": {
            "total": 2560,
            "offset": 250,
            "limit": 1000,
            "count": 1000,
            "desc": false,
            "items": [
                { 1st object },
                { 2nd object },
                ...
                { 1000th object }
            ]
        }
    }
    ```

    The following table describes the meaning of the response properties:

    <table>
      <tr>
        <th>Property</th>
        <th>Description</th>
      </tr>
      <tr>
        <td><code>total</code></td>
        <td>The total number of items available in the list.</td>
      </tr>
      <tr>
        <td><code>offset</code></td>
        <td>The number of items that were skipped at the start.
        This is equal to the <code>offset</code> query parameter if it was provided, otherwise it is <code>0</code>.</td>
      </tr>
      <tr>
        <td><code>limit</code></td>
        <td>The maximum number of items that can be returned in the HTTP response.
        It equals to the <code>limit</code> query parameter if it was provided or
        the maximum limit enforced for the particular API endpoint, whichever is smaller.</td>
      </tr>
      <tr>
        <td><code>count</code></td>
        <td>The actual number of items returned in the HTTP response.</td>
      </tr>
      <tr>
        <td><code>desc</code></td>
        <td><code>true</code> if data were requested in descending order and <code>false</code> otherwise.</td>
      </tr>
      <tr>
        <td><code>items</code></td>
        <td>An array of requested items.</td>
      </tr>
    </table>

    ### Using key
    <span id="/introduction/pagination/using-key"></span>

    The records in the [key-value
    store](https://docs.apify.com/platform/storage/key-value-store)
    are not ordered based on numerical indexes,
    but rather by their keys in the UTF-8 binary order.
    Therefore the [Get list of
    keys](#/reference/key-value-stores/key-collection/get-list-of-keys)
    API endpoint only supports pagination using the following query parameters:

    <table>
      <tr>
        <td><code>limit</code></td>
        <td>Limits the response to contain a specific maximum number items, e.g. <code>limit=20</code>.</td>
      </tr>
      <tr>
        <td><code>exclusiveStartKey</code></td>
        <td>Skips all records with keys up to the given key including the given key,
        in the UTF-8 binary order.</td>
      </tr>
    </table>

    The response of the API endpoint is always a JSON object with following
    structure:

    ```
    {
        "data": {
            "limit": 1000,
            "isTruncated": true,
            "exclusiveStartKey": "my-key",
            "nextExclusiveStartKey": "some-other-key",
            "items": [
                { 1st object },
                { 2nd object },
                ...
                { 1000th object }
            ]
        }
    }
    ```

    The following table describes the meaning of the response properties:

    <table>
      <tr>
        <th>Property</th>
        <th>Description</th>
      </tr>
      <tr>
        <td><code>limit</code></td>
        <td>The maximum number of items that can be returned in the HTTP response.
        It equals to the <code>limit</code> query parameter if it was provided or
        the maximum limit enforced for the particular endpoint, whichever is smaller.</td>
      </tr>
      <tr>
        <td><code>isTruncated</code></td>
        <td><code>true</code> if there are more items left to be queried. Otherwise <code>false</code>.</td>
      </tr>
      <tr>
        <td><code>exclusiveStartKey</code></td>
        <td>The last key that was skipped at the start. Is `null` for the first page.</td>
      </tr>
      <tr>
        <td><code>nextExclusiveStartKey</code></td>
        <td>The value for the <code>exclusiveStartKey</code> parameter to query the next page of items.</td>
      </tr>
    </table>

    ## Errors
    <span id="/introduction/errors"></span>

    The Apify API uses common HTTP status codes: `2xx` range for success, `4xx`
    range for errors caused by the caller
    (invalid requests) and `5xx` range for server errors (these are rare).
    Each error response contains a JSON object defining the `error` property,
    which is an object with
    the `type` and `message` properties that contain the error code and a
    human-readable error description, respectively.

    For example:

    ```
    {
        "error": {
            "type": "record-not-found",
            "message": "Store was not found."
        }
    }
    ```

    Here is the table of the most common errors that can occur for many API
    endpoints:

    <table>
      <tr>
        <th>status</th>
        <th>type</th>
        <th>message</th>
      </tr>
      <tr>
        <td><code>400</code></td>
        <td><code>invalid-request</code></td>
        <td>POST data must be a JSON object</td>
      </tr>
      <tr>
        <td><code>400</code></td>
        <td><code>invalid-value</code></td>
        <td>Invalid value provided: Comments required</td>
      </tr>
      <tr>
        <td><code>400</code></td>
        <td><code>invalid-record-key</code></td>
        <td>Record key contains invalid character</td>
      </tr>
      <tr>
        <td><code>401</code></td>
        <td><code>token-not-provided</code></td>
        <td>Authentication token was not provided</td>
      </tr>
      <tr>
        <td><code>404</code></td>
        <td><code>record-not-found</code></td>
        <td>Store was not found</td>
      </tr>
      <tr>
        <td><code>429</code></td>
        <td><code>rate-limit-exceeded</code></td>
        <td>You have exceeded the rate limit of ... requests per second</td>
      </tr>
      <tr>
        <td><code>405</code></td>
        <td><code>method-not-allowed</code></td>
        <td>This API endpoint can only be accessed using the following HTTP methods: OPTIONS, POST</td>
      </tr>
    </table>

    ## Rate limiting
    <span id="/introduction/rate-limiting"></span>

    All API endpoints limit the rate of requests in order to prevent overloading of Apify servers by misbehaving clients.

    There are two kinds of rate limits - a global rate limit and a per-resource rate limit.

    ### Global rate limit
    <span id="/introduction/rate-limiting/global-rate-limit"></span>

    The global rate limit is set to _250 000 requests per minute_.
    For [authenticated](#/introduction/authentication) requests, it is counted per user,
    and for unauthenticated requests, it is counted per IP address.

    ### Per-resource rate limit
    <span id="/introduction/rate-limiting/per-resource-rate-limit"></span>

    The default per-resource rate limit is _60 requests per second per resource_, which in this context means a single Actor, a single Actor run, a single dataset, single key-value store etc.
    The default rate limit is applied to every API endpoint except a few select ones, which have higher rate limits.
    Each API endpoint returns its rate limit in `X-RateLimit-Limit` header.

    These endpoints have a rate limit of _200 requests per second per resource_:

    * CRUD ([get](#/reference/key-value-stores/record/get-record),
      [put](#/reference/key-value-stores/record/put-record),
      [delete](#/reference/key-value-stores/record/delete-record))
      operations on key-value store records

    These endpoints have a rate limit of _400 requests per second per resource_:
    * [Run Actor](#/reference/actors/run-collection/run-actor)
    * [Run Actor task asynchronously](#/reference/actor-tasks/runs-collection/run-task-asynchronously)
    * [Run Actor task synchronously](#/reference/actor-tasks/runs-collection/run-task-synchronously)
    * [Metamorph Actor run](#/reference/actors/metamorph-run/metamorph-run)
    * [Push items](#/reference/datasets/item-collection/put-items) to dataset
    * CRUD
      ([add](#/reference/request-queues/request-collection/add-request),
      [get](#/reference/request-queues/request-collection/get-request),
      [update](#/reference/request-queues/request-collection/update-request),
      [delete](#/reference/request-queues/request-collection/delete-request))
      operations on requests in request queues

    ### Rate limit exceeded errors
    <span id="/introduction/rate-limiting/rate-limit-exceeded-errors"></span>

    If the client is sending too many requests, the API endpoints respond with the HTTP status code `429 Too Many Requests`
    and the following body:

    ```
    {
        "error": {
            "type": "rate-limit-exceeded",
            "message": "You have exceeded the rate limit of ... requests per second"
        }
    }
    ```

    ### Retrying rate-limited requests with exponential backoff
    <span id="/introduction/rate-limiting/retrying-rate-limited-requests-with-exponential-backoff"></span>

    If the client receives the rate limit error, it should wait a certain period of time and then retry the request.
    If the error happens again, the client should double the wait period and retry the request,
    and so on. This algorithm is known as _exponential backoff_
    and it can be described using the following pseudo-code:

    1. Define a variable `DELAY=500`
    2. Send the HTTP request to the API endpoint
    3. If the response has status code not equal to `429` then you are done. Otherwise:
       * Wait for a period of time chosen randomly from the interval `DELAY` to `2*DELAY` milliseconds
       * Double the future wait period by setting `DELAY = 2*DELAY`
       * Continue with step 2

    If all requests sent by the client implement the above steps,
    the client will automatically use the maximum available bandwidth for its requests.

    Note that the Apify API clients [for JavaScript](https://docs.apify.com/api/client/js)
    and [for Python](https://docs.apify.com/api/client/python)
    use the exponential backoff algorithm transparently, so that you do not need to worry about it.

    ## Referring to resources
    <span id="/introduction/referring-to-resources"></span>

    There are three main ways to refer to a resource you're accessing via API.

    - the resource ID (e.g. `iKkPcIgVvwmztduf8`)
    - `username~resourcename` - when using this access method, you will need to
    use your API token, and access will only work if you have the correct
    permissions.
    - `~resourcename` - for this, you need to use an API token, and the
    `resourcename` refers to a resource in the API token owner's account.
  contact: {}
  version:
      $ref: components/version.yaml
servers:
  - url: "https://api.apify.com"
    variables: {}
paths:
  /v2/acts:
    $ref: paths/actors/acts.yaml
  "/v2/acts/{actorId}":
    $ref: "paths/actors/acts@{actorId}.yaml"
  "/v2/acts/{actorId}/versions":
    $ref: "paths/actors/acts@{actorId}@versions.yaml"
  "/v2/acts/{actorId}/versions/{versionNumber}":
    $ref: "paths/actors/acts@{actorId}@versions@{versionNumber}.yaml"
  "/v2/acts/{actorId}/versions/{versionNumber}/env-vars":
    $ref: "paths/actors/acts@{actorId}@versions@{versionNumber}@env-vars.yaml"
  "/v2/acts/{actorId}/versions/{versionNumber}/env-vars/{envVarName}":
    $ref: "paths/actors/acts@{actorId}@versions@{versionNumber}@env-vars@{envVarName}.yaml"
  "/v2/acts/{actorId}/webhooks":
    $ref: "paths/actors/acts@{actorId}@webhooks.yaml"
  "/v2/acts/{actorId}/builds":
    $ref: "paths/actors/acts@{actorId}@builds.yaml"
  "/v2/acts/{actorId}/builds/default":
    $ref: "paths/actors/acts@{actorId}@builds@default.yaml"
  "/v2/acts/{actorId}/builds/{buildId}/openapi.json":
    $ref: "paths/actors/acts@{actorId}@builds@{buildId}@openapi.json.yaml"
  "/v2/acts/{actorId}/builds/{buildId}":
    $ref: "paths/actors/acts@{actorId}@builds@{buildId}.yaml"
  "/v2/acts/{actorId}/builds/{buildId}/abort":
    $ref: "paths/actors/acts@{actorId}@builds@{buildId}@abort.yaml"
  "/v2/acts/{actorId}/runs":
    $ref: "paths/actors/acts@{actorId}@runs.yaml"
  "/v2/acts/{actorId}/run-sync":
    $ref: "paths/actors/acts@{actorId}@run-sync.yaml"
  "/v2/acts/{actorId}/run-sync-get-dataset-items":
    $ref: "paths/actors/acts@{actorId}@run-sync-get-dataset-items.yaml"
  "/v2/acts/{actorId}/validate-input":
    $ref: "paths/actors/acts@{actorId}@validate-input.yaml"
  "/v2/acts/{actorId}/runs/{runId}/resurrect":
    $ref: "paths/actors/acts@{actorId}@runs@{runId}@resurrect.yaml"
  "/v2/acts/{actorId}/runs/last":
    $ref: "paths/actors/acts@{actorId}@runs@last.yaml"
  "/v2/acts/{actorId}/runs/{runId}":
    $ref: "paths/actors/acts@{actorId}@runs@{runId}.yaml"
  "/v2/acts/{actorId}/runs/{runId}/abort":
    $ref: "paths/actors/acts@{actorId}@runs@{runId}@abort.yaml"
  "/v2/acts/{actorId}/runs/{runId}/metamorph":
    $ref: "paths/actors/acts@{actorId}@runs@{runId}@metamorph.yaml"
  /v2/actor-tasks:
    $ref: paths/actor-tasks/actor-tasks.yaml
  "/v2/actor-tasks/{actorTaskId}":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}.yaml"
  "/v2/actor-tasks/{actorTaskId}/input":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@input.yaml"
  "/v2/actor-tasks/{actorTaskId}/webhooks":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@webhooks.yaml"
  "/v2/actor-tasks/{actorTaskId}/runs":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@runs.yaml"
  "/v2/actor-tasks/{actorTaskId}/run-sync":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@run-sync.yaml"
  "/v2/actor-tasks/{actorTaskId}/run-sync-get-dataset-items":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@run-sync-get-dataset-items.yaml"
  "/v2/actor-tasks/{actorTaskId}/runs/last":
    $ref: "paths/actor-tasks/actor-tasks@{actorTaskId}@runs@last.yaml"
  /v2/actor-runs:
    $ref: paths/actor-runs/actor-runs.yaml
  "/v2/actor-runs/{runId}":
    $ref: paths/actor-runs/actor-runs@{runId}.yaml
  "/v2/actor-runs/{runId}/abort":
    $ref: paths/actor-runs/actor-runs@{runId}@abort.yaml
  "/v2/actor-runs/{runId}/metamorph":
    $ref: paths/actor-runs/actor-runs@{runId}@metamorph.yaml
  "/v2/actor-runs/{runId}/reboot":
    $ref: paths/actor-runs/actor-runs@{runId}@reboot.yaml
  "/v2/actor-runs/{runId}/resurrect":
    $ref: paths/actor-runs/actor-runs@{runId}@resurrect.yaml
  "/v2/actor-runs/{runId}/charge":
    $ref: paths/actor-runs/actor-runs@{runId}@charge.yaml
  /v2/actor-builds:
    $ref: paths/actor-builds/actor-builds.yaml
  "/v2/actor-builds/{buildId}":
    $ref: "paths/actor-builds/actor-builds@{buildId}.yaml"
  "/v2/actor-builds/{buildId}/abort":
    $ref: "paths/actor-builds/actor-builds@{buildId}@abort.yaml"
  "/v2/actor-builds/{buildId}/log":
    $ref: "paths/actor-builds/actor-builds@{buildId}@log.yaml"
  "/v2/actor-builds/{buildId}/openapi.json":
    $ref: "paths/actor-builds/actor-builds@{buildId}@openapi.json.yaml"
  /v2/key-value-stores:
    $ref: paths/key-value-stores/key-value-stores.yaml
  "/v2/key-value-stores/{storeId}":
    $ref: "paths/key-value-stores/key-value-stores@{storeId}.yaml"
  "/v2/key-value-stores/{storeId}/keys":
    $ref: "paths/key-value-stores/key-value-stores@{storeId}@keys.yaml"
  "/v2/key-value-stores/{storeId}/records":
    $ref: "paths/key-value-stores/key-value-stores@{storeId}@records.yaml"
  "/v2/key-value-stores/{storeId}/records/{recordKey}":
    $ref: "paths/key-value-stores/key-value-stores@{storeId}@records@{recordKey}.yaml"
  /v2/datasets:
    $ref: paths/datasets/datasets.yaml
  "/v2/datasets/{datasetId}":
    $ref: "paths/datasets/datasets@{datasetId}.yaml"
  "/v2/datasets/{datasetId}/items":
    $ref: "paths/datasets/datasets@{datasetId}@items.yaml"
  "/v2/datasets/{datasetId}/statistics":
    $ref: "paths/datasets/datasets@{datasetId}@statistics.yaml"
  /v2/request-queues:
    $ref: paths/request-queues/request-queues.yaml
  "/v2/request-queues/{queueId}":
    $ref: "paths/request-queues/request-queues@{queueId}.yaml"
  "/v2/request-queues/{queueId}/requests/batch":
    $ref: "paths/request-queues/request-queues@{queueId}@requests@batch.yaml"
  "/v2/request-queues/{queueId}/requests/unlock":
    $ref: "paths/request-queues/request-queues@{queueId}@requests@unlock.yaml"
  "/v2/request-queues/{queueId}/requests":
    $ref: "paths/request-queues/request-queues@{queueId}@requests.yaml"
  "/v2/request-queues/{queueId}/requests/{requestId}":
    $ref: "paths/request-queues/request-queues@{queueId}@requests@{requestId}.yaml"
  "/v2/request-queues/{queueId}/head":
    $ref: "paths/request-queues/request-queues@{queueId}@head.yaml"
  "/v2/request-queues/{queueId}/head/lock":
    $ref: "paths/request-queues/request-queues@{queueId}@head@lock.yaml"
  "/v2/request-queues/{queueId}/requests/{requestId}/lock":
    $ref: "paths/request-queues/request-queues@{queueId}@requests@{requestId}@lock.yaml"
  /v2/webhooks:
    $ref: paths/webhooks/webhooks.yaml
  "/v2/webhooks/{webhookId}":
    $ref: "paths/webhooks/webhooks@{webhookId}.yaml"
  "/v2/webhooks/{webhookId}/test":
    $ref: "paths/webhooks/webhooks@{webhookId}@test.yaml"
  "/v2/webhooks/{webhookId}/dispatches":
    $ref: "paths/webhooks/webhooks@{webhookId}@dispatches.yaml"
  /v2/webhook-dispatches:
    $ref: paths/webhook-dispatches/webhook-dispatches.yaml
  "/v2/webhook-dispatches/{dispatchId}":
    $ref: "paths/webhook-dispatches/webhook-dispatches@{dispatchId}.yaml"
  /v2/schedules:
    $ref: paths/schedules/schedules.yaml
  "/v2/schedules/{scheduleId}":
    $ref: "paths/schedules/schedules@{scheduleId}.yaml"
  "/v2/schedules/{scheduleId}/log":
    $ref: "paths/schedules/schedules@{scheduleId}@log.yaml"
  /v2/store:
    $ref: paths/store/store.yaml
  "/v2/logs/{buildOrRunId}":
    $ref: "paths/logs/logs@{buildOrRunId}.yaml"
  "/v2/users/{userId}":
    $ref: "paths/users/users@{userId}.yaml"
  /v2/users/me:
    $ref: paths/users/users@me.yaml
  /v2/users/me/usage/monthly:
    $ref: paths/users/users@me@usage@monthly.yaml
  /v2/users/me/limits:
    $ref: paths/users/users@me@limits.yaml
  /v2/browser-info:
    $ref: paths/tools/tools@browser-info.yaml
  /v2/tools/encode-and-sign:
    $ref: paths/tools/tools@encode-and-sign.yaml
  /v2/tools/decode-and-verify:
    $ref: paths/tools/tools@decode-and-verify.yaml
components:
  securitySchemes:
    httpBearer:
      $ref: components/securitySchemes/httpBearer.yaml
    apiKey:
      $ref: components/securitySchemes/apiKey.yaml
security:
  - httpBearer: []
  - apiKey: []
tags:
  $ref: components/tags.yaml
x-tagGroups:
  $ref: components/x-tag-groups.yaml