# Behance Scraper - Projects, Creators & Designer Leads (`scrapesage/behance-scraper`) Actor

Scrape Behance projects, creators and creative jobs: portfolios, views/appreciations, tools, tags, plus designer leads with availability-for-hire, budget, social links, location and contact enrichment. Keyless, no browser, with a new-content monitor.

- **URL**: https://apify.com/scrapesage/behance-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Social media, Lead generation, Agents
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 project scrapeds

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?

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

## Behance Scraper — Projects, Creators & Designer Leads

Extract **the richest Behance dataset on Apify** — design **projects** with full stats, tools and tags; **creator profiles** that double as ready-to-use **designer leads** (availability-for-hire, budget, social links, location, website and contact email); and the **creative jobs** board. One actor covers what the rest of the category splits across "projects-only", "jobs-only" and "profiles-only" tools.

No login, no cookies, no browser — clean JSON straight from Behance's own server-rendered pages, on a [keyless](#faq) datacenter proxy.

### Why this Behance scraper?

Most Behance scrapers grab a name, a thumbnail and a view count. This actor reads each project **and** each creator's full record — including the **availability signal recruiters and agencies actually pay for**: who is open to freelance or full-time work, their minimum budget, whether they want remote, and how to reach them.

| Data | Typical scrapers | This actor |
|---|---|---|
| Project title, cover, views, appreciations | ✅ | ✅ |
| Project **tools used, tags, creative fields, description** | partial | ✅ (with details on) |
| Creator name, username, avatar, stats | partial | ✅ |
| Creator **occupation, company, location** | ❌ | ✅ |
| Creator **availability for hire** (freelance / full-time, remote, budget, timeline) | ❌ | ✅ |
| Creator **social links** (LinkedIn, Instagram, Dribbble, X…) | ❌ | ✅ when published |
| Creator **website + contact email** (enrichment) | ❌ | ✅ |
| Creator **work history & member-since** | ❌ | ✅ |
| Creative **jobs** with salary range, type, remote & hiring contact | ❌ | ✅ |
| **0-100 lead score** per creator | ❌ | ✅ |
| **Monitor mode** — only new content next run | ❌ | ✅ |
| Projects, creators **and** jobs in one actor | ❌ | ✅ |

### Use cases

- **Designer & creative lead generation** — find illustrators, UI/UX designers, brand designers, motion artists by field and location, filter to **available-for-hire only**, and export name, occupation, website, socials and email straight to your CRM.
- **Recruiting & talent sourcing** — target creators flagged open to full-time work, with their budget expectations, remote preference, hiring timeline and work history.
- **Agency & freelancer prospecting** — agencies pitching design services can find brands' in-house creatives; freelancers can scout competitors and rates.
- **Market & trend research** — track which tools (Figma, Blender, After Effects), styles and creative fields are trending, by appreciations and views over a timeframe.
- **Creative jobs intelligence** — monitor the Behance jobs board for new freelance and full-time roles, with salary ranges and remote flags.
- **Portfolio & inspiration feeds** — power galleries, newsletters and apps with structured project data.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Behance Scraper**, set a **search query** and/or **creative field**, choose your **content types** (Projects, Creators, Jobs), and add location/availability filters if you want targeted leads.
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchQueries": ["logo design"],
    "contentTypes": ["creators"],
    "creativeFields": ["branding"],
    "country": "DE",
    "availableForFreelance": true,
    "includeCreatorProfiles": true,
    "enrichContactEmails": true,
    "maxItems": 50
}
```

- **searchQueries** — free-text searches (e.g. `logo`, `mobile app`, `3d character`). Each returns the first page (up to 24); breadth comes from combining queries × fields × sorts × location.
- **contentTypes** *(default `["projects"]`)* — any of `projects`, `creators` (designer leads), `jobs`.
- **creativeFields** — limit to fields like `ui/ux`, `branding`, `illustration`, `motion graphics`, `web design`, `photography`.
- **tools** — filter projects by software (`Figma`, `Photoshop`, `Blender`…).
- **sort** / **timeframe** — `recommended` / `most_appreciated` / `most_viewed` / `most_recent`; projects can be limited to `today`/`week`/`month`.
- **country / state / city** — target creators and jobs by location (use a 2-letter country code, e.g. `US`, `GB`, `DE`).
- **availableForFreelance / availableForFullTime / availableForHireOnly** — narrow to in-market creators.
- **profileUrls / projectUrls / startUrls** — scrape specific profiles, projects, or paste any Behance search / joblist URL.
- **includeProjectDetails** *(default true)* — open each project for tools, tags, description and fields.
- **includeCreatorProfiles** *(default true)* — open each creator for occupation, website, work history and full availability.
- **enrichContactEmails** *(default false)* — crawl each creator's own website for an email and extra socials.
- **monitorMode** *(default false)* — emit only NEW projects/creators/jobs versus previous runs.

### Output

By default each row is tagged with a `type` (`project`, `creator`, or `job`) — switch between the **Projects**, **Creators** and **Jobs** dataset views, or filter on `type`.

A creator lead (`type: "creator"`):

```json
{
    "type": "creator",
    "source": "behance",
    "id": 2060362649,
    "username": "uxpolly",
    "displayName": "Polina Prykhodko",
    "occupation": "Product & Graphic Designer // Team Lead of UI/UX Design",
    "company": "Boosta",
    "location": { "full": "Lviv, Ukraine", "city": "Lviv", "country": "Ukraine", "countryCode": "UA" },
    "website": "https://polly.design",
    "socialLinks": [
        { "service": "LinkedIn", "url": "https://www.linkedin.com/in/...", "verified": true },
        { "service": "Instagram", "url": "https://instagram.com/...", "verified": true }
    ],
    "stats": { "views": 173636, "appreciations": 11913, "followers": 1501, "following": 2 },
    "availability": {
        "forHire": true, "availableForFreelance": true, "availableForFullTime": true,
        "lookingForRemote": true, "openToRelocation": false,
        "availabilityTimeline": "within_next_few_weeks", "hiringTimeline": "Now",
        "minBudgetUsd": 100, "currency": "USD"
    },
    "availableForHire": true,
    "workExperiences": [{ "position": "Product Designer", "organization": "Boosta", "location": "Ukraine" }],
    "memberSince": "2025-09-23T...",
    "creatorPro": true,
    "contact": { "emails": ["hello@polly.design"], "extraSocials": null, "crawledFrom": ["https://polly.design"] },
    "bestEmail": "hello@polly.design",
    "leadScore": 88,
    "scrapedAt": "2026-06-18T..."
}
```

A project (`type: "project"`) carries `title`, `url`, `coverUrl`, `publishedOn`, `stats` (views/appreciations/comments), `owners`, plus (with `includeProjectDetails`) `description`, `tags`, `tools`, `creativeFields` and `modulesCount`. A job (`type: "job"`) carries `title`, `company`, `location`, `isRemote`, `jobType`, `salary` (min/max/currency/timeframe) and `hiringContact`.

#### What to expect (field coverage)

Behance is user-entered data, so some fields are populated only when the creator filled them in. Typical coverage:

| Entity | Always present | Usually present | Present when published |
|---|---|---|---|
| **Project** | title, URL, cover, stats, owner | tools/tags/fields (with details on) ~90% | description |
| **Creator** | username, name, URL, stats | occupation ~85%, location ~80%, availability ~95% | website, socials, email (with enrichment) |
| **Job** | title, type, URL, remote flag | salary range ~85%, company ~80% | hiring contact |

A blank field means the creator/employer didn't publish it — not that scraping failed. Nothing is dropped, so you always get the richest dataset available.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly with **monitor mode** to capture newly published projects, new creators in a field/location, or fresh job posts.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/behance-scraper').call({
    searchQueries: ['logo design'],
    contentTypes: ['creators'],
    country: 'DE',
    availableForFreelance: true,
    enrichContactEmails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} creator leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new designer leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored field or location adds new creators or jobs.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find UI/UX designers in Berlin who are available for freelance, with their website and email" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **creator, talent & lead-gen stack**:

- **[GitHub Scraper](https://apify.com/scrapesage/github-scraper)** — repos, developers and contact leads.
- **[Hugging Face Scraper](https://apify.com/scrapesage/hugging-face-scraper)** — AI models, datasets, Spaces and creator leads.
- **[Product Hunt Scraper](https://apify.com/scrapesage/product-hunt-scraper)** — launches, makers and leads.
- **[Linktree Scraper](https://apify.com/scrapesage/linktree-scraper)** — creator bio links, emails and leads.
- **[YouTube Scraper](https://apify.com/scrapesage/youtube-scraper)** — channels, videos and creator leads.
- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — job postings as hiring-intent signals.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones and socials from any site.

### Tips

- **For leads, scrape `creators`** with a `creativeField` + `country`/`city` and turn on `availableForHireOnly` — you'll get a clean, contactable, in-market list.
- **Add `enrichContactEmails`** to turn a profile into an outreach-ready lead. Behance rarely shows emails directly, so the website crawl is how you get them (one fast request per creator's site).
- **Widen coverage** by passing several `searchQueries` and `creativeFields`, and try different `sort` orders — each surfaces a different 24 results.
- **Projects also yield leads**: with `includeCreatorProfiles` on, every project gets its owner resolved into a lead; set `emitProjectOwners` to output those as their own rows.
- **Recurring monitoring**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to watch a field, location, or the jobs board for new entries.

### FAQ

**Does it need the Behance/Adobe API or a key?** No. Behance's official API was retired; this actor reads the same (and richer) data straight from Behance's public, server-rendered pages — no key or login needed.

**How many results per search?** Behance serves up to 24 results per search page, and deeper pagination is login-gated. To get more, combine multiple search queries, creative fields, sorts and location filters — or pass specific profiles/projects directly.

**Where do availability and budget come from?** From each creator's own Behance "available for work" settings — whether they're open to freelance/full-time, want remote, their minimum budget and hiring timeline. Fields are blank when the creator hasn't set them.

**Where do emails come from?** Behance hides emails behind its messaging system, so the actor finds them by crawling the creator's own linked website (with `enrichContactEmails`). Many designers list a contact email there.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor a field or location for new creators/jobs?** Turn on `monitorMode` and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new records into your CRM as they appear.

**A field is empty — why?** Some creators don't publish a website, socials or availability; some projects have no description. Fields are blank only when the data wasn't published — never because the scraper skipped it.

**Is scraping Behance legal?** This actor collects publicly available data only. You're responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA for personal data) and Behance's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

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

Free-text searches run against Behance for each selected content type (e.g. "logo", "mobile app", "3d character"). Each query returns the first server-rendered page (up to 24 results). Combine with creative fields, sort and location for breadth.

## `contentTypes` (type: `array`):

What to scrape: design Projects, Creators (designer profiles = leads), and/or creative Jobs. Searches, fields and filters apply to each selected type.

## `creativeFields` (type: `array`):

Limit results to one or more Behance creative fields (e.g. UI/UX, Branding, Illustration, Motion Graphics, Web Design, Photography). Each field is combined with each search query.

## `tools` (type: `array`):

Filter projects by the software/tool used, e.g. Figma, Photoshop, Illustrator, Blender, After Effects.

## `sort` (type: `string`):

Sort order for searches. Different sorts surface different results, widening coverage.

## `timeframe` (type: `string`):

Restrict projects to a recency window.

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

Two-letter ISO country code to target creators/jobs by location, e.g. US, GB, DE, FR, IN, BR.

## `state` (type: `string`):

State or region to target creators by location (used with country).

## `city` (type: `string`):

City to target creators/jobs by location, e.g. Berlin, London, New York.

## `availableForFreelance` (type: `boolean`):

Only return creators who flag themselves as available for freelance work.

## `availableForFullTime` (type: `boolean`):

Only return creators who flag themselves as available for full-time work.

## `jobTypes` (type: `array`):

Filter jobs by type. Behance uses Freelance, Full-time and Contract.

## `remoteOnly` (type: `boolean`):

Only return jobs flagged as remote.

## `minFollowers` (type: `integer`):

Only keep creators with at least this many followers. 0 = no filter.

## `minAppreciations` (type: `integer`):

Only keep creators/projects with at least this many appreciations (likes). 0 = no filter.

## `minViews` (type: `integer`):

Only keep creators/projects with at least this many views. 0 = no filter.

## `availableForHireOnly` (type: `boolean`):

Drop creators who are not open to freelance or full-time work — keep only contactable, in-market leads.

## `withContactOnly` (type: `boolean`):

Only keep creator leads that have at least one of: website, social link, or enriched email.

## `profileUrls` (type: `array`):

Direct Behance profiles to pull as full creator leads, e.g. https://www.behance.net/uxpolly or just "uxpolly".

## `projectUrls` (type: `array`):

Direct Behance project (gallery) pages or numeric ids, e.g. https://www.behance.net/gallery/243538069/My-Project or 243538069.

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

Optional mixed list of behance.net URLs — profiles, gallery projects, or /search and /joblist result pages. Each is auto-classified.

## `includeProjectDetails` (type: `boolean`):

Open each project's gallery page for the rich record — description, tags, tools used, creative fields, module/image counts and full owner list. Turn OFF for a fast, cheap listing-only crawl.

## `includeCreatorProfiles` (type: `boolean`):

Open each creator's profile for the full lead — occupation, company, website, web links, work history and complete availability/budget. For projects, resolves the primary owner into a creator lead attached to the project. Turn OFF for speed.

## `enrichContactEmails` (type: `boolean`):

Crawl each creator's own website (home + /contact + /about) for a contact email and extra socials. Behance rarely exposes emails directly, so this is the way to get them.

## `emitProjectOwners` (type: `boolean`):

When scraping projects, also output a separate creator-lead record for each project's owner (deduplicated), not just the summary attached to the project.

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

Global cap on the total number of records (projects + creators + jobs) scraped across all searches and inputs.

## `maxItemsPerQuery` (type: `integer`):

Cap on records pulled from each individual search (Behance serves up to 24 per page).

## `deduplicateCreators` (type: `boolean`):

Emit each creator only once per run even if they appear across multiple searches or projects.

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

Remember project/creator/job ids returned in previous runs (in a named key-value store) and emit only NEW ones next time. Pair with an Apify Schedule to watch a field, a search, or a location for fresh portfolios, creators or jobs. The schedule decides WHEN to run; monitor mode decides WHAT is new.

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

Name of the key-value store that holds the monitor's memory. Use different names to track different watches independently. Lowercase letters, digits and hyphens only.

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

How many requests to run in parallel.

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

Proxy settings. Apify Proxy (default datacenter) is recommended and works well — a fresh session is rotated per attempt to shrug off the occasional 403. Switch to residential if you see persistent blocks.

## `urlsFromFile` (type: `string`):

Paste a list of URLs (one per line), OR one link to a .txt/.csv file, Google Sheet or Google Drive file containing them. Lets you import many Start URLs at once instead of typing each. Google Sheet/Drive share links are handled automatically.

## Actor input object example

```json
{
  "searchQueries": [
    "logo design",
    "mobile app"
  ],
  "contentTypes": [
    "projects"
  ],
  "creativeFields": [
    "ui/ux",
    "branding",
    "illustration"
  ],
  "tools": [
    "Figma"
  ],
  "sort": "recommended",
  "timeframe": "all",
  "availableForFreelance": false,
  "availableForFullTime": false,
  "remoteOnly": false,
  "minFollowers": 0,
  "minAppreciations": 0,
  "minViews": 0,
  "availableForHireOnly": false,
  "withContactOnly": false,
  "profileUrls": [
    "https://www.behance.net/uxpolly"
  ],
  "projectUrls": [
    "https://www.behance.net/gallery/243538069/x"
  ],
  "includeProjectDetails": true,
  "includeCreatorProfiles": true,
  "enrichContactEmails": false,
  "emitProjectOwners": false,
  "maxItems": 200,
  "maxItemsPerQuery": 24,
  "deduplicateCreators": true,
  "monitorMode": false,
  "monitorStoreName": "behance-monitor",
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

All scraped records in the default dataset.

# 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": [
        "logo design"
    ],
    "urlsFromFile": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/behance-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": ["logo design"],
    "urlsFromFile": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/behance-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": [
    "logo design"
  ],
  "urlsFromFile": ""
}' |
apify call scrapesage/behance-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapesage/behance-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/n3TVEiI4IPtI7RIPd/builds/l7GwYeswW7CqH9X0r/openapi.json