# Linkedin Leads Generator (`scrapers-hub/linkedin-leads-generator`) Actor

LinkedIn Leads Generator collects profile usernames, profile links and emails for every keyword you target. 🎯 A lightweight way to build outbound lists, source candidates and feed your sales pipeline with qualified B2B leads.

- **URL**: https://apify.com/scrapers-hub/linkedin-leads-generator.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Jobs, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

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?

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

## 💼 LinkedIn Leads Generator – B2B Prospect & Email Extraction by Keyword

The **LinkedIn Leads Generator** builds B2B prospect lists from LinkedIn profiles by keyword and country, returning the profile handle, the profile URL and any public email addresses it finds. You give it job titles or role keywords — `software engineer`, `marketing manager`, `head of procurement` — pick a target country, and it returns a dataset of matching LinkedIn leads ready for enrichment or outreach.

This LinkedIn leads generator is designed for sales development, recruitment sourcing and B2B market research: the situations where you need a list of people in a role and a region, and you need it without paying for a Sales Navigator seat or pasting a LinkedIn session cookie into a scraping tool. It works entirely from publicly indexed LinkedIn profile results, so no LinkedIn login, cookie or authentication token is required at any point.

***

### 📊 What Data Can You Extract with This LinkedIn Leads Generator?

The output is deliberately lean — four fields per lead, each one directly actionable:

| Category | Fields | What it tells you |
|---|---|---|
| 🔎 Search attribution | `keyword` | Which of your search keywords produced this lead, so multi-keyword runs stay traceable |
| 👤 Profile identity | `username` | The LinkedIn profile handle extracted from the profile URL, e.g. `john-doe-12345678` |
| 🔗 Profile link | `userLink` | The full LinkedIn profile URL, ready to open, enrich or import into a CRM |
| 📧 Contact | `emails` | An array of public email addresses discovered for that profile, empty when none were found |

The `keyword` field is more useful than it first appears. When you run several role keywords in one job, every returned lead carries the term that surfaced it, which means you can measure which search phrasing actually produces prospects with emails — and drop the keywords that do not. That single attribution column turns list building into something you can iterate on rather than guess at.

***

### 🌟 Key Features of the LinkedIn Leads Generator

| Feature | Description |
|---|---|
| 🔑 Multi-keyword search | The `keywords` array accepts several role or title terms in one run, and each result is tagged with the keyword that found it |
| 🌍 26 target countries | `country` offers a fixed list spanning the US, UK, Canada, Australia, India, the major European markets, Japan, South Korea, China, Singapore, the UAE, Brazil, Mexico, South Africa and New Zealand |
| 📧 Email-only mode | Set `scrapeLeadsWithEmail` to `true` and the run returns only profiles that have a discoverable public email address |
| 🔢 Per-keyword volume control | `maxLeadsPerKeyword` caps how many leads each keyword contributes, keeping multi-keyword runs balanced |
| 🧹 Profile URL validation | Company pages, job posts, articles, groups, school pages and LinkedIn subdomains are filtered out, so only genuine `/in/` profile URLs reach the dataset |
| 🕵️ Obfuscated email handling | Email extraction understands common obfuscations such as `name [at] domain [dot] com` and normalises them back to a usable address |
| 🔁 Deduplicated email arrays | Repeated addresses within a profile are collapsed case-insensitively, so `emails` contains each address once |
| 🔓 No LinkedIn login | Runs entirely against publicly indexed profile data — no cookie, session token or LinkedIn account involved |
| 🔄 Automatic proxy rotation | Requests are routed through rotating proxies managed automatically by the actor, with nothing for you to configure |

***

### 🚀 Why Choose This LinkedIn Leads Generator?

**Keyword-level attribution built in.** Every lead carries the `keyword` that produced it. That lets you compare hit rates across search phrasings and refine your terms empirically instead of running one giant undifferentiated search and hoping for the best.

**A genuine email filter, not a post-processing step.** With `scrapeLeadsWithEmail` enabled, profiles without a discoverable address are dropped before they reach your dataset. Your export is a contactable list from the start, rather than a long list you then have to clean.

**Strict profile URL filtering.** LinkedIn search results are full of company pages, job listings, Pulse articles and group pages. The actor validates that every URL is a real personal profile under `/in/` and discards everything else, so you are not paying attention to rows that were never leads.

**No cookies, no account risk.** Tools that require your LinkedIn session cookie break when the session expires and expose your own account. This LinkedIn leads generator works from public data only, so there is nothing to refresh and nothing tied to your identity.

***

### 📥 Input

The LinkedIn leads generator requires one field, `keywords`, and offers three optional controls.

```json
{
  "keywords": [
    "software engineer",
    "marketing manager"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": false
}
```

#### 🔧 LinkedIn Leads Generator Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array of strings | ✅ Yes | — | List of keywords to search for LinkedIn profiles (e.g. `software engineer`, `marketing manager`) |
| `country` | string (enum) | ❌ No | `"United States"` | Target country for leads. One of: United States, United Kingdom, Canada, Australia, India, Germany, France, Spain, Italy, Brazil, Mexico, Japan, South Korea, China, Singapore, United Arab Emirates, Netherlands, Sweden, Norway, Denmark, Switzerland, Belgium, Austria, Ireland, New Zealand, South Africa |
| `maxLeadsPerKeyword` | integer | ❌ No | `20` | Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run |
| `scrapeLeadsWithEmail` | boolean | ❌ No | `false` | If enabled, only returns profiles that have a public email address |

#### 💡 Input Examples

**Email-only sales prospecting** — return nothing but contactable leads:

```json
{
  "keywords": ["head of marketing", "vp marketing"],
  "country": "United Kingdom",
  "maxLeadsPerKeyword": 50,
  "scrapeLeadsWithEmail": true
}
```

**Recruitment sourcing sweep** — broad list of engineering profiles, emails optional:

```json
{
  "keywords": ["python developer", "backend engineer", "devops engineer"],
  "country": "India",
  "maxLeadsPerKeyword": 100,
  "scrapeLeadsWithEmail": false
}
```

**Minimal run using defaults** — one keyword, US, 20 leads:

```json
{
  "keywords": ["procurement manager"]
}
```

***

### 📤 Output

Each dataset item is one LinkedIn lead. The record shape follows the four output fields:

```json
{
  "keyword": "marketing manager",
  "username": "jane-smith-4a71b230",
  "userLink": "https://www.linkedin.com/in/jane-smith-4a71b230",
  "emails": ["jane.smith@example.com"]
}
```

When a profile has no discoverable email and `scrapeLeadsWithEmail` is left at its default of `false`, the record still appears with an empty array:

```json
{
  "keyword": "software engineer",
  "username": "alex-moreau",
  "userLink": "https://www.linkedin.com/in/alex-moreau",
  "emails": []
}
```

#### 🧾 LinkedIn Leads Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword that produced this lead |
| `username` | string | null | LinkedIn profile handle, parsed from the profile URL |
| `userLink` | string | null | Full LinkedIn profile URL |
| `emails` | array | null | Email addresses found for the profile; empty when none were discovered |

Note that `emails` is an array rather than a single string. Some profiles publish more than one address — a work address and a personal one, for example — and both are preserved. When you export to CSV, decide deliberately whether to take the first element or expand each address into its own row.

***

### 💻 How to Use the LinkedIn Leads Generator (Step by Step)

#### Step 1: Choose Keywords That Match Real Job Titles

The keyword is the whole search, so precision here decides the quality of everything downstream. Use the exact phrasing people actually put in their LinkedIn headline: `head of demand generation` rather than `marketing person`, `SRE` alongside `site reliability engineer` because both appear in the wild. Adding two or three variants of the same role in a single `keywords` array usually produces better coverage than one broad term, because job titles are not standardised across companies.

#### Step 2: Select the Target Country

Set `country` to the market you are selling or recruiting into. The field is a fixed list of 26 countries and defaults to the United States. Geographic targeting matters more than most people expect — the same job title in different markets surfaces entirely different profile populations, and running one country at a time keeps your list segmented in the way your outreach will need anyway.

#### Step 3: Decide Whether You Need Emails Only

If your next step is an email sequence, set `scrapeLeadsWithEmail` to `true`. The run will then return only profiles with a discoverable public address, so your export is immediately usable. If your next step is manual review, LinkedIn outreach or enrichment through another tool, leave it at `false` and take the wider list — you will get many more leads, with `emails` empty for most.

#### Step 4: Set a Realistic `maxLeadsPerKeyword`

This value applies per keyword, not per run, so three keywords at 50 each can produce up to 150 leads. Start low — the default of 20 is a good first pass — and inspect the results before scaling. Note that free users are capped at 100 emails total per run regardless of what you set here.

#### Step 5: Run and Watch the Log

Press **Start**. The actor works through each keyword in turn, collecting profile results, validating that each URL is a genuine `/in/` profile, and extracting emails from the surrounding text. The log reports progress per keyword and per page, including how many valid profiles were found and how many were filtered out for lacking an email.

#### Step 6: Review, Deduplicate and Verify

Open the dataset and check it before importing anywhere. Deduplicate on `userLink`, since the same person can surface under two different keywords. Then verify the addresses in `emails` with a validation service — publicly discovered emails include a proportion of stale and role-based addresses, and sending to unverified lists damages your sender reputation.

#### Step 7: Export into Your CRM or Sequencing Tool

Export as CSV or Excel, or pull the dataset through the Apify API into your CRM. Keep the `keyword` column through the import: knowing which search term produced each contact lets you segment sequences by role and, over time, work out which keywords actually convert.

***

### 🔌 API Access & Integrations

Run the LinkedIn leads generator programmatically. The synchronous endpoint starts a run and returns dataset items in a single call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~linkedin-leads-generator/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["marketing manager", "head of growth"],
    "country": "United Kingdom",
    "maxLeadsPerKeyword": 50,
    "scrapeLeadsWithEmail": true
  }'
```

With the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "keywords": ["software engineer", "backend engineer"],
    "country": "Germany",
    "maxLeadsPerKeyword": 40,
    "scrapeLeadsWithEmail": True,
}

run = client.actor("scrapers-hub/linkedin-leads-generator").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["keyword"], item["username"], item["userLink"], item["emails"])
```

The actor connects to Zapier, Make, Google Sheets, Slack and generic webhooks through Apify's standard integrations, so finished LinkedIn lead runs can flow straight into your CRM or a shared sheet.

***

### 💡 Best Use Cases for LinkedIn Leads Data

#### 📨 Outbound Sales Prospecting

Run your ideal-customer job titles with `scrapeLeadsWithEmail` set to `true` and `country` set to your target market. The resulting `emails` and `userLink` pairs give your SDRs both an email channel and a LinkedIn profile to reference, which is exactly what a multi-touch sequence needs.

#### 🎯 Recruitment and Talent Sourcing

Search technical or specialist role keywords to build candidate pipelines. Because `username` and `userLink` identify each profile precisely, recruiters can review the profile before reaching out, and `keyword` records which skill search surfaced the candidate.

#### 🧪 ICP and Market Research

Before committing to a market, run your target titles across several `country` values and compare volumes. The number of leads returned per keyword per country is a rough but genuinely useful proxy for how many people hold that role in that market.

#### 🔗 CRM Enrichment

If your CRM has company records but no named contacts, run role keywords and match the results back by domain from the `emails` field. This fills in decision-maker contacts against accounts you already track, without buying a full enrichment subscription.

#### 📊 Keyword Performance Testing

Run several phrasings of the same role — `VP of sales`, `vice president sales`, `sales director` — in one job and group the results by `keyword`. Comparing lead counts and email hit rates per keyword tells you which phrasing to standardise on for future runs.

#### 🌍 Multi-Market Expansion Planning

Run the identical `keywords` array against different `country` selections and compare. Where a role is well represented, the market is likely mature for your category; where it barely exists, you are either early or targeting the wrong buyer persona for that region.

#### 🤝 Partnership and Channel Discovery

Search for partner-shaped roles such as `channel manager` or `alliances director`. The `userLink` values give you a direct route to the people who own partnership decisions, and the `emails` field, where populated, gives you a way to open the conversation off-platform.

***

### ⚙️ Tips for Better LinkedIn Lead Generation Results

- **Run several title variants per role.** Job titles are not standardised. Include two or three phrasings of the same role in `keywords` and let the `keyword` field tell you which one performed.
- **Start with a small `maxLeadsPerKeyword`.** Twenty leads per keyword is enough to judge whether your terms are on target. Scale only after the sample looks right.
- **Choose the email filter deliberately.** `scrapeLeadsWithEmail: true` gives a small, contactable list; `false` gives a much larger list for LinkedIn-first outreach. Match the setting to what you will actually do next.
- **Always verify emails before sending.** Publicly discovered addresses include stale and role-based accounts. Run them through a validation service first — bounce rates directly damage domain reputation.
- **Deduplicate on `userLink`, not `username`.** The URL is the unambiguous identifier, and the same person can appear under multiple keywords in a single run.
- **Keep one country per run.** Mixing markets in one dataset makes segmentation harder later, and outreach almost always needs to be localised anyway.

***

### 🛠️ Troubleshooting

**The run returned far fewer leads than `maxLeadsPerKeyword`.**
That value is a ceiling, not a guarantee. Niche titles in smaller markets simply have fewer publicly indexed profiles, and enabling `scrapeLeadsWithEmail` reduces the count further because most profiles do not publish an address. Broaden the keyword or turn the email filter off.

**Every `emails` array is empty.**
This is expected when `scrapeLeadsWithEmail` is `false`. Only a minority of professionals publish an email in publicly visible profile text. Enable the email filter if you need a contactable list, and accept that it will be substantially shorter.

**I am getting fewer results than expected on a free account.**
Free users are capped at 100 emails total per run, as stated in the `maxLeadsPerKeyword` description. Setting a higher per-keyword value does not lift that overall cap.

**The results include people in the wrong country.**
Geographic targeting operates on the search layer and is directional rather than absolute. Profiles are not always geotagged consistently, so expect some spillover, and filter afterwards if strict geography matters.

**Some returned emails look malformed.**
Extraction handles obfuscated formats such as `name [at] domain [dot] com`, and that normalisation occasionally produces an odd-looking result from unusual source text. Validate the list before use — this is good practice regardless of source.

***

### ❓ Frequently Asked Questions About LinkedIn Lead Generation

**What does the LinkedIn Leads Generator do?**
It searches for publicly indexed LinkedIn profiles matching your role keywords in a chosen country and returns the profile handle, profile URL, any public email addresses found, and the keyword that produced each lead.

**Do I need a LinkedIn account or session cookie?**
No. The LinkedIn leads generator works entirely from publicly indexed profile data. There is no login, no cookie and no token to supply, so your own LinkedIn account is never involved.

**Can I search multiple job titles in one run?**
Yes. `keywords` is an array. Every returned lead is tagged with the `keyword` that surfaced it, so multi-keyword runs stay fully traceable.

**Which countries can I target?**
Twenty-six: the United States, United Kingdom, Canada, Australia, India, Germany, France, Spain, Italy, Brazil, Mexico, Japan, South Korea, China, Singapore, United Arab Emirates, Netherlands, Sweden, Norway, Denmark, Switzerland, Belgium, Austria, Ireland, New Zealand and South Africa.

**How does `maxLeadsPerKeyword` work?**
It caps the leads collected for each individual keyword, so a run with three keywords at 50 each can return up to 150 leads in total.

**Will I get an email address for every lead?**
No. Only a minority of LinkedIn profiles have a publicly discoverable email. Set `scrapeLeadsWithEmail` to `true` to return only those that do, at the cost of a much smaller list.

**Does it return names, job titles or company names?**
The output fields are `keyword`, `username`, `userLink` and `emails`. `username` is the profile handle from the URL, which often contains the person's name; full name, title and employer are not separate output fields.

**Are the extracted emails verified?**
No. They are extracted from publicly visible text, not validated against mail servers. Run them through an email verification service before any sending campaign.

**Can it find phone numbers?**
No. Phone numbers are not among the output fields.

**Do I need to configure a proxy?**
No. Proxy rotation is handled automatically by the actor and is not user-configurable.

**How do I avoid duplicate leads across keywords?**
Deduplicate on `userLink` after the run. The same person can legitimately match more than one of your keywords.

**Why is `emails` an array rather than a single field?**
Some profiles publish more than one address. Keeping it as an array preserves all of them; flatten it in your own export step if your CRM expects a single value.

**Can I integrate this LinkedIn leads generator with my CRM?**
Yes. Read the dataset through the Apify API, or use the built-in Zapier, Make, Google Sheets, Slack or webhook integrations to push results into your stack.

**Is scraping LinkedIn profile data legal?**
The actor accesses only publicly indexed information. Your obligations begin with how you use it — particularly under GDPR, UK GDPR and CCPA, and under anti-spam rules governing cold outreach. Read the disclaimer below carefully.

**Is this a replacement for Sales Navigator?**
No. It is a keyword-driven list-building tool that produces profile URLs and public emails. It does not provide LinkedIn's filtering depth, InMail, or account-based search features.

***

### 🆘 Support & Feedback

If a run behaves unexpectedly — no results for a keyword you know has profiles, or emails you believe are being missed — open a ticket on the **Issues** tab of this actor. Include the exact input JSON and the run ID so the behaviour can be reproduced.

Need a custom build — extra fields, a different country list, deeper enrichment, or lead generation from another source? Email **scraperhubapi@gmail.com** and describe what you are trying to achieve.

If the LinkedIn Leads Generator earns its place in your prospecting stack, please leave a review on the actor page. Ratings help other sales and recruitment teams find the tool and shape what gets improved next.

***

### ⚖️ Disclaimer

The LinkedIn Leads Generator collects only publicly available and publicly indexed information. It does not use your LinkedIn account, does not require cookies or session tokens, does not access private profiles, connection-only content, or anything behind LinkedIn authentication.

The data this LinkedIn leads generator produces is personal data. Profile handles, profile URLs and email addresses identify individuals, which brings your use of this dataset within the scope of GDPR, UK GDPR, CCPA and equivalent privacy legislation. You must establish and document a lawful basis for processing — legitimate interest for B2B outreach is common, but it must be assessed, not assumed — provide the required privacy notice at first contact, honour access, rectification and erasure requests, and maintain a suppression list.

Cold email and cold outreach are separately regulated. Depending on your jurisdiction and your recipients', rules including PECR, the ePrivacy Directive, CAN-SPAM and CASL may apply. Requirements typically include accurate sender identification, a working unsubscribe mechanism, and in some markets prior consent. You are responsible for compliance.

Use of the collected data must also comply with LinkedIn's terms of service and platform policies. Profile information is published by third parties and may be out of date or inaccurate; verify anything material before acting on it.

If you believe data collected by this actor relates to you and should be removed, contact **scraperhubapi@gmail.com** with the details and the request will be actioned.

# Actor input Schema

## `keywords` (type: `array`):

List of keywords to search for LinkedIn profiles (e.g., 'software engineer', 'marketing manager').

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

Select the target country for leads.

## `maxLeadsPerKeyword` (type: `integer`):

Maximum number of leads to collect for each keyword. Free users are capped at 100 emails total per run.

## `scrapeLeadsWithEmail` (type: `boolean`):

If enabled, only returns profiles that have a public email address.

## Actor input object example

```json
{
  "keywords": [
    "software engineer",
    "marketing manager"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20,
  "scrapeLeadsWithEmail": false
}
```

# Actor output Schema

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

Records scraped by Linkedin Leads Generator, stored in the run's 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 = {
    "keywords": [
        "software engineer",
        "marketing manager"
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/linkedin-leads-generator").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 = {
    "keywords": [
        "software engineer",
        "marketing manager",
    ],
    "country": "United States",
    "maxLeadsPerKeyword": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/linkedin-leads-generator").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 '{
  "keywords": [
    "software engineer",
    "marketing manager"
  ],
  "country": "United States",
  "maxLeadsPerKeyword": 20
}' |
apify call scrapers-hub/linkedin-leads-generator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/linkedin-leads-generator"
        }
    }
}

```

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/AuUqDaO9CTrnELxDM/builds/T8kFLTs9UxE86WZSU/openapi.json