# Shopify Products Scraper: prices, stock, variants, changes (`usefulapi/shopify-products`) Actor

Scrape any Shopify store, collection or product URL: products, variants, prices, sales and stock. Track price drops, new and removed products daily, with alerts. Works on headless stores and past 25,000 products.

- **URL**: https://apify.com/usefulapi/shopify-products.md
- **Developed by:** [Useful API](https://apify.com/usefulapi) (community)
- **Categories:** E-commerce, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 result rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Shopify Products Scraper: prices, stock, variants and changes

Get every product from any Shopify store: titles, prices, compare-at prices, discounts, stock status, variants, SKUs,
images, tags, vendors and dates. Give it a store, a collection or a product URL. No login, no API key, no browser.

It reads the product feed that every Shopify store publishes, so runs are fast (a 25,000-product store in about 90
seconds) and the data is exactly what the store shows its shoppers.

### Why this one

- **Works where others stop.** Headless stores (custom front ends) and stores behind a firewall often hide their
  product feed. This scraper finds the store's own `myshopify.com` address and reads the feed there.
- **Past 25,000 products.** Shopify's product listing stops at 25,000. For bigger stores it carries on through the
  store's collections, then its sitemap. Products found only in the sitemap are read one by one (a few thousand an
  hour), so very large stores take longer past that point.
- **The right prices, wherever it runs.** Shopify can price a store's feed for the visitor's country, so scrapers can
  return euros or baht depending on where their server is. This one always gets the store's main prices (or the
  country you ask for) and labels them with the right currency.
- **Country prices.** Stores that sell in several countries (Shopify Markets) show other prices per country. Set
  Country to `CA`, `GB`, `DE`... and you get that country's prices, currency and stock. Stores that sell each country
  through a folder (`/en-gb/`) are handled automatically; if a store does not change its prices for that country, the
  summary says so instead of guessing.
- **One row per product or one row per variant.** Variant rows are spreadsheet ready: one line per size and colour
  with its own price, SKU, barcode and stock flag.
- **Filters:** in stock only, on sale only, price range, vendors, product types, tags, title words, created or updated
  since a date ("7 days" works too).
- **Change tracking.** Schedule it daily or hourly and each row says what changed since the last run: `new`,
  `price-drop`, `price-increase`, `back-in-stock`, `sold-out`, `variants-changed`, `content-changed`, or `removed`
  (gone from the store, or from the collection you monitor).
  Switch on "Only changed products" to get just the changes. Works for whole stores up to 25,000 products and for
  collections up to 25,000 (for bigger stores, monitor some of their collections).
- **Barcodes (GTIN, UPC, EAN)** and stock tracking per variant, as an option.
- **Exact stock quantity** per variant, where the store publishes it (through its public storefront key, or as printed
  in its product pages); each row says where the number came from.
- **Best-seller rank:** Shopify's own best-selling order (1 = best seller), on stores with a public storefront key
  (read on 11 of 14 test stores).
- **Product page sections:** Dimensions & Care, Shipping & Returns, Ingredients and similar tabs and accordions.
- **Sales estimates:** with monitoring and exact stock on, units sold since the last run (and restocks), from the
  stock the store publishes. Labelled as estimates: a restock between runs hides the sales before it.
- **Price history:** with monitoring on, the last 5 earlier prices of each variant with the day each changed, and the
  day each product was first seen.
- **Store report, free:** per store, catalogue size, price range and median, share on sale, average discount, new
  products in the last 7 and 30 days (by creation date), top brands, types and tags, the top 10 best sellers among the
  products read, countries shipped to, stock units in the saved rows. In the run's `OUTPUT` record.
- **Collections per product** (Sale, New In...) and **related products** (Shopify's own "you may also like").
- **Alerts:** paste a Slack, Discord, Zapier or Make link and get each run's changes as a message. Free.
- **Clear run summary** per store: name, currency, how it was reached, products read, rows saved, errors in plain words.

### What people use it for

Copy one of these into the JSON input tab, then adjust the store addresses.

**Watch a competitor's prices every day and get only what changed.** Schedule it daily (see "Get alerts" below).

```json
{ "startUrls": ["https://competitor.com"], "maxProductsPerStore": 0, "trackChanges": true, "changesOnly": true }
```

**Export a whole catalogue to Excel or Google Sheets**, one line per size and colour:

```json
{ "startUrls": ["https://store.com"], "maxProductsPerStore": 0, "outputMode": "variants" }
```

**Find a store's best sellers and what is on sale:**

```json
{ "startUrls": ["https://store.com"], "maxProductsPerStore": 0, "bestsellerRank": true, "onSaleOnly": true }
```

**Size up many stores at once** (agencies, market research): run a list of stores and read the free store report
(catalogue size, price range, share on sale, new products, top brands, best sellers):

```json
{ "startUrls": ["https://store-one.com", "https://store-two.com"], "maxProductsPerStore": 0, "bestsellerRank": true, "descriptionFormat": "none" }
```

**Estimate what a competitor sells:** monitoring plus exact stock, run daily; each row then shows units sold since the
last read (on stores that publish stock):

```json
{ "startUrls": ["https://competitor.com"], "maxProductsPerStore": 0, "trackChanges": true, "includeStock": true }
```

### Get alerts when prices drop

1. Switch on **Track changes** (and **Only changed products** if you only want the changes in the dataset).
2. Paste a **Slack** or **Discord** webhook link, or a **Zapier** or **Make** webhook (which can email you), into
   **Send changes to**. After each run you get a short message per store: "3 price drops, 2 new, 1 removed", with up to
   10 examples and their links. It is free, and sent only when something changed.
3. Save the input as a **Task** and add a daily (or hourly) **Schedule** to it.
4. The first run saves the starting point; alerts start from the second run.

You can also use Apify's own **Integrations** on the task (email or Slack on "Run succeeded") instead of step 2.

### Input

| Field | What it does |
|---|---|
| Store, collection or product URLs | `allbirds.com`, `https://shop.com/collections/sale`, `https://shop.com/products/blue-shirt`, or `name.myshopify.com`. As many as you like. |
| Max products per store | Stop each store after this many products. 0 = everything. Through the API, leaving it out means 25. |
| One row per | Product (variants inside) or variant (flat). |
| Country | Two-letter code (`US`, `CA`, `GB`...): prices, currency and stock for that country. Empty = the store's main prices (row field `country` is then empty). |
| Market | The store's country folder such as `en-ca`, for stores that use folders; empty for none. |
| Barcodes and stock tracking | Adds barcode, stock tracking, subscription plans and image alt text. One extra request per product. |
| Exact stock quantity | Units in stock per variant where the store publishes them (`stockQuantity`, `totalStock`, `stockSource`). |
| Product page sections | The page's tabs and accordions as `pageSections` (title and text). |
| Best-seller rank / ranks to read | Shopify's best-selling order as `bestsellerRank`, for the top N (default 1,000). |
| Collections per product | `collections` (handle and title) on each row. |
| Related products | `relatedProducts` (id, title, price, in stock, URL), up to 10 per product. |
| Description | Plain text, HTML, both or none. |
| Filters | In stock, on sale, min and max price, vendors, product types, tags, title contains, created since, updated since. Products read one by one (product URLs, past 25,000) carry no update date and pass the "updated since" filter. |
| Track changes / Only changed products | Monitoring (see above). The first run saves the starting point. |
| Monitor name | Keeps separate histories for different monitors of the same store. |
| Read past 25,000 products | On by default. |
| Proxy | Not needed for most stores. |

Example:

```json
{
    "startUrls": ["https://www.allbirds.com", "kyliecosmetics.com/collections/kylie-skin"],
    "maxProductsPerStore": 0,
    "outputMode": "products",
    "onSaleOnly": true
}
```

### Output

One row per product (example from a real run on 16 Oct 2026, shortened):

```json
{
    "storeUrl": "https://www.allbirds.com",
    "storeName": "Allbirds",
    "currency": "USD",
    "country": null,
    "market": null,
    "productId": 7340901859408,
    "title": "Women's Allbirds Flip Flop - Dusty Pink",
    "handle": "womens-allbirds-flip-flop-dusty-pink",
    "url": "https://www.allbirds.com/products/womens-allbirds-flip-flop-dusty-pink",
    "vendor": "Allbirds",
    "productType": "Shoes",
    "tags": ["allbirds::gender => womens", "allbirds::material => sugar", "shoprunner"],
    "priceMin": 25,
    "priceMax": 25,
    "onSale": true,
    "maxDiscountPercent": 50,
    "available": true,
    "variantsCount": 7,
    "availableVariantsCount": 1,
    "options": [{ "name": "Size", "values": ["5", "6", "7", "8", "9", "10", "11"] }],
    "imageUrl": "https://cdn.shopify.com/s/files/1/1104/4168/files/A12513_26Q2_Allbirds-Flip-Flop-Dusty-Pink_PDP_LEFT.png?v=1774646345",
    "description": "Sun on your feet. Comfort underneath. Light, easy, and made for warm weather...",
    "variants": [
        {
            "id": 42146889039952,
            "title": "5",
            "options": { "Size": "5" },
            "sku": "A12513W050",
            "price": 25,
            "compareAtPrice": 50,
            "onSale": true,
            "discountPercent": 50,
            "available": false,
            "grams": 455,
            "url": "https://www.allbirds.com/products/womens-allbirds-flip-flop-dusty-pink?variant=42146889039952"
        }
    ],
    "createdAt": "2026-03-27T14:03:50-07:00",
    "updatedAt": "2026-10-16T03:59:35-07:00",
    "publishedAt": "2026-09-25T16:58:13-07:00",
    "source": "catalog",
    "scrapedAt": "2026-10-16T10:59:35.015Z"
}
```

With change tracking on, each row also has `changeType`, `changes` (all that apply), `previousPriceMin`,
`previousAvailable`, `priceChanges` (each variant whose price moved, with old and new price), `firstSeenOn`, and per
variant `priceHistory` (`changedOn`, `previousPrice`) and `lastPriceChangeOn`. With exact stock on as well:
`unitsSoldSinceLastRead`, `restockedSinceLastRead`, `hoursSinceLastRead` and `estimatedUnitsSoldPerDay` (given
only when the reads are at least 6 hours apart).

**For Excel or Google Sheets, choose One row per variant:** in product mode, variants, images and collections are
lists that a spreadsheet splits into many columns. In the run's Storage tab, the **Products**, **Variants** and
**Changes** views show the main columns only, and can be exported as they are.

**Readable store report:** each run also saves a page with one card per store (record `REPORT` in the key-value store,
linked from the run's Output tab), ready to forward.

Prices are numbers in the currency of the `currency` field. They are the store's catalogue prices: automatic
discounts that a store applies on its pages or at checkout through apps (for example "40% off everything") are not
in the product feed, so they are not in the rows either. The key-value store record `OUTPUT` has the summary
per store.

### Pricing

Pay per event, no monthly fee:

| Event | Price |
|---|---|
| Result row (product, or variant in variant mode) | USD 0.90 per 1,000 |
| Catalog page read (up to 250 products) | USD 0.0005 (USD 0.002 per 1,000 products read) |
| Store checked | USD 0.0005 per store per run |
| Product lookup: barcodes, product URLs, products past 25,000, a product page read (stock or sections), related products | USD 0.50 per 1,000 |
| Storefront-key request: best-seller ranks (per 250), stock and collections (per 100 products) | USD 0.0005 each, counted as a catalog page |
| Run start | USD 0.002 |

1,000 products from one store cost about USD 0.90. Filtered-out and unchanged products are never billed as results
(and never get a barcode lookup); only the pages read to find them count. Set a maximum cost per run and the scraper
stops at it, still saving its summary and change-tracking snapshots.

### Good to know

- **Stock numbers:** every row says in stock or not per variant. Exact quantities only come where the store publishes
  them (4 of 12 test stores); a store's page and its storefront key can show different counts for
  large stocks (two counts the store keeps), so `stockSource` tells you which you got. Nothing is guessed.
- **Password-protected stores** (not open yet) cannot be read; the summary says so.
- **Not a Shopify store?** The summary says so, and you are only billed the store check.
- **Very slow stores** are stopped so a run never drags on; the summary says which.
- **Billing of lookups:** a product URL (or a product past 25,000) is billed when the store answers, found or not. A
  barcode lookup, a product page read and a related-products lookup are billed only when they return what was asked
  for (a page with no stock count and no sections is not billed; after 5 such pages the store's pages are skipped).
  Blocked or unanswered requests are never billed.
- **Change tracking** keeps a small snapshot per store in a key-value store named `shopify-products-monitor` on your
  account. Delete it to start a monitor from scratch.
- Removed products are reported only when both this scan and an earlier one read the whole store (or collection), and
  this scan saw at least 80% of what the last one did. A bigger drop (a sale that ended) is reported once the next
  complete scan confirms it. With filters on, only products that matched them are reported as removed. The first run of a monitor
  saves the starting point. In variant mode, a size or colour that disappears comes as a `removed` variant row.
- If Apify moves a long run to another server, it resumes where it was: nothing is saved or billed twice.

### FAQ

**Does it work on any Shopify store?**
On most: 116 of 125 stores in our test. Stores behind an anti-bot wall (Cloudflare and similar) cannot be read, and the
run summary says so instead of returning an empty result. Headless stores (custom front ends) are read through their
Shopify address automatically.

**How do I get the data into Excel or Google Sheets?**
Choose **One row per variant**, run, then export the dataset as CSV or Excel (or connect Google Sheets in the run's
Integrations). Each size and colour is one line with its own price, SKU, barcode and stock flag.

**What does it cost?**
About USD 0.90 per 1,000 products. A 10,000-product store costs about USD 9; a daily price watch of a 5,000-product
store with "Only changed products" costs about USD 0.05 a day. You can set a maximum cost per run; the run stops at it.

**Can I get prices in another currency or country?**
Yes: set **Country** (for example `GB` or `CA`) and you get that country's prices, currency and stock, as a shopper
there would see them. Without it, you get the store's main prices, whatever the location of the server.

**How do I get alerts when a competitor changes prices?**
Switch on Track changes, paste a Slack, Discord, Zapier or Make link into **Send changes to**, and schedule the run
daily. See "Get alerts when prices drop" above.

**Can I get the exact stock count?**
Where the store publishes it (about 1 store in 3 in our tests): switch on **Exact stock quantity**. Every row also says
in stock or not per variant, for every store.

**Is scraping Shopify stores allowed?**
The tool reads only the public product data a store publishes for shoppers and search engines: no login, no personal
data, no password-protected stores. Check that your use of the data fits your local rules and the store's terms.

### Use it from code

```bash
curl -X POST "https://api.apify.com/v2/acts/<USERNAME>~shopify-products/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": ["https://www.allbirds.com"], "maxProductsPerStore": 100}'
```

### Responsible use

The scraper reads only public product information that stores publish for shoppers and search engines. It does not
collect personal data, log in, or get past password pages. It waits between requests to the same store and slows down
when a store asks it to.

# Actor input Schema

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

Any Shopify store address (allbirds.com), a collection (…/collections/sale) or a product (…/products/handle). One per line. Headless stores and stores behind a firewall are reached through their myshopify.com address automatically.

## `maxProductsPerStore` (type: `integer`):

Stop each store after this many products are saved. 0 = the whole catalogue (past Shopify's 25,000 listing limit too). Through the API, leaving this out means 25.

## `outputMode` (type: `string`):

Product: one row per product with its variants inside. Variant: one row per size/colour, best for price and stock sheets.

## `market` (type: `string`):

For stores with a country folder in their URLs: the folder, for example en-ca, en-gb, fr, de-ch. Empty for none. To get another country's prices on a store without folders, use Country instead.

## `country` (type: `string`):

2-letter code such as US, CA, GB, DE. Prices, currency and stock then follow that country's market, as a shopper there would see them. Empty = the store's main prices (never the prices for the country of the server running the scraper).

## `includeDetails` (type: `boolean`):

Adds each variant's barcode (GTIN/UPC/EAN), whether stock is tracked, subscription (selling plan) info and image alt text. One extra request per product, so slower and billed per product lookup (only for products that pass the filters and, with Only changed products, only for changed ones).

## `includeStock` (type: `boolean`):

Units in stock per variant, where the store publishes them: through the store's public storefront key when the store allows it (one request per 100 products, billed as a catalog page), otherwise as printed in the product page (one page read per product, billed as a product lookup only when the page shows a count). Each row says which (stockSource). Stores that publish neither leave it empty.

## `includePageSections` (type: `boolean`):

The product page's collapsible sections (for example Dimensions & Care, Shipping & Returns, Ingredients), where the theme uses standard tabs or accordions. One page read per product, billed as a product lookup only when the page has sections.

## `bestsellerRank` (type: `boolean`):

Shopify's own best-selling order, through the store's public storefront key (1 = best seller). One request per 250 ranks, billed as a catalog page. Not available on stores without a public key; the summary says so.

## `bestsellerLimit` (type: `integer`):

How many of the best sellers get a rank; products further down get none.

## `includeCollections` (type: `boolean`):

The collections each product belongs to (for example Sale, New In, Best Sellers), through the store's public storefront key: one request per 100 products, billed as a catalog page. Not available on stores without a key; the summary says so.

## `includeRelated` (type: `boolean`):

Shopify's own 'you may also like' products for each product, with price and stock flag. One request per product, billed as a product lookup when the store returns related products.

## `relatedLimit` (type: `integer`):

How many related products to keep per product (Shopify returns at most 10).

## `descriptionFormat` (type: `string`):

How the product description is saved: plain text (default), the store's HTML, both, or left out to keep rows small.

## `onlyAvailable` (type: `boolean`):

Keep products with at least one variant for sale (variant rows: only variants for sale).

## `onSaleOnly` (type: `boolean`):

Keep variants whose compare-at price is above the price.

## `minPrice` (type: `integer`):

In the store's currency, whole units.

## `maxPrice` (type: `integer`):

In the store's currency, whole units.

## `vendors` (type: `array`):

Exact vendor names, any of them.

## `productTypes` (type: `array`):

Exact product types, any of them.

## `tags` (type: `array`):

Products with any of these tags.

## `titleContains` (type: `array`):

Words or phrases; a product matches if its title contains any of them.

## `createdSince` (type: `string`):

A date (2026-10-01) or a period (7 days, 2 weeks). Finds new products.

## `updatedSince` (type: `string`):

A date (2026-10-01) or a period (24 hours, 7 days). Products read one by one (product URLs, past 25,000) have no update date and always pass.

## `trackChanges` (type: `boolean`):

Each row gets changeType: new, price-drop, price-increase, back-in-stock, sold-out, variants-changed, content-changed (title, description, tags, images) or unchanged; products gone from the store come as removed. The snapshot is kept in a key-value store on your account. Stores and collections up to 25,000 products. With monitoring on, rows also carry price history (the last 5 earlier prices and the day each changed), the day the product was first seen and, with Exact stock quantity on, units sold since the last read, estimated from the stock drop.

## `changesOnly` (type: `boolean`):

Save only rows that changed since the last run. The first run saves the baseline and outputs nothing.

## `monitorName` (type: `string`):

Optional. Keeps separate histories for different monitors of the same store (letters, digits, dashes).

## `notifyUrl` (type: `string`):

Optional. Paste a Slack or Discord webhook link, or a Zapier or Make webhook (which can send you an email). At the end of each run you get a short message: per store, the number of price drops, new, back-in-stock, sold-out and removed products, with up to 10 examples and their links. With Track changes on, a message is sent only when something changed. Free: not billed.

## `beyondLimit` (type: `boolean`):

Shopify's listing stops at 25,000 products. When a store is bigger, continue through its collections and its sitemap.

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

Not needed for most stores. Datacenter proxy only; residential proxy is not supported.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.allbirds.com",
    "https://colourpop.com"
  ],
  "maxProductsPerStore": 100,
  "outputMode": "products",
  "market": "",
  "includeDetails": false,
  "includeStock": false,
  "includePageSections": false,
  "bestsellerRank": false,
  "bestsellerLimit": 1000,
  "includeCollections": false,
  "includeRelated": false,
  "relatedLimit": 6,
  "descriptionFormat": "text",
  "onlyAvailable": false,
  "onSaleOnly": false,
  "trackChanges": false,
  "changesOnly": false,
  "beyondLimit": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `products` (type: `string`):

One row per product, or per variant in variant mode. Download as JSON, CSV or Excel.

## `summary` (type: `string`):

Store name, currency, how it was reached, products read, rows saved, change counts and any error.

## `report` (type: `string`):

One card per store: catalogue size, prices, share on sale, new products, top brands, best sellers, changes since the last 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 = {
    "startUrls": [
        "https://www.allbirds.com",
        "https://colourpop.com"
    ],
    "maxProductsPerStore": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("usefulapi/shopify-products").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 = {
    "startUrls": [
        "https://www.allbirds.com",
        "https://colourpop.com",
    ],
    "maxProductsPerStore": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("usefulapi/shopify-products").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 '{
  "startUrls": [
    "https://www.allbirds.com",
    "https://colourpop.com"
  ],
  "maxProductsPerStore": 100
}' |
apify call usefulapi/shopify-products --silent --output-dataset

```

## MCP server setup

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

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/2f22eyQ8h7Sz7OAsG/builds/xYtaY3IMTHU2cmd9w/openapi.json