# Car-Part Scraper — Used Auto Parts Prices & Recycler Stock (`crawloop/car-part-scraper`) Actor

Scrape Car-Part used auto parts: prices, ARA grades, stock numbers, year/make/model, core charges, ZIP distance, and photos. One part, a year range, or several parts on one vehicle. Phone and email stay off unless you opt in.

- **URL**: https://apify.com/crawloop/car-part-scraper.md
- **Developed by:** [Andrej Kiva](https://apify.com/crawloop) (community)
- **Categories:** E-commerce, Other
- **Features:** Limited permissions
- **Stats:** 33 total users, 15 monthly users, 99.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 part listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Car-Part Scraper — Used Auto Parts Prices, Grades & Recycler Inventory

> **Disclaimer:** Unofficial tool — not affiliated with, sponsored by, or endorsed by Car-Part or its affiliates. Data is read from publicly accessible pages only. No login. You are responsible for complying with applicable law (including GDPR where personal data appears) and the site’s terms. No warranty on accuracy or availability. Provided for informational and research use.

> **Contact-data controls:** Phone/WhatsApp/fax and email fields are omitted from the dataset by default. Enable `includePhones` and/or `includeEmails` only for contacts already published on public pages and only when you have a lawful basis. Any contact-field examples below assume that explicit opt-in; otherwise those fields are absent.

Scrape **used auto parts** inventory from North America's largest recycler marketplace network. Extract structured listings: part name, donor **year / make / model**, asking **price**, **core charge**, **ARA part grade**, stock number, mileage, supplier name and website, distance from ZIP, live-chat flag, and part photos.

Search one **year + make/model + part**, a **year range**, several parts on the same vehicle, or paste existing `search.cgi` result URLs. Handles **interchange** refine pages, multi-page results, and US residential proxy defaults for Cloudflare.

**Best for:** used-parts price intelligence, salvage / recycler sourcing, body-shop inventory checks, core-charge research, and ZIP-distance supplier shortlists.

> **Crawloop auto & salvage suite** — find the Actor for your task.

| I need… | Actor |
| :--- | :--- |
| Used part price from recyclers | **Car-Part Scraper** ◄ you are here · [PartsHotlines](https://apify.com/crawloop/partshotlines-scraper) · [LKQ Online](https://apify.com/crawloop/lkqonline-scraper) |
| A donor car in a self-service yard | [Row52](https://apify.com/crawloop/row52-scraper) · [Pick-n-Pull](https://apify.com/crawloop/picknpull-scraper) |
| Salvage auction lots, bids, VIN | [Copart](https://apify.com/crawloop/copart-scraper) · [IAAI](https://apify.com/crawloop/iaai-scraper) |
| New part catalog price | [RockAuto](https://apify.com/crawloop/rockauto-scraper) · [CarParts.com](https://apify.com/crawloop/carparts-com-scraper) · [Oscaro](https://apify.com/crawloop/oscaro-scraper) (EUR) |
| Whole-car prices | [Cars.com](https://apify.com/crawloop/cars-com-scraper) · [Cars & Bids](https://apify.com/crawloop/cars-and-bids-scraper) · [Facebook Marketplace](https://apify.com/crawloop/facebook-marketplace-scraper) · [Mobile.de](https://apify.com/crawloop/mobile-de-scraper) · [AutoScout24](https://apify.com/crawloop/autoscout24-scraper) · [AutoTrader.ca](https://apify.com/crawloop/autotrader-ca-scraper) · [AutoTrader UK](https://apify.com/crawloop/autotrader-uk-scraper) |
| Heavy-truck parts and trucks | [Vander Haag's Parts](https://apify.com/crawloop/vanderhaags-parts-scraper) · [TruckPaper](https://apify.com/crawloop/truckpaper-scraper) |

### When to use this Actor

- **Parts price benchmarking** — Compare recycler asking prices for engines, transmissions, body panels, lighting, and electronics by vehicle year and model.
- **Whole-vehicle pricing** — Send `queries` with several parts (engine, transmission, hood, headlight) and get one dataset. `maxItems` caps the run.
- **Local sourcing** — Sort by distance from a buyer ZIP. Turn on `includePhones` and `includeEmails` to add yard phone and email.
- **Interchange-aware searches** — Take the first option, match a trim/VIN label, or walk interchange choices (at most 8 branches; a nested page uses only its first child).
- **Exact browser searches** — Paste a `search.cgi` URL to resume a filtered results set without re-entering the form.

### Data pipeline

```
Input                         Flow                            Output
─────────────────────        ─────────────────────           ──────────────────────────
year + makeModel + part  ──► catalog resolve + form POST ──► interchange (optional)
queries (many parts)     ──► one search per part         ──► shared maxItems cap
startUrls (search.cgi)   ──► paginate results pages      ──► quoteForm + table parse
ZIP + sort + year range  ──► US residential HTTP         ──► price, grade, yard, images
```

### Key Features

- **Catalog resolution** — Fuzzy-matches make/model and part names against the live dropdown catalog (1,600+ models, 700+ part types). Prefer exact labels like `Engine` or `Headlight Assembly`.
- **Structured quote fields** — Reads `quoteForm.cgi` parameters (stock, price, seller id) for reliable records.
- **ARA grade & core charge** — Captures part grade and core / exchange fees when shown.
- **Supplier** — Name, website, city / state / country, live chat flag. Phone and email are added only when `includePhones` / `includeEmails` are on.
- **Year range** — Optional `yearTo` is sent as Car-Part's end year. Empty means the single start year.
- **Several parts** — `queries` runs engine, transmission, and body parts in one Actor run. A filled list ignores the single year / make / part fields.
- **Images** — CDN photo URLs when recyclers upload pictures.
- **US residential proxy default** — Required for stable access to `search.cgi` behind Cloudflare.

### Input Parameters

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `includePhones` | Boolean | `false` | Add phone, mobile, WhatsApp, or fax already published on the page. |
| `includeEmails` | Boolean | `false` | Add email already published on the page. |
| `startUrls` | Array | `[]` | Car-Part `search.cgi` result URLs. Skips the form when set. |
| `year` | Integer | — | Vehicle year (required for a single-part search). |
| `yearTo` | Integer | — | Optional end year. Empty searches only `year`. Applies to every `queries` row. |
| `makeModel` | String | — | Catalog make/model, e.g. `Toyota Camry`. Ignored when `queries` has rows. |
| `part` | String | — | Catalog part name, e.g. `Engine`. Ignored when `queries` has rows. |
| `queries` | Array | `[]` | Several `{year, makeModel, part}` rows for one vehicle. |
| `userZip` | String | — | ZIP / postal code for distance sorting. |
| `userLocation` | String | `USA` | All States / USA / Canada / Mexico. |
| `sortBy` | String | `price` | `price`, `zip`, `grade`, `year`, `condition`. |
| `interchangeMode` | String | `first` | `first`, `match`, or `all`. `all` stops after 8 branches. |
| `interchangeQuery` | String | — | Substring for `match` mode (e.g. `2.5L`). |
| `vin` | String | — | Optional VIN passed through to Car-Part Smart VIN search. |
| `maxItems` | Integer | `100` | Max listings for the whole run (`0` = unlimited). |
| `maxPages` | Integer | `20` | Max result pages per search / interchange branch. |
| `concurrency` | Integer | `1` | Parallel page fetches (1–5). |
| `softDeadlineSecs` | Integer | `0` | Stop early and return partial results. `0` uses 720s. The default run timeout is 300s, so for large searches raise the run timeout or set this below it. |
| `proxyConfiguration` | Object | US RESIDENTIAL | Apify Proxy — US residential required. |
| `monitorMode` | Boolean | `false` | Scheduled delta mode: only new listings and price drops. |
| `monitorStoreName` | String | `car-part-monitor` | Named KV store for fingerprints between runs. |
| `resetMonitorState` | Boolean | `false` | Clear monitor state; next run is a new baseline. |

### Monitor new parts and price drops

Turn on `monitorMode` when you run this Actor on an **Apify Schedule** (for example hourly or daily) with the same search input. The **first run** saves a baseline of every listing it scans and still returns rows up to `maxItems`. Later runs scan the full result set (bounded by `maxPages`) but **emit and charge only new listings and price drops** — unchanged rows update internal state only.

Use a dedicated `monitorStoreName` per watch (for example `camry-engine-90210`) so parallel schedules do not overwrite each other. Set `resetMonitorState` to true when you change the search or want to rebuild the baseline.

```json
{
  "year": 2019,
  "makeModel": "Toyota Camry",
  "part": "Engine",
  "userZip": "90210",
  "monitorMode": true,
  "monitorStoreName": "camry-engine-90210",
  "maxItems": 50,
  "maxPages": 20
}
```

Tip: pair monitor mode with an Apify Schedule on this Actor so you get a steady feed of new inventory and lower prices without re-downloading the whole market every time.

#### Input example — form search

```json
{
  "year": 2019,
  "makeModel": "Toyota Camry",
  "part": "Engine",
  "userZip": "90210",
  "userLocation": "USA",
  "sortBy": "price",
  "interchangeMode": "first",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

#### Input example — several parts on one vehicle

```json
{
  "yearTo": 2019,
  "userZip": "90210",
  "userLocation": "USA",
  "sortBy": "price",
  "interchangeMode": "first",
  "maxItems": 80,
  "queries": [
    { "year": 2015, "makeModel": "Toyota Camry", "part": "Engine" },
    { "year": 2015, "makeModel": "Toyota Camry", "part": "Transmission" },
    { "year": 2015, "makeModel": "Toyota Camry", "part": "Hood" },
    { "year": 2015, "makeModel": "Toyota Camry", "part": "Headlight Assembly" }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

`year`, `makeModel`, and `part` outside `queries` are ignored while that list has rows. `yearTo` applies to every row.

#### Input example — result URL

```json
{
  "startUrls": [
    {
      "url": "https://www.car-part.com/cgi-bin/search.cgi?userDate=2013&userModel=Volkswagen%20Golf%20GTI&userPart=Engine&userZip=06095&userPreference=price&userPage=1"
    }
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

### Output Format

Each dataset item is one recycler part offer:

| Field | Description |
| :--- | :--- |
| `listingId`, `sessionId` | Composite listing key; search-session token |
| `year`, `makeModel`, `partName` | Donor vehicle and part type as listed |
| `requestedYear`, `requestedYearTo`, `requestedMakeModel`, `requestedPart` | Search that produced the row. `requestedYearTo` is empty for a single year. |
| `description`, `interchangeCode` | Condition / interchange notes |
| `price`, `priceFormatted`, `priceCad`, `coreCharge`, `currency` | Pricing. `priceCad` is the Canadian dollar amount when the cell includes `--Can--`. |
| `partGrade`, `stockNumber`, `mileage` | Grade, stock tag, donor miles |
| `supplierName`, `supplierWebsite` | Recycler name and site. `supplierPhone` and `supplierEmail` appear only when `includePhones` / `includeEmails` are on. |
| `country`, `stateProvince`, `city`, `distanceMiles` | Location & distance from ZIP |
| `liveChatAvailable`, `imageUrls` | Chat flag and photo URLs |
| `scrapedAt` | UTC ISO timestamp |

#### Output example

```json
{
  "listingId": "1127-3S2523-2010-3120",
  "sessionId": "13000000735758473",
  "year": 2010,
  "makeModel": "Audi A3",
  "partName": "Engine Assembly",
  "requestedYear": 2010,
  "requestedYearTo": null,
  "requestedMakeModel": "Audi A3",
  "requestedPart": "Engine",
  "description": "2.0L,AT,AWD,W/TURBO",
  "price": 3120,
  "priceFormatted": "$3120",
  "coreCharge": null,
  "currency": "USD",
  "partGrade": "A",
  "stockNumber": "3S2523",
  "mileage": 0,
  "supplierName": "All Foreign Auto Parts - PRP Freight, CDC",
  "supplierWebsite": "http://Www.AllForeignAutoParts.com",
  "sellerId": "1127",
  "country": "USA",
  "stateProvince": "PA",
  "city": "Pittsburgh",
  "distanceMiles": 390,
  "liveChatAvailable": true,
  "imageUrls": ["https://wsimgky.car-part.com/3885/2023/3S2523/3885_396029_01.jpg"],
  "dbPart": "300.1",
  "dbModel": "75.29.1.1",
  "interchangeCode": "CDFDE",
  "scrapedAt": "2026-07-24T16:00:00Z"
}
```

### Notes

- **Proxy:** Datacenter IPs typically receive Cloudflare 403 on `cgi-bin/search.cgi`. Keep US residential enabled.
- **Exact catalog names:** Prefer exact part labels (`Engine`, not a free-text synonym). The Actor fuzzy-matches, but exact values are more reliable.
- **Interchange `all`:** At most 8 branches per search. A nested interchange page keeps only its first child. Pair with a tight `maxItems` / `maxPages`.
- **`queries`:** One bad catalog name is skipped. If every row fails, the run finishes with 0 listings and the first catalog error.

### Use cases

| Use case | What you get |
| :--- | :--- |
| **Parts price benchmarking** | Recycler asking prices by year / make / model / part |
| **Local sourcing** | ZIP distance + supplier name / website. Phone and email only with `includePhones` / `includeEmails`. |
| **Whole vehicle** | Several parts in `queries`, one dataset, one `maxItems` cap |
| **Interchange coverage** | First option, a text match, or up to 8 branches. Nested pages keep the first child. |
| **Salvage / body-shop ops** | ARA grade, stock #, core charge, photos |
| **AI / MCP workflows** | Run via Apify API, clients, or MCP and summarize part offers |

### Integration examples

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('crawloop/car-part-scraper').call({
  year: 2019,
  makeModel: 'Toyota Camry',
  part: 'Engine',
  userZip: '90210',
  maxItems: 50,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'US',
  },
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 5));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token)
run = client.actor("crawloop/car-part-scraper").call(
    run_input={
        "year": 2019,
        "makeModel": "Toyota Camry",
        "part": "Engine",
        "userZip": "90210",
        "sortBy": "price",
        "maxItems": 50,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "US",
        },
    }
)
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(len(items), items[:3])
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/crawloop~car-part-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "year": 2019,
    "makeModel": "Toyota Camry",
    "part": "Engine",
    "userZip": "90210",
    "maxItems": 50,
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
  }'
```

### MCP and AI assistants

Use this Actor from AI tools via [Apify MCP](https://docs.apify.com/platform/integrations/mcp). Connect your Apify account, then call `crawloop/car-part-scraper`.

Example prompts:

- "Run Car-Part Scraper for 2019 Toyota Camry Engine near ZIP 90210, max 50, and return price, partGrade, supplierName, distanceMiles"
- "Scrape Car-Part offers for a 2015 Honda Civic Headlight Assembly and summarize the cheapest 10"
- "Chain [Copart Scraper](https://apify.com/crawloop/copart-scraper) then Car-Part Scraper when I have a salvage lot year/make/model and need used engine and transmission prices"

# Actor input Schema

## `includePhones` (type: `boolean`):

Off by default. Include phone, mobile, WhatsApp, or fax fields already published on public pages only when you have a lawful basis.

## `includeEmails` (type: `boolean`):

Off by default. Include email fields already published on public pages only when you have a lawful basis.

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

Paste Car-Part search result URLs (cgi-bin/search.cgi?...). Skips the year/model/part form when provided. Example: https://www.car-part.com/cgi-bin/search.cgi?userDate=2019\&userModel=Toyota%20Camry\&userPart=Engine&...

## `year` (type: `integer`):

Donor vehicle model year (e.g. 2019). Required for a single-part search when startUrls and queries are empty.

## `yearTo` (type: `integer`):

Optional end year for a range (Car-Part userDate2). Leave empty to search only the start year. Applies to the single search and to every row in queries.

## `makeModel` (type: `string`):

Exact Car-Part catalog make/model string, e.g. Toyota Camry, Ford F-150, Volkswagen Golf GTI. Fuzzy-matched against the live catalog when not exact.

## `part` (type: `string`):

Exact Car-Part part name from the catalog, e.g. Engine, Transmission, Hood, Headlight Assembly. Fuzzy-matched when not exact. Ignored when queries has rows.

## `queries` (type: `array`):

Price more than one part in a single run. Each object needs year, makeModel, and part, for example \[{"year":2015,"makeModel":"Toyota Camry","part":"Engine"},{"year":2015,"makeModel":"Toyota Camry","part":"Transmission"}]. When this list has rows, year / makeModel / part above are ignored. maxItems caps the whole run.

## `userZip` (type: `string`):

Buyer ZIP (US) or postal code used for distance sorting and Dist column. Strongly recommended.

## `userLocation` (type: `string`):

Geographic scope for recycler inventory.

## `sortBy` (type: `string`):

Car-Part sort preference mapped to userPreference.

## `interchangeMode` (type: `string`):

When Car-Part asks to refine interchange (engine trim, VIN digit, etc.): take the first option, match by text, or scrape options. All is capped at 8 branches; a nested interchange page uses only its first child.

## `interchangeQuery` (type: `string`):

Used when interchangeMode=match. Substring match against interchange option labels (e.g. 2.5L, VIN G, AT, 4WD).

## `vin` (type: `string`):

Optional VIN for Car-Part Smart VIN lookup. Leave empty for year/make/model search.

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

Maximum part listings to collect. 0 = unlimited (bounded by pages × results).

## `maxPages` (type: `integer`):

Maximum result pages to follow per search / interchange branch. 0 = unlimited.

## `concurrency` (type: `integer`):

Parallel page fetches for pagination / multi-interchange (1–5). Default 1 reduces Cloudflare blocks; raise only if success stays high.

## `softDeadlineSecs` (type: `integer`):

Stop pagination / interchange branches after N seconds and return partial results instead of TIMED-OUT. 0 = default 720s.

## `monitorMode` (type: `boolean`):

When scheduled (hourly/daily), emit and charge only new listings and price drops since the last run. The first run builds a baseline and still returns rows.

## `monitorStoreName` (type: `string`):

Named key-value store that keeps listing fingerprints between runs. Use a distinct name per watch or search.

## `resetMonitorState` (type: `boolean`):

Clear stored monitor state before this run. The run becomes a new baseline.

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

Apify Proxy. US RESIDENTIAL is required — datacenter IPs receive Cloudflare 403 on search.cgi.

## Actor input object example

```json
{
  "includePhones": false,
  "includeEmails": false,
  "startUrls": [],
  "year": 2019,
  "makeModel": "Toyota Camry",
  "part": "Engine",
  "queries": [],
  "userZip": "90210",
  "userLocation": "USA",
  "sortBy": "price",
  "interchangeMode": "first",
  "interchangeQuery": "",
  "vin": "",
  "maxItems": 100,
  "maxPages": 20,
  "concurrency": 1,
  "softDeadlineSecs": 0,
  "monitorMode": false,
  "monitorStoreName": "car-part-monitor",
  "resetMonitorState": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Default dataset items — part listings with price, grade, stock number, dealer contacts, and images.

# 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 = {
    "year": 2019,
    "makeModel": "Toyota Camry",
    "part": "Engine",
    "userZip": "90210"
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawloop/car-part-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 = {
    "year": 2019,
    "makeModel": "Toyota Camry",
    "part": "Engine",
    "userZip": "90210",
}

# Run the Actor and wait for it to finish
run = client.actor("crawloop/car-part-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 '{
  "year": 2019,
  "makeModel": "Toyota Camry",
  "part": "Engine",
  "userZip": "90210"
}' |
apify call crawloop/car-part-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawloop/car-part-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/YJtKnjFupdQDdpN05/builds/SMY7d2txpgm53fXlA/openapi.json