# Target.com Product Scraper (`datascrapers/target-scraper`) Actor

Target.com product dataset from search queries or page URLs, including prices, ratings, optional product details, and customer reviews.

- **URL**: https://apify.com/datascrapers/target-scraper.md
- **Developed by:** [Farhan Ali](https://apify.com/datascrapers) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.97 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**Target.com Product Scraper** creates a structured dataset of products collected from [Target.com](https://www.target.com). Each dataset item represents one product and can include identifiers, title, brand, prices, sale status, rating, review count, image URL, badges, optional detail fields, and optional nested reviews. Query the source with `searchQueries` or Target search, category, deals, clearance, product, brand, or weekly-ad URLs (`startUrls`). Control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, XML, or another supported format.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | target.com (US retail catalog) |
| Record unit | One Target product, with optional nested reviews |
| Input methods | Search terms (`searchQueries`) and/or Target page URLs (`startUrls`) |
| Main identifiers | `tcin`, product URL (`url`) |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $1 / 1,000 products; +$1 / 1,000 product details; +$1 / 1,000 products with reviews; Actor start $0.00005 |

### Coverage and available records

The Actor collects public Target.com products from one or both entry points. When both are set, the seeds are combined.

- **Search-based**: `searchQueries` (for example `socks`, `tide pods`) run as Target catalog searches.
- **URL-based**: `startUrls` accepts Target search, category, deals, clearance, product, brand, and weekly-ad pages.

Record types and limits:

- **Listing-level records** are always collected: `tcin`, URL, title, brand, price, regular price, formatted price, currency, sale flag, rating, review count, image URL, badges, category id, and source metadata.
- **Product detail fields** are conditional: description, highlights, specifications, features, variants, barcode, DPCI, item type, and extra image URLs are returned only when `includeProductDetails` is enabled.
- **Review records** are conditional: a nested `reviews` array (and `reviewStatistics` when present) is returned only when `includeReviews` is enabled. `maxReviews` caps reviews per product (`0` = all available, internally capped; default `10`).
- **Store context**: `storeId` (default `3991`, the online catalog) and `zipCode` (default `55401`) set local pricing and weekly-ad context.
- **Result cap**: `maxItems` limits products across all queries and URLs (`0` means unlimited; default `10`). Nested reviews do not count toward `maxItems`.

Observed `sourceType` values include `search`, `category`, `brand`, `product`, and `weekly_ad`. Pagination continues until the source returns no further products or the cap is reached.

Known exclusions: content Target only shows behind login is not collected; each run captures catalog state at run time (no historical snapshots); the Actor does not follow outbound links to manufacturer sites.

### Data dictionary

Field names below match dataset record JSON properties exactly. Fields marked *conditional* appear only when the corresponding input toggle is enabled. Prices, ratings, and review scores are source values, not calculated by the Actor.

#### Product listing fields

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `tcin` | string | No | Target catalog item number; best stable deduplication key | `14073500` |
| `url` | string | No | Product page URL; secondary deduplication key | `https://www.target.com/p/hanes-men-39-s-ankle-socks-with-freshiq-8pk-white-6-12/-/A-14073500` |
| `title` | string | Yes | Product title | `Hanes Men's Ankle Socks with FreshIQ 8pk - White 6-12: Moisture Wicking, Reinforced Heel & Toe` |
| `brand` | string | Yes | Brand name | `Hanes` |
| `price` | number | Yes | Current price in `currency` | `10.0` |
| `regularPrice` | number | Yes | Regular / comparison price in `currency` | `14.0` |
| `formattedPrice` | string | Yes | Display price as shown on Target | `$10.00` |
| `currency` | string | No | ISO currency code | `USD` |
| `isOnSale` | boolean | No | Whether Target marks the item on sale | `true` |
| `rating` | number | Yes | Average customer rating | `4.25` |
| `reviewCount` | number | Yes | Number of customer reviews shown on the listing | `780` |
| `imageUrl` | string | Yes | Primary product image URL | `https://target.scene7.com/is/image/Target/GUEST_a6e47d94-b48d-4448-87d7-c2d2fdadf0eb` |
| `badges` | string\[] | Yes | Listing badges (for example Trending) | `["Trending"]` |
| `categoryId` | string | Yes | Category identifier from the listing | — |
| `sourceType` | string | No | Seed type that produced the record | `search` |
| `sourceQuery` | string | No | Original search term, URL value, or TCIN | `socks` |

#### Product detail fields (conditional — `includeProductDetails`)

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `description` | string | Yes | Product description from the product page | Long-form copy |
| `highlights` | string\[] | Yes | Highlight bullets | `["Soft blended fabric", "Pack of 8 ankle length pairs"]` |
| `specifications` | object\[] | Yes | Spec pairs `{name, value}` | `[{"name": "Sizing", "value": "Mens"}]` |
| `features` | string\[] | Yes | Feature / bullet texts | — |
| `variants` | object\[] | Yes | Related variants `{tcin, title, url, price, imageUrl}` | — |
| `barcode` | string | Yes | Primary barcode | — |
| `dpci` | string | Yes | Target DPCI identifier | `040-11-0190` |
| `itemType` | string | Yes | Item type name | — |
| `imageUrls` | string\[] | Yes | Gallery image URLs | — |

#### Review fields (conditional — `includeReviews`)

Reviews nest on the product; they are not separate dataset items. When present, `reviewStatistics` can include `reviewCount`, `averageRating`, `recommendedPercentage`, and `questionCount`.

Each `reviews[]` object:

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `id` | string | No | Review identifier | — |
| `title` | string | Yes | Review title | `great cushion socks.` |
| `text` | string | Yes | Review body | `my husband loves the socks.` |
| `rating` | number | Yes | Review score | `5.0` |
| `author` | string | Yes | Reviewer nickname | `Vunserpenk` |
| `submittedAt` | string | Yes | Submission timestamp as returned by Target | — |
| `isVerified` | boolean | No | Whether Target marks the review verified | `true` |
| `isSyndicated` | boolean | No | Whether the review is syndicated | `false` |
| `isIncentivized` | boolean | No | Whether the review is incentivized | `false` |
| `photos` | string\[] | Yes | Review photo URLs | `[]` |
| `helpfulCount` | number | Yes | Helpful-vote count | — |

### Example dataset record

Real record produced with the test input below (`searchQueries: ["socks"]`, `maxItems: 5`, product details and reviews enabled). The `reviews` array is truncated to one item for readability.

```json
{
  "tcin": "14073500",
  "url": "https://www.target.com/p/hanes-men-39-s-ankle-socks-with-freshiq-8pk-white-6-12/-/A-14073500",
  "title": "Hanes Men's Ankle Socks with FreshIQ 8pk - White 6-12: Moisture Wicking, Reinforced Heel & Toe",
  "brand": "Hanes",
  "price": 10.0,
  "regularPrice": 14.0,
  "formattedPrice": "$10.00",
  "currency": "USD",
  "isOnSale": true,
  "rating": 4.25,
  "reviewCount": 780,
  "imageUrl": "https://target.scene7.com/is/image/Target/GUEST_a6e47d94-b48d-4448-87d7-c2d2fdadf0eb",
  "badges": ["Trending"],
  "sourceType": "search",
  "sourceQuery": "socks",
  "dpci": "040-11-0190",
  "highlights": [
    "Soft blended fabric",
    "FreshIQ Advanced Odor Protection Technology",
    "Pack of 8 ankle length pairs"
  ],
  "specifications": [
    { "name": "Sizing", "value": "Mens" },
    { "name": "Material", "value": "49% Polyester, 49% Cotton, 1% Spandex, 1% Nylon" }
  ],
  "reviewStatistics": {
    "reviewCount": 233,
    "averageRating": 4.16,
    "recommendedPercentage": 54.0
  },
  "reviews": [
    {
      "title": "great cushion socks.",
      "text": "my husband loves the socks.",
      "rating": 5.0,
      "author": "Vunserpenk",
      "isVerified": true
    }
  ]
}
```

The record above was produced with this input:

```json
{
  "searchQueries": ["socks"],
  "maxItems": 5,
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviews": 5,
  "detailConcurrency": 5,
  "storeId": "3991",
  "zipCode": "55401",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---|---|---|---|
| `searchQueries` | array | No\* | — | Free-text terms | Target search terms; combined with `startUrls` when both are set |
| `startUrls` | array (requestListSources) | No\* | — | Target search, category, deals, clearance, product, brand, or weekly-ad URLs | URL-based entry point |
| `maxItems` | integer | No | `10` | `0` or any positive integer | Maximum products across all seeds; `0` = unlimited |
| `includeProductDetails` | boolean | No | `false` | `true` / `false` | Collect detail fields (charged as `product-details`) |
| `includeReviews` | boolean | No | `false` | `true` / `false` | Collect nested reviews (charged as `product-reviews`) |
| `maxReviews` | integer | No | `10` | `0` or any positive integer | Maximum reviews per product; `0` = all available, internally capped |
| `detailConcurrency` | integer | No | `5` | `1`–`15` | Parallel enrichment workers when details or reviews are enabled |
| `storeId` | string | No | `3991` | Target store ID | Store used for local pricing and weekly ads (`3991` = online catalog) |
| `zipCode` | string | No | `55401` | US ZIP code | ZIP sent with listing and product requests for store-local pricing |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` group | Apify proxy groups or custom proxies | Residential proxies are recommended |

\* Provide at least one of `searchQueries` or `startUrls`.

Minimal request:

```json
{ "searchQueries": ["socks"] }
```

Advanced request (URL entry point with enrichment and store context):

```json
{
  "startUrls": [{ "url": "https://www.target.com/s?searchTerm=socks" }],
  "maxItems": 100,
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "storeId": "3991",
  "zipCode": "55401",
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

### Retrieve the data through the API

Records are delivered through the Apify Actor and Dataset APIs — not an official Target API.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "searchQueries": ["socks"],
    "maxItems": 10,
    "includeProductDetails": True,
}

run = client.actor("datascrapers/target-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["tcin"], item["title"], item["formattedPrice"])
```

Apify generates ready-to-run Python, JavaScript, and cURL examples on the Actor's [API tab](https://apify.com/datascrapers/target-scraper/api). Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: detail and review fields are present only when their input toggle is enabled. Listings alone return a leaner record.
- **Source changes**: Target page structure and values can change; unreadable fields are returned as null or omitted rather than fabricated.
- **Deduplication**: each run appends fresh records. The Actor does not deduplicate products across runs. Use `tcin` as the stable key, or `url` as a secondary key, and filter repeated runs against previously stored identifiers.
- **Failures**: one failed product or seed does not stop the run. The run stops if a spending limit is reached (see run log). `maxItems` caps products; `maxReviews` caps nested reviews.
- **Normalization**: prices and ratings are stored as numbers; `currency` is `USD`; `isOnSale` is a boolean. Display strings such as `formattedPrice` remain as Target renders them.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store catalog prices and TCINs alongside inventory records |
| Google Sheets | Apify Google Sheets integration | Share shortlists and sale flags with merchandising teams |
| PIM / catalog systems | Dataset API or completion webhook | Product-feed refresh |
| S3 / cloud storage | Scheduled export via Apify scheduler + integration | Archival of price and assortment snapshots |

### Pricing and cost examples

The Actor uses pay-per-event pricing. Each run also charges a one-time Actor start. Compute units and proxies are billed by your Apify plan.

| Event | Trigger | Rate |
|---|---|---|
| Actor start | Once per run | $0.00005 |
| `dataset-item` | Each product written to the dataset | $0.001 / product ($1 / 1,000) |
| `product-details` | Details collected (`includeProductDetails`) | $0.001 / product ($1 / 1,000) |
| `product-reviews` | Reviews collected for a product (`includeReviews`) | $0.001 / product ($1 / 1,000) |

Example costs (Actor start is negligible; plan-tier discounts not applied):

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 | Listing only | $1.00 |
| 10,000 | Listing only | $10.00 |
| 1,000 | Listing + product details | $2.00 |
| 1,000 | Listing + details + reviews | $3.00 |
| 10,000 | Listing + details + reviews | $30.00 |

`product-reviews` is charged once per product when reviews are fetched, not once per nested review. Estimates depend on the verified pricing model and the options selected for the run.

### Limitations and responsible data use

- The Actor collects publicly accessible data from Target.com pages only.
- Field availability depends on what Target renders at run time for the selected store and ZIP; some values can be null or missing, and site changes can alter fields.
- The Actor does not provide historical snapshots unless you store them yourself.
- Large runs work more reliably with residential proxies; without them, coverage may degrade.
- You are responsible for compliance with Target's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One Target product. Review records are nested inside the product as a `reviews` array, so a product with 50 reviews still produces a single dataset item. `maxItems` caps products, not reviews.

#### Which field should I use as a unique identifier?

`tcin` is the Target catalog item number and is the recommended deduplication key. `url` is a reasonable secondary key.

#### Are fields nullable or conditional?

Yes. Detail fields exist only when `includeProductDetails` is enabled; `reviews` and `reviewStatistics` exist only when `includeReviews` is enabled. Within available records, fields that Target does not render for a product are returned as null or omitted.

#### Can I retrieve the records as CSV or JSON?

Yes. The dataset can be exported as JSON, CSV, Excel, XML, or HTML from the Apify Console, and queried through the Dataset API.

#### How do I paginate large datasets?

Use the Apify Dataset API to page through items after the run finishes (`offset` and `limit` on the dataset items endpoint), or export the full dataset. During collection, raise `maxItems` (or set `0` for unlimited) if you need more products in one run.

#### Does the Actor return historical data?

No. Each run captures the state of the catalog at run time. To track price or assortment changes, schedule repeated runs and store the outputs yourself.

#### What counts as a billable result?

Four pay-per-event charges can apply: Actor start once per run ($0.00005), a `dataset-item` for every product record ($0.001), a `product-details` charge for each enriched product ($0.001), and a `product-reviews` charge for each product whose reviews are fetched ($0.001). A listing-only run incurs Actor start plus `dataset-item`.

### Related datasets from Data Scrapers

- **[Amazon Search Scraper](https://apify.com/datascrapers/amazon-scraper)** — Marketplace product listings that can be joined with Target records by title or brand for cross-retailer price comparison.
- **[Best Buy Product Scraper](https://apify.com/datascrapers/best-buy-scraper)** — Electronics and appliance records for the same monitoring pipelines.
- **[Costco Product Scraper](https://apify.com/datascrapers/costco-scraper)** — Warehouse-club products that overlap Target grocery, household, and general-merchandise categories.
- **[IKEA Product Scraper](https://apify.com/datascrapers/ikea-scraper)** — Home and furniture catalog records for assortment comparison with Target home goods.
- **[Flipkart Product Scraper](https://apify.com/datascrapers/flipkart-scraper)** — Marketplace product and review records for additional retail-price datasets.
- **[HomeDepot Scraper](https://apify.com/datascrapers/homedepot-scraper)** — Home-improvement product data alongside Target housewares and seasonal categories.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

## `searchQueries` (type: `array`):

Product search terms to look up on Target.com (e.g. "socks", "tide pods", "lego star wars"). Primary input for AI agents — no URL required. Combine with Start URLs if you want both.

## `startUrls` (type: `array`):

Target.com URLs to scrape instead of or in addition to search queries (e.g. "https://www.target.com/s?searchTerm=socks", "https://www.target.com/c/toys-clearance/-/N-5tg3d", "https://www.target.com/p/-/A-14073530", "https://www.target.com/weekly-ad"). Accepts search, category, deals, clearance, product, brand, and weekly-ad pages.

## `maxItems` (type: `integer`):

Maximum number of products to scrape across all queries and URLs (0 = unlimited).

## `includeProductDetails` (type: `boolean`):

When enabled, fetch the full product page for each item (description, specifications, extra images, variants, barcode). Charged as the product-details event in addition to each dataset item.

## `includeReviews` (type: `boolean`):

When enabled, fetch customer reviews for each product. Charged as the product-reviews event in addition to each dataset item.

## `maxReviews` (type: `integer`):

Maximum number of reviews to collect per product when Include Product Reviews is enabled (0 = all, capped internally).

## `detailConcurrency` (type: `integer`):

How many products to enrich in parallel (product details and reviews run at the same time per product). Each worker uses its own proxy session and rotates it periodically. Higher is faster; keep it modest to avoid blocks.

## `storeId` (type: `string`):

Target store ID used for local pricing and weekly ads (e.g. "3991" for the online catalog, "1532" for a specific store). Leave the default unless you need a particular store's prices.

## `zipCode` (type: `string`):

US ZIP code sent with listing and product requests (e.g. "55401", "10001"). Used for store-local pricing context.

## `proxyConfiguration` (type: `object`):

Proxy settings. Apify Residential (US) is recommended for reliable Target access.

## Actor input object example

```json
{
  "searchQueries": [
    "socks"
  ],
  "startUrls": [
    {
      "url": "https://www.target.com/s?searchTerm=socks"
    }
  ],
  "maxItems": 10,
  "includeProductDetails": false,
  "includeReviews": false,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "storeId": "3991",
  "zipCode": "55401",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of scraped Target products

## `runStats` (type: `string`):

Record count and timestamps for this run

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "socks"
    ],
    "startUrls": [
        {
            "url": "https://www.target.com/s?searchTerm=socks"
        }
    ],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/target-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["socks"],
    "startUrls": [{ "url": "https://www.target.com/s?searchTerm=socks" }],
    "maxItems": 10,
    "maxReviews": 10,
    "detailConcurrency": 5,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/target-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "socks"
  ],
  "startUrls": [
    {
      "url": "https://www.target.com/s?searchTerm=socks"
    }
  ],
  "maxItems": 10,
  "maxReviews": 10,
  "detailConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/target-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datascrapers/target-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1ekcLUl1MXhJsfvBX/builds/1sUk93vdcCt4cVTkS/openapi.json