# Pinterest Search Lookup: pinterest scraper from $3/1k (`accountable_eel/pinterest-search-lookup`) Actor

Pinterest scraper for keyword search. Give it search terms and get one flat row per pin: title, description, image URL, outbound link, source domain, board, pinner and reaction count. No login and no cookies. Pay per pin returned; a search that finds nothing is free.

- **URL**: https://apify.com/accountable\_eel/pinterest-search-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Social media, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.28 / 1,000 pin returneds

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

## Pinterest Search Lookup: pinterest scraper from $3/1k

You give this actor a list of Pinterest searches, the same words you would type into Pinterest's
own search box. For each search it reads Pinterest's public, logged-out results and returns one
flat row per pin: the pin title, the pinner's description, Pinterest's own alt text for the
image, a direct link to the full size image, the outbound source URL where the pin has one, the
board it sits on, who pinned it, when, and how many reactions it has. No login, no cookies, no
session token. This actor has no input field that could accept one. Nothing is stored between
runs, so every row is what Pinterest was showing at fetch time.

### Who it's for

Interior, food, fashion and wedding content teams who need a running feed of what is actually
being pinned in their category this week, not what ranked last quarter. Trend researchers
building a mood board dataset they can filter and sort instead of scrolling. SEO and content
strategists mining pin titles and descriptions for the phrasing real people use, which is
frequently nothing like keyword tool output. Affiliate and e-commerce teams tracing pins back to
the sites that published them, using the source domain column to find who is already winning a
visual niche. Agencies reporting on a client's category week over week from a scheduled run.
And AI agents, which get a flat, one row per pin shape over a plain HTTP endpoint with no
pagination to manage and no nested payload to unpick.

### Why this one

- **One row per pin, and the field names never move.** `pinId`, `title`, `description`,
  `altText`, `imageUrl`, `link`, `domain`, `boardName`, `boardUrl`, `pinnerName`,
  `pinnerUsername`, `reactionCount`, `createdAt`, `url`. Apify's MCP layer infers an actor's
  output shape from its recent runs, so a renamed field breaks every agent that calls it. These
  are frozen.
- **You pay per pin, not per search, and never for a miss.** A search that returns nothing costs
  nothing. A search that returns 12 pins bills 12, not 25. Pins your filters removed are not
  billed either.
- **The same pin is never billed twice.** Overlapping searches routinely surface the same pin,
  and Pinterest repeats pins between pages of one search. "Never return the same pin twice" is
  on by default, so each pin is returned, and charged, once per run.
- **It says which fields a pin actually has.** About half of Pinterest search results are images
  a user uploaded directly, with no title and no outbound link. Those come back with `title:
  null` and `link: null` rather than a description copied into the title slot to make the column
  look full. `altText`, which Pinterest generates for every pin, is offered as the field that is
  always there.
- **There is no fake save count.** Pinterest does not send repin or save counts to a logged-out
  request. That was checked directly against both the default and the detailed field set:
  `repin_count`, `aggregated_stats.saves`, `comment_count` and `favorite_user_count` were absent
  on all 25 pins of the build probe. So no `repinCount` column is declared. `reactionCount` is
  offered instead, and it is real.
- **It is a search, not a login.** Everything here comes from the same public endpoint a
  signed-out browser uses. There is no account to connect, nothing to authorise, and no private
  or follower-only content is reachable.

### What you get

Every row starts with the same five fields, then adds the columns you selected in "Which columns
do you want?" (all included by default). With "One row per pin" on, which is the default, each
pin gets its own row.

| Field | Type | Description | Filled on the build probe |
|---|---|---|---|
| `query` | text | The search you submitted, echoed back | always |
| `found` | boolean | `true` if at least one pin was returned for this search | always |
| `status` | text | `OK` on a hit; `NOT_FOUND`, `BAD_FORMAT`, `BLOCKED` or `REQUEST_FAILED` on a miss | always |
| `message` | text | Plain-English reason for a miss, present only when `found` is `false` | on misses |
| `scrapedAt` | ISO 8601 datetime | When the search was run | always |
| `searchQuery` | text | The search term, after a pasted search URL has been unpacked | always |
| `pinCount` | number | How many pins this search returned. This is what you are billed | always |
| `truncated` | boolean | `true` when Pinterest had more and your per-search cap stopped it | always |
| `pinId` | text | Pinterest's numeric pin id, as a string | 25/25 |
| `title` | text | The pin title | 14/25 |
| `description` | text | The description the pinner wrote | 15/25 |
| `altText` | text | Pinterest's own generated description of the image | 25/25 |
| `imageUrl` | link | Largest available version of the image on `i.pinimg.com` | 25/25 |
| `link` | link | The off-Pinterest URL the pin points at | 8/25 |
| `domain` | text | Host of that link, for example `instagram.com` | 8/25 |
| `boardName` | text | Board the pin sits on | 25/25 |
| `boardUrl` | link | Public URL of that board | 25/25 |
| `pinnerName` | text | Display name of the account that pinned it | 25/25 |
| `pinnerUsername` | text | Pinterest username of that account | 25/25 |
| `reactionCount` | number | Total reactions, summed across reaction types | 25/25 |
| `createdAt` | date | When the pin was created, ISO 8601 | 25/25 |
| `url` | link | Public permalink for the pin | 25/25 |
| `pins` | array | The whole pin list in one cell. Only when "One row per pin" is off | always |

The right-hand column is measured, not promised: it is the fill rate across the 25 pins of one
real `kitchen` search captured on 2026-09-08, and the same 25 pins are the fixture the test
suite asserts against. `title`, `description`, `link` and `domain` vary per pin because a native
upload genuinely has none of them.

Deselect any column in the Input tab to drop it from every row. `query`, `found`, `status`,
`message` and `scrapedAt` always stay.

### Price

- **Pin returned**: $3 per 1,000 pins

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

You are billed per pin returned, so a run's cost is something you set, not something you
discover. 1,000 pins is **~$3**, whether that is 40 searches of 25 pins or 20 searches of 50.
The leading Pinterest search scraper on the Store lists $3.99 per 1,000. A search that returns
nothing, a blank line, and a pin your filters dropped are all free.

"Most pins to return per search" is your budget dial. At the default of 25, one search costs
about $0.075.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `queries` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~pinterest-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"queries":["kitchen ideas"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

1) Put your searches into "Pinterest searches to run", one per line. A Pinterest search URL
   pasted from the address bar works too, and its `q` is read out of it.
2) Set "Most pins to return per search". 25 is one Pinterest page and the default; 50 is the
   cap and takes a second request per search.
3) Leave "Try it first" on for the first run. It caps the run at 5 searches so you can see the
   output shape before spending on the full list.
4) Turn on "Only pins that link to a website" if you are looking for source content rather than
   images. It typically keeps about a third of a search.
5) Turn "Try it first" off and press Start to run the whole list.

Typical uses: a weekly snapshot of what is being pinned in a category, mining pin titles and
descriptions for real phrasing, finding the sites behind the pins that rank for a term, or
building a filterable mood board dataset for a client report.

### Input

```json
{
  "queries": [
    "kitchen ideas"
  ]
}
```

One search term per line, the same words you would type into Pinterest's own search box. A Pinterest search URL pasted from your browser works too. Accepted formats: kitchen ideas, minimalist living room, https://www.pinterest.com/search/pins/?q=cottagecore%20bedroom.

### Sample output

One row per pin, with "One row per pin" left on:

| query | found | status | searchQuery | pinCount | truncated | pins | pinId | title | description | altText | imageUrl | link | domain | boardName | boardUrl | pinnerName | pinnerUsername | reactionCount | createdAt | url | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| kitchen ideas | true | OK | kitchen ideas | 25 | true | \<all pins found (full list)> | 101049585382283341 | Explore Montauk Gin 2x8 White Ceramic Subway Wall Tile with Mixed Finish | The Montauk Gin 2x8 White Ceramic Wall Tile reimagines the subway format in durable ceramic—with a distinctively modern feel. The pure white coloring complements a wide range of palettes and design styles. Surface shading and a variety of matte and satin finishes offer artisanal touches to all applications. Get yours now. | a kitchen with wooden cabinets and white counter tops | https://i.pinimg.com/originals/bc/54/e8/bc54e89cd5e3e093314c3349401ec38e.png | https://www.tilebar.com/montauk-gin-2x8-ceramic-wall-tile-satin.html | tilebar.com | Tiles & Backsplashes | https://www.pinterest.com/TileBar/tiles-backsplashes/ | TileBar | TileBar | 51 | 2024-01-14T07:22:59.000Z | https://www.pinterest.com/pin/101049585382283341/ | 2026-09-08T17:47:25.482Z |

A real pin from a `kitchen` search:

| field | value |
|---|---|
| `pinId` | 309763280644328288 |
| `title` | Cozy Kitchen Ideas with Terracotta Tiles & Warm Wood |
| `altText` | a stove top oven sitting inside of a kitchen next to a sink and countertop |
| `imageUrl` | https://i.pinimg.com/originals/ad/0d/91/ad0d91719df46be4eaa9f22f773f7fdd.png |
| `link` | null |
| `domain` | null |
| `boardName` | House Renovation |
| `pinnerName` | Lauren Gibson |
| `pinnerUsername` | laureng453 |
| `reactionCount` | 10 |
| `createdAt` | 2026-08-25T21:43:33.000Z |
| `url` | https://www.pinterest.com/pin/309763280644328288/ |

That pin was uploaded straight to Pinterest, which is why `link` and `domain` are null. A pin
sourced from a website carries both, for example `link: https://www.instagram.com/reel/...` with
`domain: instagram.com`.

A search that returns nothing comes back as a single row with `found: false`, a `status` and a
`message` explaining why, and is never billed.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~pinterest-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"queries":["kitchen ideas"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~pinterest-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"queries":["kitchen ideas"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~pinterest-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"queries":["{{search}}"]}`, mapping the row's search into the `queries` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Pinterest Scraper API: search pins by keyword | Apify" — the agent will find and run this actor.

### Tips

- Keep "Max concurrency" low. It defaults to 2 and caps at 8 on purpose. Pinterest rate limits
  by IP, and a burst that trips it returns nothing while a slower run gets the whole list.
- Leave the proxy on Residential. A plain request from a clean IP works, but a shared datacenter
  pool is the first thing a rate limiter notices, and this portfolio has been caught by exactly
  that before.
- Many narrow searches beat one broad one. Pinterest ranks by its own relevance model, so
  "small kitchen storage" and "galley kitchen" return genuinely different pins, while asking for
  50 of "kitchen" mostly gets you more of the same.
- Use "Only pins that link to a website" when you want source content, and leave it off when you
  want the images themselves. Filtered pins are free either way.
- Sort by `reactionCount` to find what resonated, but do not read it as a save count. It counts
  reactions only, and a lot of high performing pins have zero.
- `imageUrl` points at the original upload, which can be several megabytes. If you are rendering
  a contact sheet, swap `/originals/` for `/736x/` in the URL for a thumbnail.
- Leave "Never return the same pin twice" on when you run overlapping searches in one job. It is
  the difference between paying once and paying three times for the same pin.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`pinterest-search-lookup`) | $0.003 per pin returned, $0.00005 actor start, nothing for a search that finds nothing | One flat row per pin from a public Pinterest search: title, description, alt text, full size image, outbound link and source domain, board, pinner, reactions and creation date | Search results only. It does not read a board, a profile's full pin history, a single pin's comments, or anything behind a login, and Pinterest sends no save or repin count to a logged-out request, so none is reported. |
| **fatihtahta/pinterest-scraper-search** | $3.99 per 1,000 | The most used Pinterest search scraper on the Store, rated 5.00 on 3 reviews as of September 2026 | It is the incumbent in this niche and it works. This is 25% cheaper per pin, does not bill for a pin your filters dropped or a pin already returned earlier in the run, and states its per-field fill rates up front. |
| **Pinterest API v5** | Free, but gated | The official source, with real analytics on pins and boards you own | If the pins you care about are your own, use it. It is OAuth-gated and scoped mostly to your own account, so it does not answer "what is everyone pinning for this term", which is what this does. |
| Doing it yourself | Your time, plus a proxy budget and the maintenance | The same fields | The search page is client rendered and carries no pin data at all, so a naive fetch returns 1 MB of nothing. Finding the resource endpoint behind it, handling its opaque bookmark pagination, deduplicating pins that repeat across pages, and knowing which fields a logged-out response genuinely omits is the work this absorbs. |

Prices and ratings for third-party tools are their published figures as of September 2026 and
are not tracked here. Check the vendor before relying on the comparison.

### FAQ

**Am I charged per search or per pin?**
Per pin returned. A search that returns 12 pins bills 12. A search that returns nothing bills
nothing, and neither does a pin your filters removed or a pin already returned earlier in the
same run.

**Why is `title` empty on so many rows?**
Because those pins have no title. Roughly half of Pinterest search results are images a user
uploaded directly, and Pinterest stores no title for them. The description is not copied into
the title to hide the gap. Use `altText`, which Pinterest generates for every pin, when you need
something on every row.

**Why is there no save or repin count?**
Pinterest does not send one to a logged-out request. This was tested against both the default
and the detailed field set on 25 pins, and every engagement count was absent from both. Rather
than ship a column that is always empty, the actor reports `reactionCount`, which is real.

**How many pins can I get for one search?**
Up to 50. Pinterest serves 25 per page and this actor fetches a second page when you ask for
more. Beyond that, run more specific searches instead. They return genuinely different pins,
where deeper paging on a broad term mostly returns more of the same.

**Does it need a Pinterest account or a session cookie?**
No. It reads the same public endpoint a signed-out browser uses, and there is no input field
that could accept a credential. Nothing private or follower-only is reachable.

**What does `BLOCKED` mean?**
Pinterest returned HTTP 403, 429 or 503, which means it is rate limiting this run. Lower "Max
concurrency" and make sure the proxy is set to Residential. Blocked rows are free, so a retry
costs only the actor start.

**Can I search boards or people instead of pins?**
No. This searches pins. Board and profile search are different endpoints with a different output
shape and are not covered.

**Is this a live read or a stored database?**
Live. Every run queries Pinterest at that moment, so a pin created this morning can appear this
afternoon. Nothing is cached between runs, and nothing is stored afterwards.

**Can an AI agent call this directly?**
Yes. It is on the Apify MCP server, so an agent in Claude, Cursor or any MCP client can find and
run it by name, or you can call the REST endpoint above from any script or workflow tool.

**Is this GDPR-relevant?**
Pins carry a public display name and username of the account that pinned them, which is personal
data in the EU sense even though it is public. Have a lawful basis before you store it, and do
not use the `pinnerName` and `pinnerUsername` columns to build a contact list. Deselect both in
"Which columns do you want?" if you only need the images and links.

### Related actors

- [TikTok Profile Lookup](https://apify.com/accountable_eel/tiktok-profile-lookup): the same
  flat, one row per result shape for TikTok creator profiles.
- [YouTube Channel Lookup](https://apify.com/accountable_eel/youtube-channel-lookup): channel
  title, subscriber count and video count from a handle or channel URL.
- [Google News Lookup](https://apify.com/accountable_eel/google-news-lookup): the same query in,
  many rows out shape for news coverage of a topic.
- [Shopify Store Lookup](https://apify.com/accountable_eel/shopify-store-lookup): once a pin's
  source domain turns out to be a store, this tells you what it sells.

# Actor input Schema

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

One search term per line, the same words you would type into Pinterest's own search box. A Pinterest search URL pasted from your browser works too. Accepted formats: kitchen ideas, minimalist living room, https://www.pinterest.com/search/pins/?q=cottagecore%20bedroom. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

## `maxResults` (type: `integer`):

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `maxPins` (type: `integer`):

Pinterest hands out 25 pins at a time. You pay per pin returned, so this is also your budget control. Capped at 50.

## `linkedPinsOnly` (type: `boolean`):

Keep only pins with an outbound source URL, and drop the ones a user uploaded straight to Pinterest. About a third of pins on a typical search have a link. Filtered pins are never billed.

## `skipDuplicatePins` (type: `boolean`):

On by default. Overlapping searches routinely surface the same pin, and Pinterest repeats pins between pages of one search. With this on, each pin is returned, and billed, exactly once per run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each pin found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "queries": [
    "kitchen ideas"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "maxPins": 25,
  "linkedPinsOnly": false,
  "skipDuplicatePins": true,
  "columns": [
    "searchQuery",
    "pinCount",
    "truncated",
    "pins",
    "pinId",
    "title",
    "description",
    "altText",
    "imageUrl",
    "link",
    "domain",
    "boardName",
    "boardUrl",
    "pinnerName",
    "pinnerUsername",
    "reactionCount",
    "createdAt",
    "url"
  ],
  "expandRows": true,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "queries": [
        "kitchen ideas"
    ],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/pinterest-search-lookup").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 = {
    "queries": ["kitchen ideas"],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/pinterest-search-lookup").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 '{
  "queries": [
    "kitchen ideas"
  ],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/pinterest-search-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,accountable_eel/pinterest-search-lookup"
        }
    }
}

```

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/p3mxP9c3TtjC2rNZu/builds/KF0aq6YXnKxzRGvUw/openapi.json