Sample 5

FORMAT: 1A
HOST: https://api.apify.com/
# Apify API
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.
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

[àpify-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
[àpify-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:** All requests with JSON payloads need to specify the `Content-Type:
application/json` HTTP header!
All API endpoints support the `method` query parameter that can override the HTTP
method.
For example, if you want to call a POST endpoint using a GET request, simply
add the query parameter `method=POST` to the URL and send the GET request.
This feature is especially useful if you want to call Apify API endpoints
from services that can only send GET requests.
## Authentication
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 Àuthorization` header as `Bearer <token>`.
E.g., Àuthorization: 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
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
Àuthorization` 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 Àpify.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
Most API endpoints return a JSON object with the `data` property:
```
{
"data": {
...
}
}
```
However, there are a few explicitly described exceptions, such as

Dataset [Get 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 èrror`. For example:
```
{
"error": {
"type": "record-not-found",
"message": "Store was not found."
}
}
```
See [Errors](#introduction/errors) for more details.
## Pagination
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 òffset` 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 èxclusiveStartKey` 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
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>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
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>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>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
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 èrror` 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>invalid-value</code></td>
<td>Invalid value provided: Comments required</td>
</tr>
<tr>
<td><code>invalid-record-key</code></td>
<td>Record key contains invalid character</td>
</tr>
<tr>
<td><code>token-not-provided</code></td>
<td>Authentication token was not provided</td>
</tr>
<tr>
<td><code>record-not-found</code></td>
<td>Store was not found</td>
</tr>
<tr>
<td><code>rate-limit-exceeded</code></td>
<td>You have exceeded the rate limit of 30 requests per second</td>
</tr>
<tr>
<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
All API endpoints limit the rate of requests in order to prevent overloading of
Apify servers by misbehaving clients.
The default rate limit is 30 requests per second and is applied to every API
endpoint except the following list
of endpoints that are rate limited to 200 requests per second:
* [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 of request queue requests
> For authenticated API endpoints (if you use an [authentication token]
(#authentication)), the limit is counted per user.
Storage API endpoints (when a token isn't used) count the limit per store ID.
Anonymous API endpoints count the limit per client IP adress. Each API endpoint
returns its rate limit in `X-RateLimit-Limit` header.
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"
}
}
```
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
There are three main ways to refer to a resource you're accessing via API.
- the resource ID (e.g. ìKkPcIgVvwmztduf8`)

- ùsername~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.
# Group Actors
The API endpoints described in this section enable you to manage, build and run
Apify actors.
For more information, see the <a
href="https://docs.apify.com/platform/actors">Actor documentation</a>.
Note that for all the API endpoints that accept the àctorId` parameter to specify
an actor,
you can pass either the actor ID (e.g. `HG7ML7M8z78YcAPEB`) or a tilde-separated
username of the actor owner and the actor name (e.g. `janedoe~my-actor`).
Some of the API endpoints return runs objects. Note that if any such run object
contains usage in dollars, your effective unit pricing at the time of query
has been used for computation of this dollar equivalent, and hence it should be
used only for informative purposes. You can learn more
about platform usage in the <a
href="https://docs.apify.com/platform/actors/running/usage-and-
resources#usage">documentation</a>.
## Actor collection [/v2/acts{?token,offset,limit,desc,my}]
+ Parameters
+ token: `soSkq9ekdmfOslopH` (string, required) - API authentication token.
### Get list of actors [GET]
Gets the list of all actors that the user created or used. The response is a list
of objects, where each object
contains a basic information about a single actor.
To only get actors created by the user, add the `my=1` query parameter.
The endpoint supports pagination using the `limit` and òffset` parameters and it
will not return more than 1000 records.
By default, the records are sorted by the `createdAt` field in ascending order,
therefore you can use pagination to incrementally fetch all actors while new
ones are still being created. To sort the records in descending order, use the
`desc=1`
parameter.
+ Parameters
+ my: true (boolean, optional) - If `true` or `1` then the returned list only
contains actors owned by the user. The default value is `false`.
+ offset: 10 (number, optional) - Number of records that should be skipped at
the start. The default value is `0`.
+ limit: 99 (number, optional) - Maximum number of records to return. The
default value as well as the maximum is `1000`.
+ desc: true (boolean, optional) - If `true` or `1` then the objects are sorted
by the `createdAt` field in descending order. By default, they are sorted in
ascending order.
+ Response 200 (application/json)
+ Attributes
- data (object, required)
- total: 2 (number, required)
- count: 2 (number, required)
- offset: 0 (number, required)
- limit: 1000 (number, required)
- desc: false (boolean, required)
- items (array[ActorShort1,ActorShort2], required)
### Create actor [POST]
Creates a new actor with settings specified in an Actor object passed as JSON in
the POST payload.
The response is the full actor object as returned by the
[Get actor](#reference/actors/actor-object/get-actor) endpoint.
The HTTP request must have the `Content-Type: application/json` HTTP header!
The actor needs to define at least one version of the source code.
For more information, see [Version object](#reference/actors/version-object).
If you want to make your actor

[public](https://docs.apify.com/platform/actors/publishing) using ìsPublic: true`,
you will need to provide the actor's `title` and the `categories` under which that
actor will be classified in Apify Store. For this, it's best to use the [constants
from our àpify-shared-js`
package](https://github.com/apify/apify-shared-js/blob/2d43ebc41ece9ad31cd6525bd523
fb86939bf860/packages/consts/src/consts.ts#L452-L471).
+ Request (application/json)
+ Attributes(ActCreate)
+ Headers
Location: https://api.apify.com/v2/acts/zdc3Pyhyz3m8vjDeM
+ Attributes
- data (Actor, required)
## Actor object [/v2/acts/{actorId}{?token}]
+ Parameters
+ actorId: `janedoe~my-actor` (string, required) - Actor ID or a tilde-

separated owner's username and actor name.
### Get actor [GET]
Gets an object that contains all the details about a specific actor.
+ Attributes
### Update actor [PUT]
Updates settings of an actor using values specified by an actor object passed as

JSON in the POST payload.
If the object does not define a specific property, its value will not be updated.
The response is the full actor object as returned by the

[Get actor](#reference/actors/actor-object/get-actor) endpoint.
The request needs to specify the `Content-Type: application/json` HTTP header!
When providing your API authentication token, we recommend using the request's
Àuthorization` header, rather than the URL. ([More
info](#introduction/authentication)).
If you want to make your actor

[public](https://docs.apify.com/platform/actors/publishing) using ìsPublic: true`,
you will need to provide the actor's `title` and the `categories` under which that
actor will be classified in Apify Store. For this, it's best to use the [constants
from our àpify-shared-js`
package](https://github.com/apify/apify-shared-js/blob/2d43ebc41ece9ad31cd6525bd523
fb86939bf860/packages/consts/src/consts.ts#L452-L471).
+ Attributes(ActUpdate)
+ Attributes
### Delete actor [DELETE]
Deletes an actor.
+ Attributes(object)
## Version collection [/v2/acts/{actorId}/versions{?token}]
+ Parameters

### Get list of versions [GET]
Gets the list of versions of a specific actor. The response is a JSON object with
the list
of [Version objects](#reference/actors/version-object), where each
contains basic information about a single version.
+ Attributes
- items (ListOfVersions, required)
### Create version [POST]
Creates a version of an actor using values specified in a [Version object]

(#reference/actors/version-object) passed as JSON in the POST payload.
The request must specify `versionNumber` and `sourceType` parameters (as strings)
in the JSON payload and a `Content-Type: application/json` HTTP header.
Each `sourceType` requires its own additional properties to be passed to the JSON
payload object. These are outlined in the [Version
object](#reference/actors/version-object) table below and in more detail in the
[Apify documentation](https://docs.apify.com/platform/actors/development/
deployment/source-types).
For example, if an Actor's source code is stored in a [GitHub

repository](https://docs.apify.com/platform/actors/development/deployment/source-
types#git-repository), you will set the `sourceType` to `GIT_REPO` and pass the
repository's URL in the `gitRepoUrl` property.
```
{
"versionNumber": "0.1",
"sourceType": "GIT_REPO",
"gitRepoUrl": "https://github.com/my-github-account/actor-repo"
}
```
The response is the [Version object](#reference/actors/version-object) as returned

by the
[Get version](#reference/actors/version-object/get-version) endpoint.
+ Attributes(VersionUpdate)
+ Request
{
"versionNumber": "0.1",
"sourceType": "GIT_REPO",
"gitRepoUrl": "https://github.com/my-github-account/actor-repo"
}
+ Headers
Location: https://api.apify.com/v2/acts/zdc3Pyhyz3m8vjDeM/versions/0.0
+ Attributes
- data (Version, required)
## Version object [/v2/acts/{actorId}/versions/{versionNumber}{?token}]
The **Version object** contains the source code of a specific version of an actor.
The `sourceType` property indicates where the source code is hosted, and based
on its value the Version object has the following additional property:
<table>
<tr>
<td><code>"SOURCE_FILES"</code></td>
<td>
Source code is comprised of multiple files specified in the
<code>sourceFiles</code> array.
Each item of the array is an object with the following fields:<br>
<code>name</code></li> - File path and name<br>
<code>format</code></li> - Format of the content, can be either
<code>"TEXT"</code> or <code>"BASE64"</code><br>
<code>content</code></li> - File content<br>
<br>
Source files can be shown and edited in the Apify Console's Web IDE.
</td>
</tr>
<tr>
<td><code>"GIT_REPO"</code></td>
<td>
Source code is cloned from a Git repository, whose URL is specified in the
<code>gitRepoUrl</code> field.
</td>
</tr>
<tr>
<td><code>"TARBALL"</code></td>
<td>
Source code is downloaded using a tarball or Zip file from a URL specified
in the <code>tarballUrl</code> field.
</td>
</tr>
<tr>
<td><code>"GITHUB_GIST"</code></td>
<td>
Source code is taken from a GitHub Gist, whose URL is specified in the
<code>gitHubGistUrl</code> field.
</td>
</tr>
</table>
For more information about source code and actor versions, see [Source code]
(https://docs.apify.com/platform/actors/development/actor-definition/source-code)
in Actors documentation.
+ Parameters

+ versionNumber: `1.0` (string, required) - Actor major and minor version of
the actor.
### Get version [GET]
Gets a [Version object](#reference/actors/version-object) that contains all the

details about a specific version of an actor.
+ Attributes
### Update version [PUT]
Updates actor version using values specified by a [Version

object](#reference/actors/version-object)
passed as JSON in the POST payload.
The response is the [Version object](#reference/actors/version-object) as returned

by the
[Get version](#reference/actors/version-object/get-version) endpoint.
+ Attributes(VersionUpdate)
+ Attributes
### Delete version [DELETE]
Deletes a specific version of actor's source code.
## Environment variable collection

[/v2/acts/{actorId}/versions/{versionNumber}/env-vars{?token}]
+ Parameters

+ versionNumber: `0.1` (string, required) - Actor version
### Get list of environment variables [GET]
Gets the list of environment variables for a specific version of an actor. The
response is a JSON object with the list
of [EnvVar objects](#reference/actors/environment-variable-object), where each
contains basic information about a single environment variable.
+ Attributes
- items (ListOfEnvVars, required)
### Create environment variable [POST]
Creates an environment variable of an actor using values specified in a [EnvVar

object](#reference/actors/environment-variable-object) passed as JSON in the POST
payload.
The request must specify `name` and `value` parameters (as strings) in the JSON
payload and a `Content-Type: application/json` HTTP header.
```
{
"name": "ENV_VAR_NAME",
"value": "my-env-var"
}
```
The response is the [EnvVar object](#reference/actors/environment-variable-object)

as returned by the
[Get environment variable](#reference/actors/environment-variable-object/get-
environment-variable) endpoint.
+ Attributes(EnvVarUpdate)
+ Request
{
"name": "ENV_VAR_NAME",
"value": "my-env-var"
}
+ Headers
Location:
https://api.apify.com/v2/acts/zdc3Pyhyz3m8vjDeM/versions/1.0/env-vars/ENV_VAR_NAME
+ Attributes
- data (EnvVar, required)
## Environment variable object [/v2/acts/{actorId}/versions/{versionNumber}/env-

vars/{envVarName}{?token}]
+ Parameters

+ versionNumber: `0.1` (string, required) - Actor version
+ envVarName: `MY_ENV_VAR` (string, required) - The name of the environment
variable
### Get environment variable [GET]
Gets a [EnvVar object](#reference/actors/environment-variable-object) that contains

all the details about a specific environment variable of an actor.
If ìsSecret` is set to `true`, then `value` will never be returned.
+ Attributes
### Update environment variable [PUT]
Updates actor environment variable using values specified by a [EnvVar object]

(#reference/actors/environment-variable-object)
passed as JSON in the POST payload.

The response is the [EnvVar object](#reference/actors/environment-variable-object)

as returned by the
[Get environment variable](#reference/actors/environment-variable-object/get-
environment-variable) endpoint.
+ Attributes(EnvVarUpdate)
+ Attributes
### Delete environment variable [DELETE]
Deletes a specific environment variable.
## Webhook collection [/v2/acts/{actorId}/webhooks{?token,offset,limit,desc}]
+ Parameters

### Get list of webhooks [GET]
Gets the list of webhooks of a specific actor. The response is a JSON with the list
contains basic information about a single webhook.
to sort the records in descending order, use the `desc=1` parameter.
+ Parameters

+ offset: 10 (number, optional) - Number of array elements that should be
skipped at the start. The default value is `0`.
+ limit: 99 (number, optional) - Maximum number of array elements to return.
The default value as well as the maximum is `1000`.
ascending order.

+ Attributes
- items (array[Webhook,Webhook], required)
## Build collection [/v2/acts/{actorId}/builds{?

token,offset,limit,desc,waitForFinish,version,useCache,betaPackages,tag}]
+ Parameters

### Get list of builds [GET]
Gets the list of builds of a specific actor. The response is a JSON with the list
contains basic information about a single build.
By default, the records are sorted by the `startedAt` field in ascending order,
therefore you can use pagination to incrementally fetch all builds while new
ones are still being started. To sort the records in descending order, use the
`desc=1`
parameter.
+ Parameters

by the `startedAt` field in descending order. By default, they are sorted in
ascending order.
+ Attributes
- items (array[BuildShort1,BuildShort2], required)
### Build actor [POST]
Builds an actor.
The response is the build object as returned by the
[Get build](#reference/actors/build-object/get-build) endpoint.
+ Parameters
+ version: `0.0` (string, required) - Actor version number to be built.

+ useCache: true (boolean, optional) - If `true` or `1`, the system will use a
cache to speed up the build process. By default, cache is not used.
+ betaPackages: true (boolean, optional) - If `true` or `1` then the actor is
built with beta versions of Apify NPM packages. By default, the build uses `latest`
packages.
+ tag: `latest` (string, optional) - Tag to be applied to the build on success.
By default, the tag is taken from actor version's `buildTag` property.
+ waitForFinish: 60 (number, optional) - The maximum number of seconds the
server waits for the build to finish. By default it is `0`, the maximum value is
`60`. 
If the build finishes in time then
the returned build object will have a terminal status (e.g. `SUCCEEDED`),
otherwise it will have a transitional
status (e.g. `RUNNING`).
+ Headers
Location:
https://api.apify.com/v2/acts/zdc3Pyhyz3m8vjDeM/runs/HG7ML7M8z78YcAPEB
+ Attributes
- data (Build, required)
## Build object - deprecated [/v2/acts/{actorId}/builds/{buildId}{?

token,waitForFinish}]
API endpoints related to build of the actor were moved under new namespace [actor
builds](#reference/actor-builds).
+ Parameters

### Get build [GET]
Gets an object that contains all the details about a specific build of an actor.
By passing the optional `waitForFinish` parameter the API endpoint will

synchronously wait for the build to finish.
This is useful to avoid periodic polling when waiting for an actor build to finish.
This endpoint does not require the authentication token. The calls are
authenticated using a hard-to-guess ID of the build.
+ Parameters
+ buildId: `soSkq9ekdmfOslopH` (string, required) - ID of the build you want to

get, found in the build's Ìnfo` tab.
If the build finishes in time then the
returned build object will have a terminal status (e.g. `SUCCEEDED`),
+ token: `soSkq9ekdmfOslopH` (string, optional) - API authentication token. It
is only required for private actors.
Builds of public actors can be queried without any token.
+ Attributes
## Abort build [/v2/acts/{actorId}/builds/{buildId}/abort{?token}]
### Abort build [POST]
Aborts an actor build and returns an object that contains all the details about the
build.
Only builds that are starting or running are aborted. For builds with status
`FINISHED`, `FAILED`, ÀBORTING` and `TIMED-OUT` this call does nothing.
+ Parameters

+ buildId: `3KH8gEpp4d8uQSe8T` (string, required) - Build ID.
+ Attributes
- data (BuildAborted, required)
## Run collection [/v2/acts/{actorId}/runs{?

token,offset,limit,desc,waitForFinish,timeout,memory,build,webhooks,status}]
+ Parameters

### Get list of runs [GET]
Gets the list of runs of a specific actor. The response is a list of objects, where
each object
contains basic information about a single actor run.
will not return more than 1000
array elements.
By default, the records are sorted by the `startedAt` field in ascending order,
therefore you can use pagination to incrementally fetch all records while new
ones are still being created. To sort the records in descending order, use `desc=1`
parameter. You can also filter runs by status ([available
statuses](https://docs.apify.com/platform/actors/running/runs-and-
builds#lifecycle)).
+ Parameters

ascending order.
+ status: SUCCEEDED (string, optional) - Return only runs with the provided
status ([available statuses](https://docs.apify.com/platform/actors/running/runs-
and-builds#lifecycle))
+ Attributes
- items (array[RunShort1,RunShort2], required)
### Run actor [POST]
Runs an actor and immediately returns without waiting for the run to finish.
The POST payload including its `Content-Type` header is passed as ÌNPUT` to the
actor (usually àpplication/json`).
The actor is started with the default options; you can override them using various
URL query parameters.
The response is the Run object as returned by the [Get

run](#reference/actor-runs/run-object-and-its-storages/get-run) API endpoint.
If you want to wait for the run to finish and receive the actual output of the
actor as the response,
please use one of the [Run actor synchronously](#reference/actors/run-actor-
synchronously) API endpoints instead.
To fetch the actor run results that are typically stored in the default dataset,
you'll need to pass the ID received in the `defaultDatasetId` field
received in the response JSON to the [Get items](#reference/datasets/item-
collection/get-items) API endpoint.
+ Parameters
+ token: `soSkq9ekdmfOslopH` (string, optional) - API authentication token.

Public actors that are configured to be anonymously runnable do not require the
token.
+ timeout: 60 (number, optional) - Optional timeout for the run, in seconds. By
default, the run uses a timeout specified in the default run configuration for the
actor.
+ memory: 256 (number, optional) - Memory limit for the run, in megabytes. The
amount of memory can be set to a power of 2 with a minimum of 128. By default, the
run uses a memory limit specified in the default run configuration for the actor.
+ maxItems: 1000 (number, optional) - The maximum number of items that the
actor run should return. This is useful for pay-per-result actors, as it allows you
to limit the number of results that will be charged to your subscription. You can
access the maximum number of items in your actor by using the
ÀCTOR_MAX_PAID_DATASET_ITEMS` environment variable.
+ build: `0.1.234` (string, optional) - Specifies the actor build to run. It
can be either a build tag or build number. By default, the run uses the build
specified in the default run configuration for the actor (typically `latest`).
server waits for the run to finish. By default, it is `0`, the maximum value is
returned run object will have a terminal status (e.g. `SUCCEEDED`),
+ webhooks: `dGhpcyBpcyBqdXN0IGV4YW1wbGUK...` (string, optional) - Specifies
optional webhooks associated with the actor run, which can be used to receive a
notification
e.g. when the actor finished or failed. The value is a Base64-encoded JSON
array of objects defining the webhooks. For more information, see
[Webhooks
documenation](https://docs.apify.com/platform/integrations/webhooks).
+ Request
+ Headers
Content-Type: application/json
+ Attributes
- foo: `bar`
+ Headers
Location:
https://api.apify.com/v2/acts/zdc3Pyhyz3m8vjDeM/runs/HG7ML7M8z78YcAPEB
+ Attributes
- data (Run, required)
## Run actor synchronously [/v2/acts/{actorId}/run-sync{?

token,outputRecordKey,timeout,memory,build,webhooks}]
+ Parameters

Public actors that are configured to be anonymously runnable do not require token
parameter.
+ outputRecordKey: ÒUTPUT` (string, optional) - Key of the record from run's
default key-value store to be returned
in the response. By default,
it is ÒUTPUT`.
actor.
notification
[Webhooks
### With input [POST]
Runs a specific actor and returns its output.
actor (usually <code>application/json</code>).
The HTTP response contains actor's ÒUTPUT` record from its default key-value
store.
The actor is started with the default options; you can override them using various
URL query parameters.
If the actor run exceeds 300 seconds,
the HTTP response will have status 408 (Request Timeout).
Beware that it might be impossible to maintain an idle HTTP connection for a long
period of time,
due to client timeout or network conditions. Make sure your HTTP client is
configured to have a long enough connection timeout.
If the connection breaks, you will not receive any information about the run and
its status.
To run the actor asynchronously, use the [Run actor](#reference/actors/run-

collection/run-actor) API endpoint instead.
+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Response 201
+ Headers
+ Attributes
- bar: `foo`
+ Response 400
+ Headers
+ Attributes
- error (object, required)
- type: `run-failed` (string, required)
- message: Àctor run did not succeed (run ID: 55uatRrZib4xbZs, status:
FAILED)` (string, required)
+ Response 408
+ Headers
+ Attributes
- type: `run-timeout-exceeded` (string, required)
- message: Àctor run exceeded timeout of 300 seconds for this API
endpoint` (string, required)
### Without input [GET]
Runs a specific actor and returns its output.

The run must finish in 300 seconds otherwise
the API endpoint returns a timeout error.
The actor is not passed any input.
period of time,
its status.

+ Response 201
+ Headers
+ Attributes
- foo: `bar`
+ Response 400
+ Headers
+ Attributes
+ Response 408
+ Headers
+ Attributes
enpoint` (string, required)
## Run Actor synchronously and get dataset items [/v2/acts/{actorId}/run-sync-get-

dataset-items{?
token,timeout,memory,build,webhooks,format,offset,limit,attachment,delimiter,bom,de
sc,xmlRoot,xmlRow,fields,omit,unwind,flatten,skipHeaderRow,token,clean,skipHidden,s
kipEmpty,simplified,skipFailedPages}]
+ Parameters

Public actors that are configured to be anonymously runnable do not require token
parameter.
actor.
notification
[Webhooks
+ format: `json` (string, optional) - Format of the results, possible values
are: `json`, `jsonl`, `csv`, `html`, `xlsx`, `xml` and `rss`. The default value is
`json`.
+ clean: `false` (boolean, optional) - If `true` or `1` then the API endpoint
returns only non-empty items and skips hidden fields
(i.e. fields starting with the # character).
The `clean` parameter is just a shortcut for `skipHidden=true` and
`skipEmpty=true` parameters.
Note that since some objects might be skipped from the output, that the
result might contain less items than the `limit` value.
+ offset: 0 (number, optional) - Number of items that should be skipped at the
start. The default value is `0`.
+ limit: 99 (number, optional) - Maximum number of items to return. By default
there is no limit.
+ fields: `myValue,myOtherValue` (string, optional) - A comma-separated list of
fields which should be picked from the items,
only these fields will remain in the resulting record objects.
Note that the fields in the outputted items are sorted the same way as they
are specified in the `fields` query parameter.
You can use this feature to effectively fix the output format.
+ omit: `myValue,myOtherValue` (string, optional) - A comma-separated list of
fields which should be omitted from the items.
+ unwind: `myValue` (string, optional) - Name of a field which should be
unwound. If the field is an array then every element of
the array will become a separate record and merged with parent object.
If the unwound field is an object then it is merged with the parent object
If the unwound field is missing or its value is neither an array nor an
object and therefore cannot be merged with a parent object then the item gets
preserved as it is.
Note that the unwound items ignore the `desc` parameter.
+ flatten: `myValue` (string, optional) - A comma-separated list of fields
which should transform nested objects into flat structures.
For example, with `flatten="foo"` the object `{"foo":{"bar": "hello"}}` is
turned into `{"foo.bar": "hello"}`.
The original object with properties is replaced with the flattened object.
+ desc: true (boolean, optional) - By default, results are returned in the same
order as they were stored. To reverse the order, set this parameter to `true` or
`1`.
+ attachment: true (boolean, optional) - If `true` or `1` then the response
will define the `Content-Disposition: attachment` header, forcing a web browser to
download the file rather than to display it. By default this header is not present.
+ delimiter: `;` (string, optional) - A delimiter character for CSV files, only
used if `format=csv`. You might need to URL-encode the character (e.g. use `%09`
for tab or `%3B` for semicolon). The default delimiter is a simple comma (`,`).
+ bom: false (boolean, optional) - All text responses are encoded in UTF-8
encoding. By default, the `format=csv` files are prefixed with
the UTF-8 Byte Order Mark (BOM), while `json`, `jsonl`, `xml`, `html` and
`rss` files are not.
If you want to override this default behavior, specify `bom=1` query
parameter to include the BOM or `bom=0` to skip it.
+ xmlRoot: ìtems` (string, optional) - Overrides default root element name of
`xml` output. By default the root element is ìtems`.
+ xmlRow: ìtem` (string, optional) - Overrides default element name that wraps
each page or page function result object in `xml` output. By default the element
name is ìtem`.
+ skipHeaderRow: true (boolean, optional) - If `true` or `1` then header row in
the `csv` format is skipped.
+ skipHidden: `false` (boolean, optional) - If `true` or `1` then hidden fields
are skipped from the output,
i.e. fields starting with the `#` character.
+ skipEmpty: `false` (boolean, optional) - If `true` or `1` then empty items
are skipped from the output.
Note that if used, the results might contain less items than the limit
value.
+ simplified: `false` (boolean, optional) - If `true` or `1` then, the endpoint
applies the `fields=url,pageFunctionResult,errorInfo`
and ùnwind=pageFunctionResult` query parameters. This feature is used to
emulate simplified results provided by the
legacy Apify Crawler product and it's not recommended to use it in new
integrations.
+ skipFailedPages: `false` (boolean, optional) - If `true` or `1` then, the all
the items with errorInfo property will be skipped from the output.
This feature is here to emulate functionality of API version 1 used for the
integrations.
### Run actor synchronously with input and get dataset items [POST]
Runs a specific actor and returns its dataset items.
actor (usually àpplication/json`).
The HTTP response contains the actor's dataset items, while the format of items
depends on specifying dataset items' `format` parameter.
You can send all the same options in parameters as the [Get Dataset Items]
(#reference/datasets/item-collection/get-items) API endpoint.
The actor is started with the default options; you can override them using URL
query parameters.
If the actor run exceeds 300 seconds,
the HTTP response will return the 408 status code (Request Timeout).
period of time,
its status.

+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Response 201
+ Attributes
+ format: `json`
+ Headers
X-Apifier-Pagination-Offset: 0
X-Apifier-Pagination-Limit: 100
X-Apifier-Pagination-Count: 100
X-Apifier-Pagination-Total: 10204
+ Body
[
{
myValue: 'some value',
myOtherValue: 'some other value'
}
]
+ Response 400
+ Headers
+ Attributes
+ Response 408
+ Headers
+ Attributes
### Run actor synchronously without input and get dataset items [GET]
Runs a specific actor and returns its dataset items.

The actor is not passed any input.
It allows to send all possible options in parameters from [Get Dataset Items]
period of time,
its status.

+ Response 201
+ Attributes
+ format: `json`
+ Headers
+ Body
[
{
}
]
+ Response 400
+ Headers
+ Attributes
+ Response 408
+ Headers
+ Attributes
enpoint` (string, required)
## Run object - deprecated [/v2/acts/{actorId}/runs/{runId}{?token,waitForFinish}]

API endpoints related to run of the actor were moved under new namespace [actor
runs](#reference/actor-runs).
### Get run [GET]
Gets an object that contains all the details about a specific run of an actor.

synchronously wait for the run to finish.
This is useful to avoid periodic polling when waiting for actor run to complete.
authenticated using a hard-to-guess ID of the run.
+ Parameters

+ runId: `3KH8gEpp4d8uQSe8T` (string, required) - Run ID.
server waits for the run to finish. By default it is `0`, the maximum value is
the returned run object will have a terminal status (e.g. `SUCCEEDED`),
otherwise it will have a
transitional status (e.g. `RUNNING`).
+ Attributes
## Abort run [/v2/acts/{actorId}/runs/{runId}/abort{?token,gracefully}]
### Abort run [POST]
Aborts an actor run and returns an object that contains all the details about the
run.
Only runs that are starting or running are aborted. For runs with status
+ Parameters

+ gracefully: `true` (boolean, optional) - If true passed, the actor run
will abort gracefully.
It will send àborting` and
`persistState` event into run and force-stop the run after 30 seconds.
It is helpful in cases where you
plan to resurrect the run later.
+ Attributes
- data (RunAborted, required)
## Metamorph run [/v2/acts/{actorId}/runs/{runId}/metamorph{?

token,build,targetActorId}]
### Metamorph run [POST]
Transforms an actor run into a run of another actor with a new input.
This is useful if you want to use another actor to finish the work
of your current actor run, without the need to create a completely new run and
waiting for its finish.
For the users of your actors, the metamorph operation is transparent, they will
just see your actor got the work done.
There is a limit on how many times you can metamorph a single run. You can check
the limit in [the Actor runtime
limits](https://docs.apify.com/platform/limits#actor-limits).
Internally, the system stops the Docker container corresponding to the actor run
and starts a new container using a different Docker image.
All the default storages are preserved and the new input is stored under the
ÌNPUT-METAMORPH-1` key in the same default key-value store.
For more information, see the [Actor

docs](https://docs.apify.com/platform/actors/development/programming-interface/
metamorph).
+ Parameters

+ runId: `3KH8gEpp4d8uQSe8T` (string, required) - Actor run ID.
+ targetActorId: `HDSasDasz78YcAPEB` (string, required) - ID of a target actor
that the run should be transformed into.
+ build: `beta` (string, optional) - Optional build of the target actor.
It can be either a build tag or build number. By default, the run uses the
build specified in the default run configuration for the target actor (typically
`latest`).
+ Attributes
- data (RunMetamorphed, required)
## Resurrect run [/v2/acts/{actorId}/runs/{runId}/resurrect{?

token,build,timeout,memory}]
### Resurrect run [POST]
Resurrects a finished actor run and returns an object that contains all the details
about the resurrected run.
Only finished runs, i.e. runs with status `FINISHED`, `FAILED`, ÀBORTED` and
`TIMED-OUT` can be resurrected.
Run status will be updated to RUNNING and its container will be restarted with the
same storages
(the same behaviour as when the run gets migrated to the new server).

docs](https://docs.apify.com/platform/actors/running/runs-and-builds#resurrection-
of-finished-run).
+ Parameters

specified in the run that is being resurrected (typically `latest`).
default, the run uses a timeout specified in the run that is being resurrected.
run uses a memory limit specified in the run that is being resurrected.
+ Attributes
## Last run object and its storages [/v2/acts/{actorId}/runs/last/{?token,status}]
This is not a single endpoint, but an entire group of endpoints that lets you to
retrieve and manage the last run of given actor or any of its default storages.
All the endpoints require an authentication token.
The endpoints accept the same HTTP methods and query parameters as
the respective storage endpoints.
The base path represents the last actor run object is:
`/v2/acts/{actorId}/runs/last{?token,status}`
Using the `status` query parameter you can ensure to only get a run with a certain
status
(e.g. `status=SUCCEEDED`). The output of this endpoint and other query parameters
are the same as in the [Run object](#reference/actors/run-object) endpoint.
In order to access the default storages of the last actor run, i.e. log, key-value
store, dataset and request queue,
use the following endpoints:
* `/v2/acts/{actorId}/runs/last/log{?token,status}`
* `/v2/acts/{actorId}/runs/last/key-value-store{?token,status}`
* `/v2/acts/{actorId}/runs/last/dataset{?token,status}`
* `/v2/acts/{actorId}/runs/last/request-queue{?token,status}`
These API endpoints have the same usage as the equivalent storage endpoints.
For example,
`/v2/acts/{actorId}/runs/last/key-value-store` has the same HTTP method and
parameters as the
[Key-value store object](#reference/key-value-stores/store-object) endpoint.
Additionally, each of the above API endpoints supports all sub-endpoints

of the original one:
#### Key-value store
* `/v2/acts/{actorId}/runs/last/key-value-store/keys{?token,status}` [Key
collection](#reference/key-value-stores/key-collection)
* `/v2/acts/{actorId}/runs/last/key-value-store/records/{recordKey}{?token,status}`
[Record](#reference/key-value-stores/record)
#### Dataset
* `/v2/acts/{actorId}/runs/last/dataset/items{?token,status}` [Item collection]

(#reference/datasets/item-collection)
#### Request queue
* `/v2/acts/{actorId}/runs/last/request-queue/requests{?token,status}` [Request
collection](#reference/request-queues/request-collection)
* `/v2/acts/{actorId}/runs/last/request-queue/requests/{requestId}{?token,status}`
[Request collection](#reference/request-queues/request)
* `/v2/acts/{actorId}/runs/last/request-queue/head{?token,status}` [Queue head]
(#reference/request-queues/queue-head)
For example, to download data from a dataset of the last succeeded actor run in XML
format,
send HTTP GET request to the following URL:
```
https://api.apify.com/v2/acts/{actorId}/runs/last/dataset/items?
token={yourApiToken}&format=xml&status=SUCCEEDED
```
In order to save new items to the dataset, send HTTP POST request with JSON payload
to the same URL.
+ Parameters

+ status: `SUCCEEDED` (string, optional) - Filter for the run status.
### Get last run [GET]
+ Attributes
# Group Actor tasks
The API endpoints described in this section enable you to manage and run Apify
actor tasks.
href="https://docs.apify.com/platform/actors/running/tasks">Actor tasks
documentation</a>.
Note that for all the API endpoints that accept the àctorTaskId` parameter to
specify a task,
you can pass either the task ID (e.g. `HG7ML7M8z78YcAPEB`) or a tilde-separated
username of the task's owner and the task's name (e.g. `janedoe~my-task`).
Some of the API endpoints return runs objects. Note that if any such run object
contains usage in dollars, your effective unit pricing at the time of query
used only for informative purposes. You can learn more
about platform usage in the <a
## Task collection [/v2/actor-tasks{?token,offset,limit,desc}]
+ Parameters
### Get list of tasks [GET]

Gets the complete list of tasks that a user has created or used. The response is a
list of objects in which each object contains essential information about a single
task.
The endpoint supports pagination using the `limit` and òffset` parameters, and it
does not return more than a 1000 records.
By default, the records are sorted by the `createdAt` field in ascending order;
therefore you can use pagination to incrementally fetch all tasks while new
`desc=1`
parameter.
+ Parameters

ascending order.
+ Attributes
- items (array[TaskShort1,TaskShort2], required)
### Create task [POST]
Create a new task with settings specified by the object passed as JSON in the POST
payload.
The response is the full task object as returned by the
[Get task](#reference/tasks/task-object/get-task) endpoint.
+ Attributes(TaskCreate)
+ Headers
Location: https://api.apify.com/v2/actor-tasks/zdc3Pyhyz3m8vjDeM
+ Attributes
- data (Task, required)
## Task object [/v2/actor-tasks/{actorTaskId}{?token}]
+ Parameters
+ actorTaskId: `janedoe~my-task` (string, required) - Task ID or a tilde-

separated owner's username and task's name.
### Get task [GET]
Get an object that contains all the details about a task.
+ Attributes
### Update task [PUT]
Update settings of a task using values specified by an object passed as JSON in the
POST payload.
If the object does not define a specific property, its value is not updated.
The response is the full task object as returned by the

[Get task](#reference/tasks/task-object/get-task) endpoint.
+ Attributes(TaskUpdate)
+ Attributes
### Delete task [DELETE]
Delete the task specified through the àctorTaskId` parameter.
## Task input object [/v2/actor-tasks/{actorTaskId}/input{?token}]
+ Parameters

### Get task input [GET]
Returns the input of a given task.
+ Attributes
- myField1: `some-value` (string, nullable)
- myField2: ànother-value` (string, nullable)
- myField3: 1 (number, nullable)
### Update task input [PUT]
Updates the input of a task using values specified by an object passed as JSON in
the PUT payload.
If the object does not define a specific property, its value is not updated.
The response is the full task input as returned by the

[Get task](#reference/tasks/task-input-object/get-task-input) endpoint.
+ Attributes
- myField2: ùpdated-value` (string, nullable)
+ Attributes
- myField1: `some-value` (string, nullable)
- myField2: ùpdated-value` (string, nullable)
- myField3: 1 (number, nullable)
## Webhook collection [/v2/actor-tasks/{actorTaskId}/webhooks{?

token,offset,limit,desc}]
+ Parameters

Gets the list of webhooks of a specific actor task. The response is a JSON with the
list of objects, where each object
contains basic information about a single webhook.
to sort the records in descending order, use the `desc=1` parameter.
+ Parameters

ascending order.
+ Attributes
- items (array[Webhook,Webhook], required)
## Run collection [/v2/actor-tasks/{actorTaskId}/runs{?

token,offset,limit,desc,waitForFinish,webhooks,timeout,memory,build,status}]
+ Parameters

### Get list of task runs [GET]
Get a list of runs of a specific task. The response is a list of objects, where
each object
contains essential information about a single task run.
The endpoint supports pagination using the `limit` and òffset` parameters, and it
does not return more than a 1000
array elements.
By default, the records are sorted by the `startedAt` field in ascending order;
therefore you can use pagination to incrementally fetch all records while new
`desc=1`
builds#lifecycle)).
+ Parameters

ascending order.
+ Attributes
### Run task [POST]
Runs an actor task and immediately returns without waiting for the run to finish.
Optionally, you can override the actor input configuration by passing a JSON object
as the POST payload
and setting the `Content-Type: application/json` HTTP header.
Note that if the object in the POST payload does not define a particular input
property,
the actor run uses the default value defined by the task (or actor's input schema
if not defined by the task).
The response is the actor Run object as returned by the [Get run](#reference/actor-
runs/run-object-and-its-storages/get-run) endpoint.
If you want to wait for the run to finish and receive the actual output of the
actor run as the response,
use one of the [Run task synchronously](#reference/actor-tasks/run-task-
synchronously) API endpoints instead.
To fetch the actor run results that are typically stored in the default dataset,
you'll need to pass the ID received in the `defaultDatasetId` field
received in the response JSON to the [Get items](#reference/datasets/item-
collection/get-items) API endpoint.
+ Parameters

default, the run uses a timeout specified in the task settings.
run uses a memory limit specified in the task settings.
specified in the task settings (typically `latest`).
server waits for the run to finish. By default, it is `0`, the maximum value is
If the build finishes in time then the returned run object will have a
terminal status (e.g. `SUCCEEDED`),
otherwise it will have a transitional status (e.g. `RUNNING`).
notification
array of objects defining the webhooks.
**Note**: if you already have a webhook set up for the actor or task, you do
not have to add it again here.
For more information, see
[Webhooks
+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Headers
Location:
https://api.apify.com/v2/actor-tasks/zdc3Pyhyz3m8vjDeM/runs/HG7ML7M8z78YcAPEB
+ Attributes
- data (TaskRun, required)
## Run task synchronously [/v2/actor-tasks/{actorTaskId}/run-sync{?

token,outputRecordKey,webhooks,timeout,memory,build}]
+ Parameters

+ maxItems: 1000 (number, optional) - The maximum number of items that the task
run should return. This is useful for pay-per-result tasks, as it allows you to
limit the number of results that will be charged to your subscription. You can
+ outputRecordKey: ÒUTPUT` (string, optional) - Key of the record from run's
default key-value store to be returned
in the response. By default, it is ÒUTPUT`.
notification
[Webhooks
### Run task synchronously (POST) [POST]
Runs an actor task and synchronously returns its output.

as the POST payload
property,
the actor run uses the default value defined by the task (or actor's input schema
if not defined by the task).
Beware that it might be impossible to maintain an idle HTTP connection for an

extended period,
its status.
Input fields from actor task configuration can be overloaded with values passed as
the POST payload.
Just make sure to specify `Content-Type` header to be àpplication/json` and input
to be an object.
To run the task asynchronously, use the [Run task](#reference/actor-tasks/run-

collection/run-task) API endpoint instead.
+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Response 201
+ Headers
+ Attributes
- bar: `foo`
+ Response 400
+ Headers
+ Attributes
### Run task synchronously (GET) [GET]
Run a specific task and return its output.


extended period,
its status.
To run the Task asynchronously, use the [Run task asynchronously](#reference/actor-

tasks/run-collection/run-task) endpoint instead.
+ Response 201
+ Headers
+ Attributes
- bar: `foo`
+ Response 400
+ Headers
+ Attributes
+ Response 408
+ Headers
+ Attributes
## Run task synchronously and get dataset items [/v2/actor-tasks/{actorTaskId}/run-
sync-get-dataset-items{?
token,webhooks,timeout,memory,build,format,offset,limit,attachment,delimiter,bom,de
sc,xmlRoot,xmlRow,fields,omit,unwind,flatten,skipHeaderRow,token,clean,skipHidden,s
kipEmpty,simplified,skipFailedPages}]
+ Parameters

+ maxItems: 1000 (number, optional) - The maximum number of items that the task
run should return. This is useful for pay-per-result tasks, as it allows you to
limit the number of results that will be charged to your subscription. You can
notification
[Webhooks
`json`.
there is no limit.
preserved as it is.
`1`.
name is ìtem`.
Note that if used, the results might contain less items than the limit value.
integrations.
integrations.
### Run task synchronously and get dataset items (POST) [POST]
Runs an actor task and synchronously returns its dataset items.

as the POST payload
property,
the actor run uses the default value defined by the task (or the actor's input
schema if not defined by the task).

extended period,
its status.
Input fields from actor task configuration can be overloaded with values passed as
the POST payload.
Just make sure to specify the `Content-Type` header as àpplication/json` and that
the input is an object.
To run the task asynchronously, use the [Run task](#reference/actor-tasks/run-

collection/run-task) API endpoint instead.
+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Response 201
+ Attributes
+ format: `json`
+ Headers
+ Body
[
{
}
]
+ Response 400
+ Headers
+ Attributes
### Run task synchronously and get dataset items (GET) [GET]
Run a specific task and return its dataset items.


extended period,
its status.
To run the Task asynchronously, use the [Run task asynchronously](#reference/actor-

tasks/run-collection/run-task) endpoint instead.
+ Response 201
+ Attributes
+ format: `json`
+ Headers
+ Body
[
{
}
]
+ Response 400
+ Headers
+ Attributes
+ Response 408
+ Headers
+ Attributes
## Last run object and its storages [/v2/acts/{actorId}/runs/last/{?

token,status,actorTaskId}]
This is not a single endpoint, but an entire group of endpoints that lets you to
retrieve and manage the last run of given actor task or any of its default
storages.
All the endpoints require an authentication token.
The base path represents the last actor task run object is:
`/v2/actor-tasks/{actorTaskId}/runs/last{?token,status}`
Using the `status` query parameter you can ensure to only get a run with a certain
status
(e.g. `status=SUCCEEDED`). The output of this endpoint and other query parameters
are the same as in the [Run object](#reference/actors/run-object) endpoint.
In order to access the default storages of the last actor task run, i.e. log, key-
value store, dataset and request queue,
* `/v2/actor-tasks/{actorTaskId}/runs/last/log{?token,status}`
* `/v2/actor-tasks/{actorTaskId}/runs/last/key-value-store{?token,status}`
* `/v2/actor-tasks/{actorTaskId}/runs/last/dataset{?token,status}`
* `/v2/actor-tasks/{actorTaskId}/runs/last/request-queue{?token,status}`
For example,
`/v2/actor-tasks/{actorTaskId}/runs/last/key-value-store` has the same HTTP method
and parameters as the

* `/v2/actor-tasks/{actorTaskId}/runs/last/key-value-store/keys{?token,status}`
[Key collection](#reference/key-value-stores/key-collection)
* `/v2/actor-tasks/{actorTaskId}/runs/last/key-value-store/records/{recordKey}{?
token,status}` [Record](#reference/key-value-stores/record)
#### Dataset
* `/v2/actor-tasks/{actorTaskId}/runs/last/dataset/items{?token,status}` [Item
collection](#reference/datasets/item-collection)
#### Request queue
* `/v2/actor-tasks/{actorTaskId}/runs/last/request-queue/requests{?token,status}`
[Request collection](#reference/request-queues/request-collection)
* `/v2/actor-tasks/{actorTaskId}/runs/last/request-queue/requests/{requestId}{?
token,status}` [Request collection](#reference/request-queues/request)
* `/v2/actor-tasks/{actorTaskId}/runs/last/request-queue/head{?token,status}`
[Queue head](#reference/request-queues/queue-head)
For example, to download data from a dataset of the last succeeded actor task run
in XML format,
```
https://api.apify.com/v2/actor-tasks/{actorTaskId}/runs/last/dataset/items?
token={yourApiToken}&format=xml&status=SUCCEEDED
```
to the same URL.
+ Parameters
+ actorTaskId: `janedoe~my-task` (string, required) - Actor ID or a tilde-

separated owner's username and actor task name.
+ status: `SUCCEEDED` (string, optional) - Filter for the run status.
### Get last run [GET]
+ Attributes
# Group Actor runs
The API endpoints described in this section enable you to manage Apify actor runs.
Note that if any returned run object contains usage in dollars, your effective unit
pricing at the time of query
used only for informative purposes.
You can learn more about platform usage in the <a
## Run collection [/v2/actor-runs{?token,offset,limit,desc,status}]
### Get user runs list [GET]
Gets a list of all runs for a user. The response is a list of objects, where each
object
contains basic information about a single actor run.
array elements.
By default, the records are sorted by the `startedAt` field in ascending order.
Therefore, you can use pagination to incrementally fetch all records while new
ones are still being created. To sort the records in descending order, use `desc=1`
builds#lifecycle)).
+ Parameters

The default value (as well as the maximum) is `1000`.
ascending order.
+ Attributes
## Run object and its storages [/v2/actor-runs/{runId}{?token,waitForFinish}]
This is not a single endpoint, but an entire group of endpoints that lets you
retrieve the run or any of its default storages.
The base path that represents the actor run object is:
`/v2/actor-runs/{runId}{?token}`
In order to access the default storages of the actor run, i.e. log, key-value
store, dataset and request queue,
* `/v2/actor-runs/{runId}/log{?token}`
* `/v2/actor-runs/{runId}/key-value-store{?token}`
* `/v2/actor-runs/{runId}/dataset{?token}`
* `/v2/actor-runs/{runId}/request-queue{?token}`
For example,
`/v2/actor-runs/{runId}/key-value-store` has the same HTTP method and parameters as
the
#### Log
* `/v2/actor-runs/{runId}/logs` [Log](#reference/log)
* `/v2/actor-runs/{runId}/key-value-store/keys{?token}` [Key collection]

(#reference/key-value-stores/key-collection)
* `/v2/actor-runs/{runId}/key-value-store/records/{recordKey}{?token}` [Record]
(#reference/key-value-stores/record)
#### Dataset
* `/v2/actor-runs/{runId}/dataset/items{?token}` [Item
collection](#reference/datasets/item-collection)
#### Request queue
* `/v2/actor-runs/{runId}/request-queue/requests{?token}` [Request collection]

(#reference/request-queues/request-collection)
* `/v2/actor-runs/{runId}/request-queue/requests/{requestId}{?token}` [Request
collection](#reference/request-queues/request)
* `/v2/actor-runs/{runId}/request-queue/head{?token}` [Queue
head](#reference/request-queues/queue-head)
For example, to download data from a dataset of the actor run in XML format,
```
https://api.apify.com/v2/actor-runs/{runId}/dataset/items?format=xml
```
to the same URL.
+ Parameters

### Get run [GET]
Gets an object that contains all the details about a specific run of an actor.

synchronously wait for the run to finish.
This is useful to avoid periodic polling when waiting for actor run to complete.
authenticated using a hard-to-guess ID of the run.
+ Parameters

server waits for the run to finish. By default it is `0`, the maximum value is
the returned run object will have a terminal status (e.g. `SUCCEEDED`),
otherwise it will have a
transitional status (e.g. `RUNNING`).
+ Attributes
## Delete run [/v2/actor-runs/{runId}{?token}]
### Delete run [DELETE]
Delete the run. Only finished runs can be deleted. Only the person or organization
that initiated the run can delete it.
+ Parameters

## Abort run [/v2/actor-runs/{runId}/abort{?token,gracefully}]
### Abort run [POST]
Aborts an actor run and returns an object that contains all the details about the
run.
Only runs that are starting or running are aborted. For runs with status
+ Parameters

+ gracefully: `true` (boolean, optional) - If true passed, the actor run
will abort gracefully.
It will send àborting` and
`persistState` event into run and force-stop the run after 30 seconds.
It is helpful in cases where you
plan to resurrect the run later.
+ Attributes
- data (RunAborted, required)
## Metamorph run [/v2/actor-runs/{runId}/metamorph{?token,build,targetActorId}]
### Metamorph run [POST]
Transforms an actor run into a run of another actor with a new input.
This is useful if you want to use another actor to finish the work
of your current actor run, without the need to create a completely new run and
waiting for its finish.
For the users of your actors, the metamorph operation is transparent, they will
just see your actor got the work done.
Internally, the system stops the Docker container corresponding to the actor run
and starts a new container using a different Docker image.
All the default storages are preserved and the new input is stored under the
ÌNPUT-METAMORPH-1` key in the same default key-value store.

docs](https://docs.apify.com/platform/actors/development/programming-interface/
metamorph).
+ Parameters

+ targetActorId: `HDSasDasz78YcAPEB` (string, required) - ID of a target actor
that the run should be transformed into.
+ build: `beta` (string, optional) - Optional build of the target actor.
It can be either a build tag or build number. By default, the run uses the
build specified in the default run configuration for the target actor (typically
`latest`).
+ Attributes
- data (RunMetamorphed, required)
## Reboot run [/v2/actor-runs/{runId}/reboot{?token}]
### Reboot run [POST]
Reboots an actor run and returns an object that contains all the details about the
rebooted run.
Only runs that are running, i.e. runs with status `RUNNING` can be rebooted.
The run's container will be restarted, so any data not persisted in the key-value
store, dataset, or request queue will be lost.
+ Parameters

+ Attributes
## Resurrect run [/v2/acts/{actorId}/runs/{runId}/resurrect{?

token,build,timeout,memory}]
### Resurrect run [POST]
Resurrects a finished actor run and returns an object that contains all the details
about the resurrected run.
Only finished runs, i.e. runs with status `FINISHED`, `FAILED`, ÀBORTED` and
`TIMED-OUT` can be resurrected.
Run status will be updated to RUNNING and its container will be restarted with the
same storages
(the same behaviour as when the run gets migrated to the new server).
docs](https://docs.apify.com/platform/actors/running/runs-and-builds#resurrection-
of-finished-run).
+ Parameters

specified in the run that is being resurrected (typically `latest`).
default, the run uses a timeout specified in the run that is being resurrected.
run uses a memory limit specified in the run that is being resurrected.
+ Attributes
## Update status message [/v2/actor-runs/{runId}{?token,statusMessage,isTerminal}]
### Update status message [PUT]
You can set a single status message on your run that will be displayed in the Apify
Console UI. During an actor run,
you will typically do this in order to inform users of your actor about the actor's
progress.
The request body must contain `runId` and `statusMessage` properties. The
ìsStatusMessageTerminal` property is optional and it indicates if the status
message is the very last one. In the absence of a status message, the platform will
try to substitute sensible defaults.
+ Parameters
+ Attributes(StatusMessageUpdate)
+ Attributes
# Group Actor builds
The API endpoints described in this section enable you to manage Apify actor
builds.
Note that if any returned build object contains usage in dollars, your effective
unit pricing at the time of query
used only for informative purposes.
You can learn more about platform usage in the <a
## Build collection [/v2/actor-builds{?token,offset,limit,desc}]
+ Parameters
### Get user builds list [GET]
Gets a list of all builds for a user. The response is a JSON array of objects,
where each object
contains basic information about a single build.
By default, the records are sorted by the `startedAt` field in ascending order.
Therefore, you can use pagination to incrementally fetch all builds while new
ones are still being started. To sort the records in descending order, use the
`desc=1`
parameter.
+ Parameters

ascending order.
+ Attributes
- items (array[BuildShort1,BuildShort2], required)
## Build object [/v2/actor-builds/{buildId}{?token,waitForFinish}]
### Get build [GET]
Gets an object that contains all the details about a specific build of an actor.

synchronously wait for the build to finish.
This is useful to avoid periodic polling when waiting for an actor build to finish.
authenticated using a hard-to-guess ID of the build.
+ Parameters
returned build object will have a terminal status (e.g. `SUCCEEDED`),
is only required for private actors.
Builds of public actors can be queried without any token.
+ Attributes
## Delete build [/v2/actor-builds/{buildId}{?token}]
### Delete build [DELETE]
Delete the build. The build that is the current default build for the Actor cannot
be deleted.
Only users with build permissions for the Actor can delete builds.
+ Parameters

## Abort build [/v2/actor-builds/{buildId}/abort{?token}]
### Abort build [POST]
Aborts an actor build and returns an object that contains all the details about the
build.
Only builds that are starting or running are aborted. For builds with status
+ Parameters
+ buildId: `3KH8gEpp4d8uQSe8T` (string, required) - Build ID.

+ Attributes
- data (BuildAborted, required)
# Group Key-value stores
This section describes API endpoints to manage Key-value stores.

Key-value store is a simple storage for saving and reading data records or files.
Each data record is represented by a unique key and associated with a MIME content
type.
Key-value stores are ideal for saving screenshots, actor inputs and outputs, web
pages,
PDFs or to persist the state of crawlers.
For more information, see the <a href="https://docs.apify.com/platform/storage/key-
value-store">Key-value store documentation</a>.
Note that some of the endpoints do not require the authentication token, the calls
are authenticated using a hard-to-guess ID of the key-value store.
## Store collection [/v2/key-value-stores{?token,limit,offset,desc,name,unnamed}]
+ Parameters
### Get list of key-value stores [GET]
Gets the list of key-value stores owned by the user.

The response is a list of objects, where each objects contains a basic information
about a single key-value store.
array elements.
therefore you can use pagination to incrementally fetch all key-value stores while
new
`desc=1`
parameter.
+ Parameters

ascending order.
+ unnamed: true (boolean, optional) - If `true` or `1` then all the stores are
returned. By default, only named key-value stores are returned.
+ Attributes
- items (array[KVStoreShort1,KVStoreShort2], required)
### Create key-value store [POST]
Creates a key-value store and returns its object. The response is the same object
as returned
by the [Get store](#reference/key-value-stores/store-object/get-store) endpoint.
Keep in mind that data stored under unnamed store follows [data retention period]
(https://docs.apify.com/platform/storage#data-retention).
It creates a store with the given name if the parameter name is used.
If there is another store with the same name, the endpoint does not create a new
one and returns the existing object instead.
+ Parameters

+ name: èshop-values` (string, optional) - Custom unique name to easily
identify the store in the future.
+ Headers
Location: https://api.apify.com/v2/key-value-stores/WkzbQMuFYuamGv3YF
+ Attributes
- data (KVStore, required)
## Store object [/v2/key-value-stores/{storeId}{?token}]
+ Parameters
+ storeId: `WkzbQMuFYuamGv3YF` (string, required) - Key-value store ID or

ùsername~store-name`.
### Get store [GET]
Gets an object that contains all the details about a specific key-value store.
+ Parameters

It is required only when using the ùsername~store-name` format for `storeId`.
+ Attributes
### Update store [PUT]
Updates a key-value store's name using a value specified by a JSON object passed in
the PUT payload.
The response is the updated key-value store object, as returned by the [Get store]
(#reference/key-value-stores/store-object/get-store) API endpoint.
+ Parameters
+ Request
{
"name": "new-store-name"
}
+ Attributes
### Delete store [DELETE]
Deletes a key-value store.
+ Parameters
## Key collection [/v2/key-value-stores/{storeId}/keys{?

exclusiveStartKey,limit,token}]
### Get list of keys [GET]
Returns a list of objects describing keys of a given key-value store, as well as

some information about the values (e.g. size).
This endpoint is paginated using èxclusiveStartKey` and `limit` parameters - see
[Pagination](#introduction/response-structure) for more details.
+ Parameters

+ exclusiveStartKey: Ìhnsp8YrvJ8102Kj` (string, optional) - All keys up to
this one (including) are skipped from the result.
+ limit: 100 (number, optional) - Number of keys to be returned. Maximum value
is `1000`.
is required only when using the ùsername~store-name` format for `storeId`.
+ Attributes
- items (array, required)
- (object)
- key: `second-key` (string, required)
- size: 36 (number, required)
- (object)
- key: `third-key` (string, required)
- size: 128 (number, required)
- exclusiveStartKey: `some-key` (string)
- isTruncated: true (boolean, required)
- nextExclusiveStartKey: `third-key` (string)
## Record [/v2/key-value-stores/{storeId}/records/{recordKey}{?token}]
+ Parameters

+ recordKey: `some key` (string, required) - Key of the record.
### Get record [GET]
Gets a value stored in the key-value store under a specific key.
The response body has the same `Content-Encoding` header as it was set in [Put
record](#reference/key-value-stores/key-collection/put-record).
If the request does not define the Àccept-Encoding` HTTP header with the right
encoding, the record will be decompressed.
Most HTTP clients support decompression by default. After using the HTTP client
with decompression support, the Àccept-Encoding` header is set by the client and
body is decompressed automatically.
+ Parameters

It is required only when using the ùsername~store-name` format for `storeId`.
+ Response 302
+ Headers
Location:
https://apifier-key-value-store-prod.s3.amazonaws.com/tqx6jeMia43gYY6eE/INPUT?
AWSAccessKeyId=NKDOUN&Expires=1502720992&Signature=DKLVPI4lDDKC
{
"foo": "bar"
}
### Put record [PUT]
Stores a value under a specific key to the key-value store.

The value is passed as the PUT payload and it is stored with a MIME content type
defined by the `Content-Type` header and with encoding defined by the `Content-
Encoding` header.
To save bandwidth, storage, and speed up your upload, send the request payload
compressed with Gzip compression and
add the `Content-Encoding: gzip` header. It is possible to set up another
compression type with `Content-Encoding` request header.
Below is a list of supported `Content-Encoding` types.
* Gzip compression: `Content-Encoding: gzip`

* Deflate compression: `Content-Encoding: deflate`
* Brotli compression: `Content-Encoding: br`
+ Parameters
+ Request
+ Headers
+ Attributes
- foo: `bar`
+ Request
0000 0000 0011 4c69 6e65 2031 3033 3530

2036 3335 3935 0a32 3031 372d 3037 2d31
3254 3132 3a30 303a 3030 2e37 3232 5a20
0100 0000 0000 0011 4c69 6e65 2031 3033
...
+ Headers
Content-Type: image/jpeg
Content-Encoding: gzip
+ Headers
Location:
https://api.apify.com/v2/key-value-stores/WkzbQMuFYuamGv3YF/records/some-key
## Delete record [DELETE]
Removes a record specified by a key from the key-value store.
+ Parameters
# Group Datasets
This section describes API endpoints to manage Datasets.
Dataset is a storage for structured data, where each record stored has the same
attributes,
such as online store products or real estate offers. You can imagine it as a table,
where each object is a row and its attributes are columns. Dataset is an append-
only
storage - you can only add new records to it but you cannot modify or remove
existing
records. Typically it is used to store crawling results.
href="https://docs.apify.com/platform/storage/dataset">Datasets documentation</a>.
are authenticated using the hard-to-guess ID of the dataset.
## Dataset collection [/v2/datasets{?token,limit,offset,desc,name,unnamed}]

### Get list of datasets [GET]
Lists all of a user's datasets. The response is a JSON array of objects, where each
object
contains basic information about one dataset.
By default, the objects are sorted by the `createdAt` field in ascending order,
therefore you can use pagination to incrementally fetch all datasets while new
ones are still being created. To sort them in descending order, use `desc=1`
parameter. The endpoint supports pagination using `limit` and òffset` parameters
and it will not return more than 1000
array elements.
+ Parameters

ascending order.
+ unnamed: true (boolean, optional) - If `true` or `1` then all the datasets
are returned. By default only named datasets are returned.
+ Attributes
- items (array[DatasetShort1,DatasetShort2], required)
### Create dataset [POST]
Creates a dataset and returns its object.

Keep in mind that data stored under unnamed dataset follows [data retention period]
(https://docs.apify.com/platform/storage#data-retention).
It creates a dataset with the given name if the parameter name is used.
If a dataset with the given name already exists then returns its object.
+ Parameters

+ name: èshop-items` (string, optional) - Custom unique name to easily
identify the dataset in the future.
+ Headers
Location: https://api.apify.com/v2/datasets/WkzbQMuFYuamGv3YF
+ Attributes
- data (Dataset, required)
## Dataset [/v2/datasets/{datasetId}{?token}]
+ Parameters
+ datasetId: `WkzbQMuFYuamGv3YF` (string, required) - Dataset ID or

ùsername~dataset-name`.
### Get dataset [GET]
Returns dataset object for given dataset ID.
**NOTE:** Keep in mind that attributes ìtemCount` and `cleanItemCount` are not
propagated right away after data are pushed into a dataset.
There is a short period (up to 5 seconds) during which these counters may not match
with exact counts in dataset items.
+ Parameters

It is required only when using the ùsername~dataset-name` format for `datasetId`.
+ Attributes
### Update dataset [PUT]
Updates a dataset's name using a value specified by a JSON object passed in the PUT
payload.
The response is the updated dataset object, as returned by the

[Get dataset](#reference/datasets/dataset-collection/get-dataset) API endpoint.
+ Parameters
+ Request
{
"name": "new-dataset-name"
}
+ Attributes
### Delete dataset [DELETE]
Deletes a specific dataset.
+ Parameters

## Item collection [/v2/datasets/{datasetId}/items{?

format,offset,limit,attachment,delimiter,bom,desc,xmlRoot,xmlRow,fields,omit,unwind
,flatten,skipHeaderRow,token,clean,skipHidden,skipEmpty,simplified,skipFailedPages}
]
+ Parameters
+ datasetId: `WkzbQMuFYuamGv3YF` (string, required) - Dataset ID or

ùsername~dataset-name`.
### Get items [GET]
Returns data stored in the dataset in a desired format.
### Response format
The format of the response depends on <code>format</code> query parameter.
The <code>format</code> parameter can have one of the following values:

<code>json</code>, <code>jsonl</code>, <code>xml</code>, <code>html</code>,
<code>csv</code>, <code>xlsx</code> and <code>rss</code>.
The following table describes how each format is treated.
<table>
<tr>
<th>Format</th>
<th>Items</th>
</tr>
<tr>
<td><code>json</code></td>
<td rowspan="3">The response is a JSON, JSONL or XML array of raw item
objects.</td>
</tr>
<tr>
<td><code>jsonl</code></td>
</tr>
<tr>
<td><code>xml</code></td>
</tr>
<tr>
<td><code>html</code></td>
<td rowspan="3">The response is a HTML, CSV or XLSX table, where columns
correspond to the
properties of the item and rows correspond to each dataset item.</td>
</tr>
<tr>
<td><code>csv</code></td>
</tr>
<tr>
<td><code>xlsx</code></td>
</tr>
<tr>
<td><code>rss</code></td>
<td colspan="2">The response is a RSS file. Each item is displayed as child
elements of one
<code><item></code>.</td>
</tr>
</table>
Note that CSV, XLSX and HTML tables are limited to 500 columns and the column names
cannot be longer than 200 characters.
JSON, XML and RSS formats do not have such restrictions.
### Hidden fields
The top-level fields starting with the `#` character are considered hidden. These
are useful to
store debugging information and can be omitted from the output by providing the
`skipHidden=1` or `clean=1`
query parameters.
For example, if you store the following object to the dataset:
```
{
productName: "iPhone Xs",
description: "Welcome to the big screens."
#debug: {
url: "https://www.apple.com/lae/iphone-xs/",
crawledAt: "2019-01-21T16:06:03.683Z"
}
}
```
The `#debug` field will be considered as hidden and can be omitted from the
results. This is useful to
provide nice cleaned data to end users, while keeping debugging info available if
needed. The Dataset object
returned by the API contains the number of such clean items in the
`dataset.cleanItemCount` property.
### XML format extension
When exporting results to XML or RSS formats, the names of object properties become
XML tags
and the corresponding values become tag's children. For example, the following
JavaScript object:
```
{
name: "Paul Newman",
address: [
{ type: "home", street: "21st", city: "Chicago" },
{ type: "office", street: null, city: null }
]
}
```
will be transformed to the following XML snippet:
```
<name>Paul Newman</name>
<address>
<type>home</type>
<street>21st</street>
<city>Chicago</city>
</address>
<address>
<type>office</type>
<street/>
<city/>
</address>
```
If the JavaScript object contains a property named `@`

then its sub-properties are exported as attributes of the parent XML element.
If the parent XML element does not have any child elements then its value is taken
from a JavaScript object property named `#`.
For example, the following JavaScript object:
```
{
"address": [{
"@": {
"type": "home"
},
"street": "21st",
"city": "Chicago"
},
{
"@": {
"type": "office"
},
"#": 'unknown'
}]
}
```
will be transformed to the following XML snippet:
```
<address type="home">
<street>21st</street>
<city>Chicago</city>
</address>
<address type="office">unknown</address>
```
This feature is also useful to customize your RSS feeds generated for various
websites.
By default the whole result is wrapped in a `<items>` element and each page object
is wrapped in a `<item>` element.
You can change this using <code>xmlRoot</code> and <code>xmlRow</code> url
parameters.
### Pagination
The generated response supports [pagination](#introduction/pagination).

The pagination is always performed with the granularity of a single item,
regardless whether <code>unwind</code> parameter was provided.
By default, the **Items** in the response are sorted by the time they were stored
to the database, therefore you can use
pagination to incrementally fetch the items as they are being added.
The maximum number of items that will be returned in a single API call is limited
to 250,000. 
If you specify `desc=1` query paremeter, the results are returned in the reverse
order
than they were stored (i.e. from newest to oldest items).
Note that only the order of **Items** is reversed, but not the order of the
ùnwind` array elements.
+ Parameters

It is required only when using the ùsername~dataset-name` format for `datasetId`.
`json`.
there is no limit.
preserved as it is.
`1`.
name is ìtem`.
Note that if used, the results might contain less items than the limit value.
integrations.
integrations.
+ Attributes
+ format: `json`
+ Headers
+ Body
[
{
}
]
### Put items [POST]
Appends an item or an array of items to the end of the dataset.

The POST payload is a JSON object or a JSON array of objects to save into the
dataset.
**IMPORTANT:** The limit of request payload size for the dataset is 5 MB. If the
array exceeds the size,
you'll need to split it into a number of smaller arrays.
+ Parameters

+ Request
+ Headers
+ Body
[
{
"foo": "bar"
},
{
"foo": "hotel"
},
{
"foo": "restaurant"
}
]
+ Headers
Location: https://api.apify.com/v2/datasets/WkzbQMuFYuamGv3YF/items
# Group Request queues
This section describes API endpoints to manage request queues.

Request queue is a storage for a queue of HTTP URLs to crawl, which is typically
used for deep crawling of websites where you
start with several URLs and then recursively follow links to other pages.
The storage supports both breadth-first and depth-first crawling orders.
href="https://docs.apify.com/platform/storage/request-queue">Request queue
documentation</a>.
are authenticated using the hard-to-guess ID of the queue.
## Queue collection [/v2/request-queues{?token,limit,offset,desc,name,unnamed}]
### Get list of request queues [GET]
Lists all of a user's request queues. The response is a JSON array of objects,
where each object
contains basic information about one queue.
By default, the objects are sorted by the `createdAt` field in ascending order,
therefore you can use pagination to incrementally fetch all queues while new
ones are still being created. To sort them in descending order, use `desc=1`
parameter. The endpoint supports pagination using `limit` and òffset` parameters
and it will not return more than 1000
array elements.
+ Parameters
ascending order.
+ unnamed: true (boolean, optional) - If `true` or `1` then all the queues are
returned. By default only named queues are returned.
+ Attributes
- items (array[RequestQueueShort1,RequestQueueShort2], required)
### Create request queue [POST]
Creates a request queue and returns its object.

Keep in mind that requests stored under unnamed queue follows [data retention
period](https://docs.apify.com/platform/storage#data-retention).
It creates a queue of given name if the parameter name is used. If a queue with the
given name already exists then the endpoint returns
its object.
+ Parameters
+ name: èxample-com` (string, required) - Custom unique name to easily

identify the queue in the future.
+ Headers
Location: https://api.apify.com/v2/request-queues/WkzbQMuFYuamGv3YF
+ Attributes
- data (RequestQueue, required)
## Queue [/v2/request-queues/{queueId}{?token}]
+ Parameters
+ queueId: `WkzbQMuFYuamGv3YF` (string, required) - Queue ID or

ùsername~queue-name`.
### Get request queue [GET]
Returns queue object for given queue ID.
+ Parameters
It is required only when using the ùsername~queue-name` format for `queueId`.
+ Attributes
### Update request queue [PUT]
Updates a request queue's name using a value specified by a JSON object passed in
the PUT payload.
The response is the updated request queue object, as returned by the

[Get request queue](#reference/request-queues/queue-collection/get-request-queue)
API endpoint.
+ Parameters
+ token: `soSkq9ekdmfOslopH` (string) - API authentication token.
+ Request
{
"name": "new-request-queue-name"
}
+ Attributes
### Delete request queue [DELETE]
Deletes given queue.
+ Parameters
## Request collection [/v2/request-queues/{queueId}/requests{?

forefront,token,clientKey,limit,exclusiveStartId}]
+ Parameters

+ clientKey: `client-abc` (string, optional) - A unique identifier of the
client accessing the request queue. It must be a string between 1 and 32 characters
long. This identifier is used to determine whether the queue was accessed by
multiple clients. If `clientKey` is not provided,
the system considers this API call to come from a new client. For details, see
the `hadMultipleClients` field returned by the [Get head](#reference/request-
queues/queue-head) operation.
### List requests [GET]
Returns a list of requests. This endpoint is paginated using exclusiveStartId and

limit parameters.
+ Parameters
+ queueId: `WkzbQMuFYuamGv3YF` (string, required) - Request queue ID or

+ exclusiveStartId: Ìhnsp8YrvJ8102Kj` (string, optional) - All requests up to
this one (including) are skipped from the result.
+ limit: 100 (number, optional) - Number of keys to be returned. Maximum value
is `10000`.
+ Attributes
- (Request1)
- (Request1)
- exclusiveStartId: Ìhnsp8YrvJ8102Kj` (string)
### Add request [POST]
Adds request to the queue. Response contains ID of the request and info if request
was already present in the queue or handled.
If request with same ùniqueKey` was already present in the queue then returns an
ID of existing request.
+ Parameters

+ forefront: false (string, optional) - Determines if request should be added
to the head of the queue or to the end. Default value is `false` (end of queue).
+ Attributes(RequestWithoutId)
+ Attributes
- data (RequestOperationInfo, required)
## Request [/v2/request-queues/{queueId}/requests/{requestId}{?
forefront,token,clientKey}]
+ Parameters

+ requestId: `xpsmkDlspokDSmklS` (string, required) - Request ID.
### Get request [GET]
Returns request from queue.
+ Parameters

+ Attributes
- data (Request1, required)
### Update request [PUT]
Updates a request in a queue. Mark request as handled by setting `request.handledAt

= new Date()`.
If `handledAt` is set, the request will be removed from head of the queue.
+ Parameters

+ Attributes(Request1)
+ Attributes
- data (RequestOperationInfo, required)
### Delete request [DELETE]
Deletes given request from queue.
+ Parameters

## Request lock [/v2/request-queues/{queueId}/requests/{requestId}/lock{?

lockSecs,forefront,token,clientKey}]
+ Parameters

+ requestId: `xpsmkDlspokDSmklS` (string, required) - Request ID.
long. This identifier is used to ensure one client is not to able delete or prolong
a request from another client.
### Prolong request lock [PUT]
Prolongs request lock. The request lock can be prolonged only by the client that
has locked it using [Get and lock head operation](#reference/request-queues/queue-
head-with-locks).
+ Parameters
+ lockSecs: 60 (Number, required) - For how long second request will be

locked.
to the head of the queue or to the end after lock expires.
+ Attributes
- data
- lockExpiresAt: `2022-01-01T00:00:00.000Z` (string, required) - Date
when lock expires.
### Delete request lock [DELETE]
Deletes a request lock. The request lock can be deleted only by the client that has
locked it using [Get and lock head operation](#reference/request-queues/queue-head-
with-locks).
+ Parameters

to the head of the queue or to the end after lock was removed.
## Queue head [/v2/request-queues/{queueId}/head{?limit,token,clientKey}]
+ Parameters

+ limit: 100 (Number, optional) - How many items from queue should be
returned.
the system considers this API call to come from a new client. For details,
see the `hadMultipleClients` field returned by the [Get head](#reference/request-
### Get head [GET]
Returns given number of first requests from the queue.
The response contains the `hadMultipleClients` boolean field which indicates that
the queue was accessed by more than one client (with unique or empty `clientKey`).
This field is used by [Apify SDK](https://sdk.apify.com) to determine whether the
local cache is consistent with the request queue, and thus optimize performance of
certain operations.
+ Attributes
- queueModifiedAt: `2018-03-14T23:00:00.000Z` (string, required)
- hadMultipleClients: false (boolean, required)
- (object)
- id: `8OamqXBCpPHxyH9` (string, required)
- retryCount: 0 (number, required)
- uniqueKey: `http://example.com` (string, required)
- url: `http://example.com` (string, required)
- method: `GET` (string, required)
- (object)
- id: `ZJAoqlRijenMQIn` (string, required)
- uniqueKey: `http://example.com/a/b` (string, required)
- url: `http://example.com/a/b` (string, required)
- (object)
- id: `hAhkwyk5oOBHKQC` (string, required)
- uniqueKey: `http://example.com/c/d` (string, required)
- url: `http://example.com/c/d` (string, required)
## Queue head with locks [/v2/request-queues/{queueId}/head/lock{?

limit,lockSecs,token,clientKey}]
+ Parameters

+ lockSecs: 60 (Number, required) - How long the second request will be locked
for.
+ limit: 100 (Number, optional) - How many items from the queue should be
returned.
long.
### Get head and lock [POST]
Returns the given number of first requests from the queue and locks them for the
given time.
If this endpoint locks the request, no other client will be able to get and lock
these requests.
The response contains the `hadMultipleClients` boolean field which indicates that
the queue was accessed by more than one client (with unique or empty `clientKey`).
+ Attributes
- queueModifiedAt: `2018-03-14T23:00:00.000Z` (string, required)
- hadMultipleClients: true (boolean, required)
- lockSecs: 60 (number, required)
- (object)
- id: `8OamqXBCpPHxyj9` (string, required)
- lockExpiresAt: `2022-06-14T23:00:00.000Z` (string, required)
- (object)
- id: `8OamqXBCpPHxyx9` (string, required)
- uniqueKey: `http://example.com/a` (string, required)
- url: `http://example.com/a` (string, required)
- (object)
- id: `8OamqXBCpPHxy08` (string, required)
- uniqueKey: `http://example.com/a/b` (string, required)
- url: `http://example.com/a/b` (string, required)
## Batch request operations [/v2/request-queues/{queueId}/requests/batch{?

forefront,token,clientKey}]
+ Parameters

long
### Add requests [POST]

Adds requests to the queue in batch. The maximum requests in batch is limit to 25.
The response contains an array of unprocessed and processed requests.
If any add operation fails because the request queue rate limit is exceeded or an
internal failure occurs,
the failed request is returned in the unprocessedRequests response parameter.
You can resend these requests to add. It is recommended to use exponential backoff
algorithm for these retries.
If a request with the same ùniqueKey` was already present in the queue, then it
returns an ID of the existing request.
+ Parameters

+ Attributes(array[RequestWithoutId, RequestWithoutId2])
+ Attributes
- data
- processedRequests (array[RequestOperationInfo])
- unprocessedRequests (array[RequestWithoutId2])
### Delete requests [DELETE]
Batch-deletes given requests from the queue. The number of requests in a batch is
limited to 25. The response contains an array of unprocessed and processed
requests.
If any delete operation fails because the request queue rate limit is exceeded or
an internal failure occurs,
the failed request is returned in the ùnprocessedRequests` response parameter.
You can re-send these delete requests. It is recommended to use an exponential
backoff algorithm for these retries.
Each request is identified by its ID or uniqueKey parameter. You can use either of
them to identify the request.
+ Parameters
+ Attributes(array[RequestBatchDelete, RequestBatchDelete2])
+ Attributes
- data
- processedRequests (array[RequestBatchDelete])
- unprocessedRequests (array[RequestBatchDelete2])
# Group Webhooks
This section describes API endpoints to manage webhooks.
Webhooks provide an easy and reliable way to configure the Apify platform
to carry out an action (e.g. a HTTP request to another service) when a certain
system event occurs.
For example, you can use webhooks to start another actor when an actor run finishes
or fails.
For more information see <a
href="https://docs.apify.com/platform/webhooks">Webhooks documentation</a>.
## Webhook collection [/v2/webhooks{?token,limit,offset,desc}]
+ Parameters
Gets the list of webhooks that the user created.
By default, the records are sorted by the `createdAt` field in ascending order. To
sort the records in descending order, use the `desc=1`
parameter.
+ Parameters

ascending order.
+ Attributes
- items (array[WebhookShort, WebhookShort], required)
### Create webhook [POST]
Creates a new webhook with settings provided by the webhook object passed as JSON
in the payload.
The response is the created webhook object.
To avoid duplicating a webhook, use the ìdempotencyKey` parameter in the request

body.
Multiple calls to create a webhook with the same ìdempotencyKey` will only create
the webhook with the first call and return the existing webhook on subsequent
calls.
Idempotency keys must be unique, so use a UUID or another random string with enough
entropy.
To assign the new webhook to an actor or task, the request body must contain
`requestUrl`, èventTypes`, and `condition` properties.
* `requestUrl` is the webhook's target URL, to which data is sent as a POST request
with a JSON payload.
* èventTypes` is a list of events that will trigger the webhook, e.g. when the
actor run succeeds.
* `condition` should be an object containing the ID of the actor or task to which
the webhook will be assigned.
* `payloadTemplate` is a JSON-like string, whose syntax is extended with the use of
variables.
* `headersTemplate` is a JSON-like string, whose syntax is extended with the use of
variables. Following values will be re-written to defaults: "host", "Content-Type",
"X-Apify-Webhook", "X-Apify-Webhook-Dispatch-Id", "X-Apify-Request-Origin"
* `description` is an optional string.
* `shouldInterpolateStrings` is a boolean indicating whether to interpolate
variables contained inside strings in the `payloadTemplate`
```
"isAdHoc" : false,
"requestUrl" : "https://example.com",
"eventTypes" : [
"ACTOR.RUN.SUCCEEDED",
"ACTOR.RUN.ABORTED"
],
"condition" : {
"actorId": "janedoe~my-actor",
"actorTaskId" : "W9bs9JE9v7wprjAnJ"
},
"payloadTemplate": "",
"headersTemplate": "",
"description": "my awesome webhook",
"shouldInterpolateStrings": false,
```
**Important**: The request must specify the `Content-Type: application/json` HTTP

header.
+ Attributes(WebhookCreate)
+ Headers
Location: https://api.apify.com/v2/webhook/zdc3Pyhyz3m8vjDeM
+ Attributes
- data (Webhook, required)
## Webhook object [/v2/webhooks/{webhookId}{?token}]
+ Parameters
+ webhookId: `Zib4xbZsmvZeK55ua` (string, required) - Webhook ID.

### Get webhook [GET]
Gets webhook object with all details.
+ Attributes
### Update webhook [PUT]
Updates a webhook using values specified by a webhook object passed as JSON in the
POST payload.
The response is the full webhook object as returned by the

[Get webhook](#reference/webhooks/webhook-object/get-webhook) endpoint.
+ Attributes(WebhookUpdate)
+ Attributes
### Delete webhook [DELETE]
Deletes a webhook.
## Webhook test [/v2/webhooks/{webhookId}/test{?token}]
+ Parameters
+ webhookId: `Zib4xbZsmvZeK55ua` (string, required) - Webhook ID.

### Test webhook [POST]
Tests a webhook. Creates a webhook dispatch with a dummy payload.

+ Attributes
- data (WebhookDispatch, required)
### Dispatches collection [/v2/webhooks/{webhookId}/dispatches{?token}]

## Get collection [GET]
Gets a given webhook's list of dispatches.
+ Parameters
+ webhookId: `pVJtoTelgYUq4qJOt` (string, required) - ID number of the

webhook.
+ Attributes
- items (array[WebhookDispatch], required)
# Group Webhook dispatches
This section describes API endpoints to get webhook dispatches.
## Webhook dispatches collection [/v2/webhook-dispatches{?token,limit,offset,desc}]
+ Parameters
### Get list of webhook dispatches [GET]
Gets the list of webhook dispatches that the user have.
parameter.
+ Parameters

ascending order.
+ Attributes
- items (array[WebhookDispatch, WebhookDispatch], required)
## Webhook dispatch object [/v2/webhook-dispatches/{dispatchId}{?token}]
+ Parameters
+ dispatchId: `Zib4xbZsmvZeK55ua` (string, required) - Webhook dispacth

ID.
+ token: `soSkq9ekdmfOslopH` (string, required) - API authentication
token.
### Get webhook dispatch [GET]
Gets webhook dispatch object with all details.
+ Attributes
- data (WebhookDispatch, required)
# Group Schedules
This section describes API endpoints for managing schedules.
Schedules are used to automatically start your actors at certain times. Each
schedule can be associated with a number of actors and actor tasks. It is also
possible
to override the settings of each actor (task) similarly to when invoking the actor
(task) using the API.
For more information, see <a
href="https://docs.apify.com/platform/schedules">Schedules documentation</a>.
Each schedule is assigned actions for it to perform. Actions can be of two types -
`RUN_ACTOR` and `RUN_ACTOR_TASK`. For details, see the documentation of the
[Get schedule](#reference/schedules/schedule-object/get-schedule) endpoint.
## Schedules collection [/v2/schedules{?token,limit,offset,desc}]
+ Parameters
### Get list of schedules [GET]
Gets the list of schedules that the user created.
The endpoint supports pagination using the `limit` and òffset` parameters. It will
not return more than 1000 records.
parameter.
+ Parameters

default value, as well as the maximum, is `1000`.
+ desc: true (boolean, optional) - If `true` or `1`, the objects are sorted by
the `createdAt` field in descending order. By default, they are sorted in ascending
order.
+ Attributes
- items (array[ScheduleShort1, ScheduleShort2], required)
### Create schedule [POST]
Creates a new schedule with settings provided by the schedule object passed as JSON
in the payload.
The response is the created schedule object.
+ Attributes(ScheduleCreate)
+ Headers
Location: https://api.apify.com/v2/schedules/asdLZtadYvn4mBZmm
+ Attributes
- data (Schedule, required)
## Schedule object [/v2/schedules/{scheduleId}{?token}]
+ Parameters
+ scheduleId: àsdLZtadYvn4mBZmm` (string, required) - Schedule ID.

### Get schedule [GET]
Gets the schedule object with all details.
+ Attributes
### Update schedule [PUT]
Updates a schedule using values specified by a schedule object passed as JSON in

the POST payload.
The response is the full schedule object as returned by the

[Get schedule](#reference/schedules/schedule-object/get-schedule) endpoint.
**The request needs to specify the `Content-Type: application/json` HTTP header!**
+ Attributes(ScheduleCreate)
+ Attributes
### Delete schedule [DELETE]
Deletes a schedule.
## Schedule log [/v2/schedules/{scheduleId}/log{?token}]
+ Parameters
+ scheduleId: àsdLZtadYvn4mBZmm` (string, required) - Schedule ID.

### Get schedule log [GET]
Gets the schedule log as a JSON array containing information about up to a 1000
invocations of the schedule.
+ Attributes
- data (array, required)
- (object, required)
- message: `Schedule invoked` (string, required)
- level: ÌNFO` (string, required)
- createdAt: `2019-03-26T12:28:00.370Z` (string, required)
- message: `Cannot start actor task \"iEvfA6pm6DWjRTGxS\":
Provided input must be object, got \"string\" instead.` (string, required)
- level: ÈRROR` (string, required)
# Group Store
[Apify Store](https://apify.com/store) is home to hundreds of public Actors

available to the Apify community.
The API endpoints described in this section are used to retrieve these Actors.
Note that the endpoints do not require the authentication token.
## Store Actors collection [/v2/store{?

limit,offset,search,sortBy,category,username,pricingModel}]
+ Parameters
+ limit: 99 (number, optional) - Maximum number of elements to return. The

default and maximum value is `1,000`.
+ offset: 10 (number, optional) - Number of elements that should be skipped at
+ search: `web scraper` (string, optional) - String to search by. The search
runs on the following fields: `title`, `name`, `description`, ùsername`, `readme`.
+ sortBy: 'popularity' (string, optional) - Specifies the field by which to
sort the results. The supported values are `relevance` (default), `popularity`,
`newest` and `lastUpdate`.
+ category: 'AI' (string, optional) - Filters the results by the specified
category.
+ username: 'apify' (string, optional) - Filters the results by the specified
username.
+ pricingModel: 'FREE' (string, optional) - Filters the results by the
specified pricing model. The supported values are `FREE`, `FLAT_PRICE_PER_MONTH`
and `PRICE_PER_DATASET_ITEM`.
### Get list of Actors in store [GET]
Gets the list of public Actors in Apify Store. You can use `search` parameter to
search Actors by string in title, name, description, username and readme.
If you need detailed info about a specific Actor, use the [Get
actor](#/reference/actors/actor-object/get-actor) endpoint.
The endpoint supports pagination using the `limit` and òffset` parameters. It will
not return more than 1,000 records.
+ Attributes
- items (array[StoreListActor, StoreListActor], required)
# Group Logs
The API endpoints described in this section are used the download the logs
generated by actor builds and runs. Note that only the trailing 5M characters
of the log are stored, the rest is discarded.
Note that the endpoints do not require the authentication token, the calls
are authenticated using a hard-to-guess ID of the actor build or run.
## Log [/v2/logs/{buildOrRunId}{?stream,download}]
+ Parameters
+ buildOrRunId: `HG7ML7M8z78YcAPEB` (string, required) - ID of the actor build

or run.
+ stream: false (boolean, required) - If `true` or `1` then the logs will be
streamed as long as the run or build is running.
+ download: false (boolean, required) - If `true` or `1` then the web browser
will download the log file rather than open it in a tab.
### Get log [GET]
Responds with HTTP status 302 to redirect to an URL containing the requested log.
The log has a content type `text/plain` and it is encoded as `gzip` returned with
appropriate HTTP headers. The log has following format:
```
2017-07-14T06:00:49.733Z Application started.
2017-07-14T06:00:49.741Z Input: { test: 123 }
2017-07-14T06:00:49.752Z Some useful debug information follows.
```
+ Headers
Location:
https://apifier-circular-logs-prod.s3.amazonaws.com/yiawTzreqPeFSKySN.log.gz?
AWSAccessKeyId=AKIABOIQ&Expires=1500368148&Signature=B7wgpkNKiBin
# Group Users
The API endpoints described in this section return information about user accounts.
## Public data [/v2/users/{userId}]
+ Parameters
+ userId: `HGzIk8z78YcAPEB` (string, required) - User ID or username.
### Get public user data [GET]
Returns public information about a specific user account, similar to what can be
seen on public profile pages (e.g. https://apify.com/apify).
This operation requires no authentication token.
+ Attributes
- data (UserPublicInfo, required)
## Private data [/v2/users/me{?token}]
+ Parameters
### Get private user data [GET]

Returns information about the current user account, including both public and
private information.
The user account is identified by the provided authentication token.
+ Attributes
- data (UserPrivateInfo, required)
## Monthly usage [/v2/users/me/usage/monthly{?token,date}]
+ Parameters
+ token: `rWLaYmvZeK55uatRrZib4xbZf` (string, required) - API authentication

token.
+ date: `2020-06-14` (string, optional) - Date in the YYYY-MM-DD format.
### Get monthly usage [GET]
Returns a complete summary of your usage for the current usage cycle,
an overall sum, as well as a daily breakdown of usage. It is the same information
you will see on your account's
[Billing page](https://console.apify.com/billing#/usage). The information
includes your use of storage, data transfer, and request queue usage.
Using the `date` parameter will show your usage in the usage cycle that includes
that date.
+ Attributes
- data (MonthlyUsage, required)
## Account and usage limits [/v2/users/me/limits{?token}]
+ Parameters
+ token: `rWLaYmvZeK55uatRrZib4xbZf` (string, required) - API authentication

token.
### Get limits [GET]
Returns a complete summary of your account's limits. It is the same information you
will see on your account's
[Limits page](https://console.apify.com/billing#/limits). The returned data
includes the current usage cycle,
a summary of your limits, and your current usage.
+ Attributes
- data (AccountLimits, required)
# Data Structures
## Actor (object)
- id: `zdc3Pyhyz3m8vjDeM` (string, required)
- userId: `wRsJZtadYvn4mBZmm` (string, required)
- name: `MyActor` (string, required)
- username: `jane35` (string, required)
- description: `My favourite actor!` (string, nullable)
- restartOnError: false (boolean, nullable)
- isPublic: false (boolean, required)
- modifiedAt: `2019-07-08T14:01:05.546Z` (string, required)
- stats (object, required)
- totalBuilds: 9 (number, required)
- totalRuns: 16 (number, required)
- totalUsers: 6 (number, required)
- totalUsers7Days: 2 (number, required)
- totalMetamorphs: 2 (number, required)
- lastRunStartedAt: `2019-07-08T14:01:05.546Z` (string, required)
- versions (ListOfVersions, required)
- defaultRunOptions (object, required)
- build: `latest` (string, required)
- timeoutSecs: 3600 (number, required)
- memoryMbytes: 2048 (number, required)
- exampleRunInput (object, nullable)
- body: `{ "helloWorld": 123 }` (string, required)
- contentType: àpplication/json; charset=utf-8` (string, required)
- isDeprecated: false (boolean, nullable)
- deploymentKey: `ssh-rsa AAAA ...` (string, required)
- title: `My Actor` (string, nullable)
- taggedBuilds (object, nullable)
- latest (object, nullable)
- buildId: `z2EryhbfhgSyqj6Hn` (string, nullable)
- buldNumber: `0.0.2` (string, nullable)
- finishedAt: `2019-06-10T11:15:49.286Z` (string, nullable)
## ActCreate (object)
- name: `MyActor` (string, nullable)
- title: `My actor` (string, nullable)
- isPublic: false (boolean, nullable)
- seoTitle: `My actor` (string, nullable)
- seoDescription: `My actor is the best` (string, nullable)
- versions (array, nullable)
- (VersionUpdate, nullable)
- categories (array[string], nullable)
- defaultRunOptions (object, nullable)
## ActUpdate (object)
- name: `MyActor` (string, required)
- isPublic: false (boolean, required)
- seoTitle: `My actor` (string, nullable)
- seoDescription: `My actor is the best` (string, nullable)
- title: `My Actor` (string, nullable)
- versions (array, required)
- (VersionUpdate, required)
- categories (array[string], nullable)
- defaultRunOptions (object, nullable)
## ActorShort1 (object)
- id: `br9CKmk457` (string, required)
- name: `MyAct` (string, required)
- username: `janedoe` (string, required)
## ActorShort2 (object)
- id: `ksiEKo23pz` (string, required)
- name: `MySecondAct` (string, required)
## Task (object)
- actId: àsADASadYvn4mBZmm` (string, required)
- name: `my-task` (string, required)
- username: `janedoe` (string, nullable)
- removedAt (string, nullable)
- stats (object, nullable)
- options (object, nullable)
- build: `latest` (string, nullable)
- timeoutSecs: 300 (number, nullable)
- memoryMbytes: 128 (number, nullable)
- input (object, nullable)
- hello: `world` (string, nullable)
## TaskShort1 (object)
- actName: `my-actor` (string, required)
- actUsername: `janedoe` (string, required)
## TaskShort2 (object)
- id: àWE3asdas3m8vjDeM` (string, required)
- actName: `my-actor` (string, required)
- actUsername: `janedoe` (string, required)
- name: `my-task-2` (string, required)
## TaskCreate (object)
## TaskUpdate (object)
- id: `ZxLNxrRaZrSjuhT9y` (string, required)
- userId: `BPWZBd7Z9c746JAnF` (string, required)
- removedAt (string, nullable)
## Version (object)
- versionNumber: `0.0` (string, required)
- sourceType: `SOURCE_FILES` (VersionSourceType,
required)
- envVars (array, nullable)
- (object)
- name: `DOMAIN` (string, required)
- value: `http://example.com` (string, required)
- isSecret: false (boolean, nullable)
- (object)
- name: `SECRET_PASSWORD` (string, required)
- isSecret: true (boolean, nullable)
- applyEnvVarsToBuild: false (boolean, nullable)
- buildTag: `latest` (string, required)
- sourceFiles (array)
-(object)
- name: `src/main.js` (string, required)
- format: `TEXT` (string, required)
- content: `console.log('This is the main.js file');` (string, required)
-(object)
- name: `package.json` (string, required)
- content: `name: "My Scraper"` (string, required)
-(object)
- name: `Dockerfile` (string, required)
- content: ` # Dockerfile contains instructions ...`
(string, required)
-(object)
- name: `README.md` (string, required)
- content: `My Actor scrapes the web` (string, required)
## EnvVar (object)
- name: `MY_ENV_VAR` (string, required)
- value: `my-value` (string, required)
## EnvVarUpdate (object)
- value: `my-new-value` (string, required)
## ListOfEnvVars (array)
- (object)
- value: `my-value` (string, required)
- (object)
- name: ÀNOTHER_VAR` (string, required)
- value: `123` (string, required)
- (object)
- name: `SECRET_ENV_VAR` (string, required)
- isSecret: true (boolean, nullable)
## ListOfVersions (array)
- (object)
- versionNumber: `0.1` (string, required)
- sourceType: `SOURCE_FILES` (VersionSourceType,
required)
- applyEnvVarsToBuild: false (boolean, nullable)
- buildTag: `latest` (string, required)
-(object)
- name: `src/main.js` (string,
required)
- format: `TEXT` (string,
required)
- content: `console.log('This is the main.js file');` (string,
required)
-(object)
- name: `package.json` (string,
required)
required)
- content: `name: "My Scraper"` (string,
required)
-(object)
- name: `Dockerfile` (string,
required)
required)
(string, required)
-(object)
- name: `README.md` (string,
required)
required)
- content: `My Actor scrapes the web` (string,
required)
- (object)
- versionNumber: `0.2` (string,
required)
- sourceType: `GIT_REPO`
(VersionSourceType, required)
- envVars (array,
nullable)
- applyEnvVarsToBuild: false (boolean,
nullable)
- buildTag: `latest` (string,
required)
- gitRepoUrl: `https://github.com/jane35/my-actor` (string,
required)
- (object)
required)
- sourceType: `TARBALL`
- envVars (array,
nullable)
nullable)
required)
- tarballUrl:
`https://github.com/jane35/my-actor/archive/master.zip` (string, required)
- (object)
required)
- sourceType: `GITHUB_GIST`
- envVars (array,
nullable)
nullable)
required)
- gitHubGistUrl: `https://gist.github.com/jane35/e51feb784yu89`
(string, required)
## VersionUpdate (object)
- versionNumber: `0.0` (string, nullable)
- sourceType: `SOURCE_FILES`
(VersionSourceType, nullable)
- (object)
- name: `DOMAIN` (string, nullable)
- value: `http://example.com` (string, nullable)
- isSecret: false (boolean,
nullable)
- (object)
- name: `SECRET_PASSWORD` (string, nullable)
- value: `MyTopSecretPassword123` (string, nullable)
- isSecret: true (boolean,
nullable)
nullable)
- buildTag: `latest` (string, nullable)
-(object)
- name: `src/main.js` (string, required)
- content: `console.log('This is the main.js file');` (string, required)
-(object)
- name: `package.json` (string, required)
- content: `name: "My Scraper"` (string, required)
-(object)
- name: `Dockerfile` (string, required)
(string, required)
-(object)
- name: `README.md` (string, required)
- content: `My Actor scrapes the web` (string, required)
## VersionSourceType (enum)
+ `SOURCE_FILES`
+ `GIT_REPO`
+ `TARBALL`
+ `GITHUB_GIST`
## Build (object)
- id: `HG7ML7M8z78YcAPEB` (string, required)
- actId: `janedoe~my-actor` (string, required)
- userId: `klmdEpoiojmdEMlk3` (string, required)
- startedAt: `2019-11-30T07:34:24.202Z` (string, required)
- status: `SUCCEEDED` (string, required)
- meta (object, required)
- origin: `WEB` (string, required)
- clientIp: `172.234.12.34` (string, required)
- userAgent: `Mozilla/5.0 (iPad)` (string, required)
- durationMillis: 1000 (number, required)
- runTimeSecs: 45.718 (number, required)
- computeUnits: 0.012699444444444444 (number, required)
- useCache: false (boolean, nullable)
- betaPackages: false (boolean, nullable)
- diskMbytes: 2048 (number, nullable)
- usage (object, nullable)
- ACTOR_COMPUTE_UNITS: 0.08 (number, nullable)
- usageTotalUsd: 0.02 (number, nullable)
- usageUsd (object, nullable)
- inputSchema: `{\n \"title\": \"Schema for ... }` (string, nullable)
- readme: `# Magic actor\nThis actor is magic.` (string, nullable)
- buildNumber: `0.1.1` (string, required)
## BuildShort1 (object)
- finishedAt: `2019-12-12T09:30:12.202Z` (string, required)
- usageTotalUsd: 0.02 (number, required)
- meta (object)
- userAgent: `Mozilla/5.0 (Macintosh)` (string, required)
## BuildShort2 (object)
- status: `FAILED` (string, required)
- meta (object)
- origin: ÀPI` (string, required)
## BuildAborted (object)
- userId: `klmdEpoiojmdEMlk3` (string, required)
- status: ÀBORTED` (string, required)
- useCache: false (boolean, nullable)
- diskMbytes: 2048 (number, nullable)
## Run (object)
- actId: `HDSasDasz78YcAPEB` (string, required)
- userId: `7sT5jcggjjA9fNcxF` (string, required)
- actorTaskId: `KJHSKHausidyaJKHs` (string, nullable)
- status: `RUNNING` (string, required)
- statusMessage: Àctor is running` (string, nullable)
- isStatusMessageTerminal: false (boolean, nullable)
- inputBodyLen: 240 (number, required)
- restartCount: 0 (number, required)
- resurrectCount: 2 (number, required)
- memAvgBytes: 267874071.9 (number, required)
- memMaxBytes: 404713472 (number, required)
- memCurrentBytes: 0 (number, required)
- cpuAvgUsage: 33.75321011075384 (number, required)
- cpuMaxUsage: 169.65073553494125 (number, required)
- cpuCurrentUsage: 0 (number, required)
- netRxBytes: 103508042 (number, required)
- netTxBytes: 4854600 (number, required)
- metamorph: 0 (number, required)
- options (object, required)
- diskMbytes: 2048 (number, required)
- buildId: `7sT5jcggjjA9fNcxF` (string, required)
- exitCode: 0 (number, nullable)
- defaultKeyValueStoreId: èJNzqsbPiopwJcgGQ` (string, required)
- defaultDatasetId: `wmKPijuyDnPZAPRMk` (string, required)
- defaultRequestQueueId: `FL35cSF7jrxr3BY39` (string, required)
- containerUrl: `https://g8kd8kbc5ge8.runs.apify.net` (string, required)
- isContainerServerReady: true (boolean, nullable)
- gitBranchName: `master` (string, nullable)
- ACTOR_COMPUTE_UNITS: 3 (number, nullable)
- DATASET_READS: 4 (number, nullable)
- DATASET_WRITES: 4 (number, nullable)
- KEY_VALUE_STORE_READS: 5 (number, nullable)
- KEY_VALUE_STORE_WRITES: 3 (number, nullable)
- KEY_VALUE_STORE_LISTS: 5 (number, nullable)
- REQUEST_QUEUE_READS: 2 (number, nullable)
- REQUEST_QUEUE_WRITES: 1 (number, nullable)
- DATA_TRANSFER_INTERNAL_GBYTES: 1 (number, nullable)
- DATA_TRANSFER_EXTERNAL_GBYTES?: 3 (number, nullable)
- PROXY_RESIDENTIAL_TRANSFER_GBYTES: 34 (number, nullable)
- PROXY_SERPS: 3 (number, nullable)
- DATASET_READS: 0.0004 (number, nullable)
- DATASET_WRITES: 0.0002 (number, nullable)
- KEY_VALUE_STORE_READS: 0.0006 (number, nullable)
- KEY_VALUE_STORE_WRITES: 0.002 (number, nullable)
- KEY_VALUE_STORE_LISTS: 0.004 (number, nullable)
- REQUEST_QUEUE_READS: 0.005 (number, nullable)
- REQUEST_QUEUE_WRITES: 0.02 (number, nullable)
- DATA_TRANSFER_INTERNAL_GBYTES: 0.0004 (number, nullable)
- DATA_TRANSFER_EXTERNAL_GBYTES?: 0.0002 (number, nullable)
- PROXY_RESIDENTIAL_TRANSFER_GBYTES: 0.16 (number, nullable)
- PROXY_SERPS: 0.0006 (number, nullable)
## RunShort1 (object)
- buildId: `HG7ML7M8z78YcAPEB` (string, required)
- defaultKeyValueStoreId: `sfAjeR4QmeJCQzTfe` (string, required)
- defaultDatasetId: `3ZojQDdFTsyE7Moy4` (string, required)
- defaultRequestQueueId: `so93g2shcDzK3pA85` (string, required)
## RunShort2 (object)
- status: `FAILED` (string, required)
- buildId: ù78dML7M8z78YcAPEB` (string, required)
- origin: `DEVELOPMENT` (string, required)
- defaultKeyValueStoreId: `sffsouqlseJCQzTfe` (string, required)
- defaultDatasetId: `CFGggdjQDsyE7Moyw` (string, required)
- defaultRequestQueueId: `soowucklrmDzKpA8x` (string, required)
## TaskRun (object)
- userId: `BPWZBd9V9c746JAnF` (string, required)
- statusMessage: Àctor has finished` (string, nullable)
- isStatusMessageTerminal: true (boolean, nullable)
- clientIp: `172.234.12.34` (string, nullable)
- scheduleId: `dWazFsPpxMigMSqHL` (string, required)
- scheduledAt: `2019-06-10T11:40:00.000Z` (string, required)
- containerUrl: `https://nwfcc4btrgqt.runs.apify.com` (string, required)
- isContainerServerReady: false (boolean, nullable)
## RunAborted (object)
- userId: `BPWZBd7Z9c746JAng` (string, required)
- actorTaskId: `rANaydYhUxjsnA3oz` (string, required)
- status: ÀBORTED` (string, required)
- statusMessage: Àctor was aborted` (string, nullable)
- isStatusMessageTerminal: true (boolean, nullable)
## RunMetamorphed (object)
- userId: `PNWZBd7Z9c746JAnF` (string, required)
- finishedAt (string, nullable)
- status: `RUNNING` (string, required)
- statusMessage: Àctor is running` (string, nullable)
- isStatusMessageTerminal: false (boolean, nullable)
- metamorphs (array, nullable)
- (object, nullable)
- actorId: `nspoEjklmnsF2oosD` (string, required)
- buildId: `ME6oKecqy5kXDS4KQ` (string, required)
- inputKey: ÌNPUT-METAMORPH-1` (string, required)
- containerUrl: `https://hfewsyknno9o.runs.apify.com` (string, required)
## StatusMessageUpdate (object)
- runId: `3KH8gEpp4d8uQSe8T` (string, required)
- statusMessage: Àctor has finished` (string, required)
- isStatusMessageTerminal: true (boolean, optional)
## KVStore (object)
- id: `WkzbQMuFYuamGv3YF` (string, required)
- name: `d7b9MDYsbtX5L7XAj` (string, required)
- accessedAt: `2019-12-14T08:36:13.202Z` (string, required)
- actId (object, nullable)
- actRunId (object, nullable)
## KVStoreShort1 (object)
- userId: `BPWDBd7Z9c746JAnF` (string, nullable)
## KVStoreShort2 (object)
- id: `YiKoxjkaS9gjGTqhF` (string, required)
- name: èshop-items` (string, required)
- userId: `BPWDBd7Z9c746JAnF` (string, nullable)
## Dataset (object)
- itemCount: 7 (number, required)
- cleanItemCount: 5 (number, required)
- fields (array[string], nullable)
## DatasetShort1 (object)
- userId: `tbXmWu7GCxnyYtSiL` (string, required)
## DatasetShort2 (object)
- name: èshop-items` (string, required)
- userId: `tbXmWu7GCxnyYtSiL` (string, required)
## RequestQueue (object)
- name: `some-name` (string, required)
- totalRequestCount: 870 (number, required)
- handledRequestCount: 100 (number, required)
- pendingRequestCount: 670 (number, required)
## RequestQueueShort1 (object)
- name: `some-name` (string, required)
- expireAt: `2019-06-02T17:15:06.751Z` (string, required)
## RequestQueueShort2 (object)
- name: èxample-com` (string, required)
- expireAt: `2019-06-02T17:15:06.751Z` (string, required)
- hadMultipleClients: false (boolean, required)
## RequestOperationInfo (object)
- requestId: `YiKoxjkaS9gjGTqhF` (string, required)
- wasAlreadyPresent: true (boolean, required)
- wasAlreadyHandled: false (boolean, required)
## RequestWithoutId (object)
## RequestWithoutId2 (object)
- uniqueKey: `http://example.com/2` (string, required)
- url: `http://example.com/2` (string, required)
## RequestBatchDelete (object)
## RequestBatchDelete2 (object)
- id: `sbJ7klsdf7ujN9l` (string, required)
## Request1 (object)
- id: `dnjkDMKLmdlkmlkmld` (string, required)
- loadedUrl: `http://example.com/example-1` (string, nullable)
- payload (object, nullable)
- noRetry: false (boolean, nullable)
- errorMessages (array, nullable)
- headers (object, nullable)
- userData (object)
- label: `DETAIL` (string, nullable)
- image: `https://picserver1.eu` (string, nullable)
- handledAt: `2019-06-16T10:23:31.607Z` (string, nullable)
## UserPublicInfo (object)
- username: `d7b9MDYsbtX5L7XAj` (string, required)
- profile (object, required)
- bio: Ì started web scraping in 1985 using Altair BASIC.`
(string)
- name: `Jane Doe`
(string)
- pictureUrl: `/img/anonymous_user_picture.png`
(string)
- githubUsername: `torvalds.`
(string)
- websiteUrl: `http://www.example.com`
(string)
- twitterUsername: `@BillGates`
(string)
## UserPrivateInfo (object)
- username: `myusername` (string, required)
- profile (object, required)
- bio: Ì started web scraping in 1985 using Altair BASIC.`
(string)
- name: `Jane Doe`
(string)
- pictureUrl: `/img/anonymous_user_picture.png`
(string)
- githubUsername: `torvalds.`
(string)
- websiteUrl: `http://www.example.com`
(string)
- twitterUsername: `@BillGates`
(string)
- email: `bob@example.com` (string, required)
- proxy (object, required)
- password: àd78knd9Jkjd86` (string, required)
- groups (array, required)
- plan (object, required)
- id: `Personal` (string, required)
- description: `Cost-effective plan for freelancers,
developers and students.` (string, required)
- isEnabled: true (boolean, required)
- monthlyBasePriceUsd: 49 (number, required)
- monthlyUsageCreditsUsd: 49 (number, required)
- usageDiscountPercent: 0 (number, required)
- enabledPlatformFeatures (array, required)
- ÀCTORS` (array, required)
- `STORAGE` (array, required)
- `PROXY_SERPS` (array, required)
- `SCHEDULER` (array, required)
- `WEBHOOKS` (array, required)
- maxMonthlyUsageUsd: 9999 (number, required)
- maxActorMemoryGbytes: 32 (number, required)
- maxMonthlyActorComputeUnits: 1000 (number, required)
- maxMonthlyResidentialProxyGbytes: 10 (number, required)
- maxMonthlyProxySerps: 30000 (number, required)
- maxMonthlyExternalDataTransferGbytes: 1000 (number, required)
- maxActorCount: 100 (number, required)
- maxActorTaskCount: 1000 (number, required)
- dataRetentionDays: 14 (number, required)
- availableProxyGroups (object, required)
- SOMEGROUP: 20 (number, required)
- ANOTHERGROUP: 200 (number, required)
- teamAccountSeatCount: 1 (number, required)
- supportLevel: `COMMUNITY` (string, required)
- availableAddOns (array, required)
## MonthlyUsage (object)
- usageCycle (object, required)
- startAt: `2022-10-02T00:00:00.000Z` (string, required)
- endAt: `2022-11-01T23:59:59.999Z` (string, required)
- monthlyServiceUsage (object, required)
- USAGE_ITEM (object, required)
- quantity: `2.784475` (number, required)
- baseAmountUsd: `0.69611875` (number, required)
- baseUnitPriceUsd: `0.25` (number, required)
- amountAfterVolumeDiscountUsd: `0.69611875` (number, required)
- dailyServiceUsages (array, required)
- date: `2022-10-02T00:00:00.000Z` (string, required)
- serviceUsage (object, required)
- SERVICE_USAGE_ITEM (object, required)
- quantity: `60` (number, required)
- baseAmountUsd: `0.00030000000000000003` (number, required)
- amountAfterVolumeDiscountUsd: `0.69611875` (number, required)

- totalUsageCreditsUsd: `0.04743857919705913` (number,
required)
- totalUsageCreditsUsdBeforeVolumeDiscount: `0.786143673840067` (number,
required)
- totalUsageCreditsUsdAfterVolumeDiscount: `0.7861436738400671` (number,
required)
## AccountLimits (object)
- monthlyUsageCycle (object, required)
- startAt: `2022-10-02T00:00:00.000Z` (string, required)
- endAt: `2022-11-01T23:59:59.999Z` (string, required)
- limits (object, required)
- maxMonthlyUsageUsd: `300` (number, required)
- maxMonthlyActorComputeUnits: `1000` (number, required)
- maxMonthlyExternalDataTransferGbytes: `7` (number, required)
- maxMonthlyProxySerps: `50` (number, required)
- maxMonthlyResidentialProxyGbytes: `0.5` (number, required)
- maxActorMemoryGbytes: `16` (number, required)
- maxActorCount: `100` (number, required)
- maxActorTaskCount: `1000` (number, required)
- maxTeamAccountSeatCount: `9` (number, required)
- current (object, required)
- monthlyUsageUsd: `43` (number, required)
- monthlyActorComputeUnits: `500.784475` (number,
required)
- monthlyExternalDataTransferGbytes: `3.008619039319455624` (number,
required)
- monthlyProxySerps: `34` (number,
required)
- monthlyResidentialProxyGbytes: `0.4` (number,
required)
- actorMemoryGbytes: `8` (number,
required)
- actorCount: `31` (number,
required)
- actorTaskCount: `130` (number,
required)
- teamAccountSeatCount: `5` (number,
required)
## Webhook (object)
- isAdHoc: false (boolean, nullable)
- shouldInterpolateStrings: false (boolean, nullable)
- eventTypes (array, required)
- ÀCTOR.RUN.SUCCEEDED` (string, nullable)
- condition (object, required)
- actorId: `hksJZtadYvn4mBuin` (string, nullable)
- actorTaskId: àsdLZtadYvn4mBZmm` (string, nullable)
- actorRunId: `hgdKZtadYvn4mBpoi` (string, nullable)
- ignoreSslErrors: false (boolean, required)
- doNotRetry: false (boolean, nullable)
- requestUrl: `http://example.com/` (string, required)
- payloadTemplate: `{\n \"userId\": {{userId}}...` (string, nullable)
- headersTemplate: `{\n \"Authorization\": Bearer...`(string, nullable)
- description: `this is webhook description` (string, nullable)
- lastDispatch (object, nullable)
- totalDispatches: 1 (number, required)
## WebhookShort (object)
- actorId: `hksJZtadYvn4mBuin` (string, nullable)
- actorRunId: `hgdKZtadYvn4mBpoi` (string, nullable)
- ignoreSslErrors: false (boolean, required)
- doNotRetry: false (boolean, required)
- lastDispatch (object, nullable)
- totalDispatches: 1 (number, required)
## WebhookCreate (object)
- idempotencyKey: `fdSJmdP3nfs7sfk3y` (string, nullable)
- ignoreSslErrors: false (boolean, nullable)
## WebhookUpdate (object)
- eventTypes (array, nullable)
- condition (object, nullable)
- ignoreSslErrors: false (boolean, nullable)
- requestUrl: `http://example.com/` (string, nullable)
## WebhookDispatch
- id: àsdLZtadYvn4mBZmm` (string, required)
- webhookId: àsdLZtadYvn4mBZmm` (string, required)
- eventType: ÀCTOR.RUN.SUCCEEDED` (string, required)
- eventData (object, required)
- actorId: `vvE7iMKuMc5qTHHsR` (string, required)
- actorRunId: `JgwXN9BdwxGcu9MMF` (string, required)
- calls (array, nullable)
- (object)
- startedAt: `2019-12-12T07:34:14.202Z` (string, nullable)
- errorMessage: `Cannot send request` (string, nullable)
- responseStatus: 200 (number, nullable)
- responseBody: `{ "foo": "bar" }` (string, nullable)
## ScheduleShort1
- name: `my-schedule` (string, required)
- lastRunAt: `2019-04-12T07:33:10.202Z` (string, required)
- nextRunAt: `2019-04-12T07:34:10.202Z` (string, required)
- isExclusive: true (boolean, required)
- cronExpression: `* * * * *` (string, required)
- timezone: ÙTC` (string, required)
- actions (array, required)
- (object)
- id: `ZReCs7hkdieq8ZUki` (string, required)
- type: `RUN_ACTOR` (string, required)
- actorId: `HKhKmiCMrDgu9eXeE` (string, required)
- (object)
- id: `RT2FCgQSgfQyIdC9h` (string, required)
- type: `RUN_ACTOR_TASK` (string, required)
- actorTaskId: `CkTH9jCqmknq69eu2` (string, required)
## ScheduleShort2
- id: `JgwXN9BdwxGcu9MMF` (string, required)
- lastRunAt: `2019-04-10T07:34:10.202Z` (string, required)
- nextRunAt: `2019-05-10T07:34:10.202Z` (string, required)
## Schedule
- description: `Schedule of actor ...` (string, nullable)
- nextRunAt: `2019-04-12T07:34:10.202Z` (string, nullable)
- lastRunAt: `2019-04-12T07:33:10.202Z` (string, nullable)
- id: `c6KfSgoQzFhMk3etc` (string, required)
- actorId: `jF8GGEvbEg4Au3NLA` (string, required)
- runInput (object, nullable)
- body: `{\n \"foo\": \"actor\"\n}` (string, nullable)
- contentType: àpplication/json; charset=utf-8` (string, nullable)
- runOptions (object, nullable)
- id: `VvTKsjqhKDcDxbR9d` (string, required)
- actorTaskId: ìEvfA6pm6DWjRTGxS` (string, required)
- foo: `bar` (string, nullable)
- hotel: `restaurant` (string, nullable)
## ScheduleCreate
- name: `my-schedule` (string, nullable)
- isEnabled: true (boolean, nullable)
- isExclusive: true (boolean, nullable)
- cronExpression: `* * * * *` (string, nullable)
- timezone: ÙTC` (string, nullable)
- description: `Schedule of actor ...` (string, nullable)
- actions (array, nullable)
- actorId: `jF8GGEvbEg4Au3NLA` (string, required)
- runInput (object, nullable)
- body: `{\n \"foo\": \"actor\"\n}` (string, nullable)
- contentType: àpplication/json; charset=utf-8` (string, nullable)
- runOptions (object, nullable)
- actorTaskId: ìEvfA6pm6DWjRTGxS` (string, required)
- foo: `bar` (string, nullable)
- hotel: `restaurant` (string, nullable)
## StoreListActor (object)
- title: `My Public Actor` (string, required)
- name: `my-public-actor` (string, required)
- username: `jane35` (string, required)
- description: `My public actor!` (string, nullable)
- pictureUrl: `https://...` (string, nullable)
- userPictureUrl: `https://...` (string, nullable)
- totalBuilds: 9 (number, required)
- totalUsers: 6 (number, required)
- totalMetamorphs: 2 (number, required)
- lastRunStartedAt: `2019-07-08T14:01:05.546Z` (string, required)
- currentPricingInfo (object, required)
- pricingModel: `FREE` (string, required)

Sample 5

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Sample 5

Uploaded by

Copyright:

Available Formats

FORMAT: 1A

To access the API using [Node.js](https://nodejs.org/en/), we recommend the

You can find your API token on the

To use your token in a request, either:

For more information, see our

A typical workflow is as follows:

1. Run an actor or task using the [Run actor](#reference/actors/run-collection/run-

3. Fetch the results from the [Get items](#reference/datasets/item-collection/get-

**Note**: Instead of periodic polling, you can also run your

However, there are a few explicitly described exceptions, such as

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

All API endpoints that return a list of records

**IMPORTANT**: Each API endpoint that supports pagination enforces a certain

### Using offset

The following table describes the meaning of the response properties:

### Using key

The records in the [key-value store](https://docs.apify.com/platform/storage/key-

The following table describes the meaning of the response properties:

1. Define a variable `DELAY=500`

If all requests sent by the client implement the above steps,

Note that the Apify API clients [for

- the resource ID (e.g. `iKkPcIgVvwmztduf8`)

## Actor collection [/v2/acts{?token,offset,limit,desc,my}]

+ token: `soSkq9ekdmfOslopH` (string, required) - API authentication token.

### Get list of actors [GET]

+ Response 200 (application/json)

### Create actor [POST]

If you want to make your actor

+ Response 201 (application/json)

## Actor object [/v2/acts/{actorId}{?token}]

+ actorId: `janedoe~my-actor` (string, required) - Actor ID or a tilde-

### Get actor [GET]

+ Response 200 (application/json)

### Update actor [PUT]

Updates settings of an actor using values specified by an actor object passed as

The response is the full actor object as returned by the

The request needs to specify the `Content-Type: application/json` HTTP header!

If you want to make your actor

+ Response 200 (application/json)

### Delete actor [DELETE]

+ Response 204 (application/json)

## Version collection [/v2/acts/{actorId}/versions{?token}]

+ actorId: `janedoe~my-actor` (string, required) - Actor ID or a tilde-

### Get list of versions [GET]

+ Response 200 (application/json)

### Create version [POST]

Creates a version of an actor using values specified in a [Version object]

For example, if an Actor's source code is stored in a [GitHub

The response is the [Version object](#reference/actors/version-object) as returned

+ Response 201 (application/json)

## Version object [/v2/acts/{actorId}/versions/{versionNumber}{?token}]

+ actorId: `janedoe~my-actor` (string, required) - Actor ID or a tilde-

### Get version [GET]

Gets a [Version object](#reference/actors/version-object) that contains all the

+ Response 200 (application/json)

### Update version [PUT]

Updates actor version using values specified by a [Version

The request needs to specify the `Content-Type: application/json` HTTP header!

The response is the [Version object](#reference/actors/version-object) as returned

+ Response 200 (application/json)

### Delete version [DELETE]

Deletes a specific version of actor's source code.

Note: Instead of periodic polling, you can also run your

IMPORTANT: Each API endpoint that supports pagination enforces a certain