# Kakaotalk Email Scraper Fast Advanced And Cheapest (`scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest`) Actor

KakaoTalk Email Scraper extracts public contact emails by keyword, location or custom domain across the Kakao ecosystem. 💬 A fast, affordable route to Korean-market lead generation, partner outreach and B2B prospecting.

- **URL**: https://apify.com/scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **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

### 💬 KakaoTalk Email Scraper – Fast, Advanced & Cheapest Lead Extraction by Keyword

The **KakaoTalk email scraper** finds publicly indexed KakaoTalk-related pages by keyword and extracts the email addresses published on them, returning one clean record per address with the keyword, page title, description and source URL attached. You supply a list of search terms, optionally a location and a set of email domains to target, and the Actor returns a structured contact dataset you can filter, export and import straight into an outreach tool.

Manual prospecting on KakaoTalk is slow work. Searching, opening results one by one, copying an address out of a bio or a page footer and pasting it into a spreadsheet takes hours to produce a few dozen contacts. This KakaoTalk email scraper automates the whole loop: it runs your keyword queries, walks the result pages, applies email pattern matching against the domains you specified, de-duplicates what it finds, and stops the moment your `maxEmails` budget is reached so you never pay for volume you did not ask for.

The domain filter is what makes the output usable rather than merely large. By restricting matches to domains such as `@gmail.com` or `@naver.com`, you get addresses that fit the audience you are actually targeting instead of a mixed bag of tracking, image and placeholder addresses scraped indiscriminately from page markup.

***

### 📊 What Data Can You Extract with This KakaoTalk Email Scraper?

Every dataset item represents one email address discovered against one of your keywords, with enough context to judge whether the contact is relevant before you ever write to them.

| Category | Fields | What you get |
|---|---|---|
| 📧 Contact data | `email` | The email address extracted from the page, matched against your configured domain list |
| 🔑 Search attribution | `keyword` | The exact keyword or query that produced this result, so you can measure which terms perform |
| 🌐 Source identification | `network`, `url` | The network the result belongs to and the canonical URL of the page the address was found on |
| 📝 Page context | `title` | The title of the source page, which usually carries the person's or business's name and role |
| 🧾 Descriptive context | `description` | Long-form description text from the result, typically a bio snippet or page summary |

The most operationally useful field here is `keyword`. Because each record records the term that surfaced it, you can measure yield per query — which search terms produce contacts, which produce noise, and which produce nothing at all — and refine your keyword list on evidence rather than instinct. Pair it with `description` and you have enough context to personalise an opening line without opening the source page.

***

### 🌟 Key Features of the KakaoTalk Email Scraper

| Feature | Description |
|---|---|
| 🔑 Multi-keyword search | Pass an array of keywords or queries and the scraper works through all of them in a single run |
| 📮 Custom domain targeting | Restrict extraction to the email domains you care about, such as `@gmail.com`, `@yahoo.com` or `@naver.com` |
| 📍 Optional location filter | Narrow search results geographically by supplying a location string alongside your keywords |
| 🎯 Hard result cap | `maxEmails` stops the run at a precise number of addresses, giving you predictable cost control |
| 🧹 Automatic de-duplication | Repeated addresses across pages and keywords are collapsed so the dataset stays clean |
| 🕸️ Automatic proxy rotation | Requests are routed through rotating proxy infrastructure automatically to reduce blocking on longer runs |
| 🧭 Full source attribution | Every address ships with its `url`, `title` and `keyword`, so results are auditable and traceable |
| ⚡ Lightweight HTTP fetching | No browser is launched, which keeps runs quick and inexpensive compared with rendering-based scrapers |
| 📤 Standard dataset export | Results export as JSON, JSONL, CSV, Excel or XML, or stream out through the Apify dataset API |

***

### 🚀 Why Choose This KakaoTalk Email Scraper?

**Domain targeting beats blanket extraction.** Generic email scrapers pull every string that looks like an address, including tracking pixels, image filenames and support aliases you will never use. Constraining matches through `customDomains` means the dataset arrives already aligned with the segment you intend to contact.

**Predictable cost through a hard cap.** `maxEmails` is a stopping condition, not a suggestion. Set it to 20 for a test, 500 for a campaign, and the run ends exactly there. That makes budgeting straightforward and stops an unexpectedly rich keyword from producing a run far larger than you planned.

**Every record is traceable.** An address with no provenance is a liability. Because `url`, `title` and `keyword` accompany each result, you can always check where an address came from, verify it is genuinely relevant, and remove it cleanly if someone asks you to.

**Fast by design.** The scraper uses plain HTTP fetching rather than a headless browser. Fewer moving parts means faster runs and lower compute cost, which matters when you are working through dozens of keyword variations.

***

### 📥 Input

The KakaoTalk email scraper is configured with four fields. Only the keyword list is required.

```json
{
  "keywords": ["manager", "founder"],
  "location": "",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 20
}
```

#### 🔧 KakaoTalk Email Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array | ✅ Yes | `["manager", "founder"]` | A list of keywords or queries to search for. |
| `location` | string | No | `""` | Location used to filter search results. Leave empty to search without a geographic filter. |
| `customDomains` | array | No | `["@gmail.com", "@yahoo.com"]` | List of custom email domains to match against when extracting addresses. |
| `maxEmails` | integer | No | `20` | Maximum number of emails to collect, between 1 and 10000. The scraper stops once this limit is reached. A higher limit allows more potential results but does not guarantee reaching that number. |

#### 💡 Input Examples

**Quick test run**

```json
{
  "keywords": ["photographer"],
  "maxEmails": 20
}
```

**Location-targeted B2B search**

```json
{
  "keywords": ["marketing manager", "brand director", "founder"],
  "location": "Seoul",
  "customDomains": ["@gmail.com", "@naver.com"],
  "maxEmails": 300
}
```

**Broad multi-keyword campaign**

```json
{
  "keywords": ["fitness coach", "personal trainer", "yoga instructor", "pilates studio"],
  "customDomains": ["@gmail.com", "@yahoo.com", "@hanmail.net"],
  "maxEmails": 1000
}
```

***

### 📤 Output

Each dataset item is one extracted email address with its surrounding context. The example below uses the real output field names with representative values.

```json
{
  "network": "kakaotalk",
  "keyword": "marketing manager",
  "title": "Jiwon Park — Marketing Manager | KakaoTalk Channel",
  "description": "Marketing manager working with lifestyle brands in Seoul. Collaborations and enquiries welcome — get in touch by email.",
  "url": "https://pf.kakao.com/_examplechannel",
  "email": "jiwon.park.mkt@gmail.com"
}
```

#### 🧾 KakaoTalk Email Scraper Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | null | Network the item belongs to. |
| `keyword` | string | null | Keyword that produced this item. |
| `title` | string | null | Title of the source page or result. |
| `description` | string | null | Long-form description text associated with the result. |
| `url` | string | null | Canonical URL of the scraped item. |
| `email` | string | null | Email address found for the item. |

***

### 💻 How to Use the KakaoTalk Email Scraper (Step by Step)

#### Step 1: Build a Keyword List That Matches Your Audience

`keywords` is the engine of the whole run, so it deserves real thought. Job titles such as "founder", "marketing manager" or "creative director" work well for B2B prospecting. Niche descriptors such as "yoga instructor", "wedding photographer" or "café owner" work better for local and creator outreach. Include natural variations and, where relevant, Korean-language equivalents, since the pages you are searching are frequently written in Korean and an English-only keyword set will miss a large part of the available results.

#### Step 2: Decide Whether to Apply a Location Filter

`location` defaults to an empty string, which searches without a geographic constraint. Supplying a value such as "Seoul" or "Busan" narrows results to that area, which is what you want for local services, events or region-specific campaigns. Leave it blank when you are prospecting a category rather than a place — a wider net produces more contacts, and you can always filter on `description` afterwards.

#### Step 3: Choose the Email Domains You Want

`customDomains` controls what counts as a match. The defaults, `@gmail.com` and `@yahoo.com`, are a reasonable starting point for consumer-facing outreach. For Korean audiences, adding domains such as `@naver.com`, `@daum.net` or `@hanmail.net` will typically increase yield substantially. If you are specifically after business contacts, you can list corporate domains instead, though this narrows results sharply. Keep the list focused: every extra domain widens the match surface and dilutes relevance.

#### Step 4: Set a Realistic Email Budget

`maxEmails` accepts anything from 1 to 10000 and defaults to 20. Treat it as your spend control. A first run of 20 to 50 confirms that your keywords and domains are producing relevant contacts. Only once you have seen the output quality is it sensible to scale to several hundred or several thousand. A high limit does not guarantee that many results exist — it simply allows the run to continue until they are exhausted.

#### Step 5: Launch the KakaoTalk Email Scraper

Start the run from the Apify Console or through the API. The log shows which keyword is being processed and how many addresses have been collected so far. Because the scraper stops at `maxEmails`, a run that ends early with fewer results than requested is telling you something useful: your keyword set is too narrow, your domain list is too restrictive, or the location filter is excluding too much.

#### Step 6: Review Results Before You Send Anything

Open the dataset and read a sample of records properly. Check that `title` and `description` describe the kind of person or business you meant to target, and that `email` looks like a real personal or business address rather than a support alias. Group the dataset by `keyword` to see which queries are pulling their weight — this is usually the single fastest way to improve the next run.

#### Step 7: Export and Load into Your Outreach Stack

Export as CSV or Excel for spreadsheet work, or pull JSON through the dataset API for a direct integration. Map `email` to the contact address, `title` to the contact or company name, and keep `url` and `keyword` as reference columns. Retaining the source URL matters for compliance: if someone asks where you got their address, you can answer precisely.

***

### 🔌 API Access & Integrations

Run the KakaoTalk email scraper and collect results in a single call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~kakaotalk-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["marketing manager", "founder"],
    "location": "Seoul",
    "customDomains": ["@gmail.com", "@naver.com"],
    "maxEmails": 200
  }'
```

The equivalent Python call using the official client, with a per-keyword yield summary:

```python
from collections import Counter
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "keywords": ["fitness coach", "personal trainer", "yoga instructor"],
    "location": "",
    "customDomains": ["@gmail.com", "@yahoo.com"],
    "maxEmails": 500,
}

run = client.actor(
    "scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest"
).call(run_input=run_input)

yield_by_keyword = Counter()
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    yield_by_keyword[item.get("keyword")] += 1
    print(item.get("email"), "|", item.get("title"), "|", item.get("url"))

print(yield_by_keyword.most_common())
```

The Actor also plugs into Zapier, Make, Google Sheets, Slack and any custom HTTP endpoint via Apify webhooks, so a completed run can append rows to a sheet, create records in a CRM or notify your team automatically.

***

### 💡 Best Use Cases for KakaoTalk Email Data

#### 🎯 Targeted B2B Lead Generation

Search job-title keywords such as "founder", "sales director" or "operations manager" and let `customDomains` shape the address mix. Each result carries a `title` and `description` you can read before contacting, which means your first message can reference something real rather than opening with a generic pitch.

#### 🤝 Influencer and Creator Outreach

Creators frequently publish a contact address for collaboration enquiries. Keyword searches around niches — "beauty creator", "food blogger", "travel vlogger" — surface those addresses, and the `description` field usually reveals the creator's focus so you can match brands to audiences before reaching out.

#### 🏙️ Local Market Prospecting

Setting `location` to a city and pairing it with service keywords builds a geographically bounded contact list. This is the practical route for agencies, franchises and local service businesses that only sell within a defined catchment area.

#### 📊 Keyword and Niche Research

Because `keyword` is stored on every record, a single run doubles as a research exercise. Comparing how many contacts each term produced tells you which niches have an active, contactable presence and which are effectively empty, which is valuable input before committing to a market.

#### 📇 Contact Database Enrichment

If you already hold company or creator names, running matching keywords through the scraper can surface public email addresses to attach to those records. The `url` field gives each addition a verifiable source, which keeps an enriched database auditable.

#### 🧪 Campaign Segmentation and A/B Testing

Split the dataset by `keyword` and treat each group as a distinct segment with its own messaging. Because the attribution is preserved end to end, you can measure reply rates per keyword and reinvest in whichever terms produce engaged prospects.

#### 🌏 Regional Audience Discovery

Combining Korean-language keywords with locally popular email domains reveals audiences that English-only searches consistently miss. This is particularly effective for brands entering the Korean market who need a first list of contactable local partners, resellers or creators.

***

### ⚙️ Tips for Better KakaoTalk Email Scraping Results

- **Use several specific keywords rather than one broad one.** Five targeted terms almost always outperform a single generic term, and the per-keyword attribution shows you exactly which are worth keeping.
- **Add Korean-language keyword variants.** Many relevant pages are written in Korean, and an English-only keyword list systematically under-samples the available audience.
- **Extend `customDomains` for Korean audiences.** Adding `@naver.com`, `@daum.net` and `@hanmail.net` alongside the defaults typically lifts yield noticeably.
- **Start with a small `maxEmails` value.** A 20-result trial costs very little and tells you within one run whether your keywords and domains are producing the right kind of contact.
- **Leave `location` empty when prospecting by category.** Geographic filtering is powerful but restrictive; apply it only when the campaign genuinely depends on place.
- **Keep `url` in your exported file.** Retaining provenance makes it straightforward to verify a contact and to honour removal requests without guesswork.

***

### 🛠️ Troubleshooting

**Why did the run return fewer emails than my `maxEmails` value?**
`maxEmails` is a ceiling, not a target. If publicly indexed pages matching your keywords do not contain that many addresses in your chosen domains, the run finishes early. Widen the keyword list, add more entries to `customDomains`, or clear the `location` filter.

**Why am I getting no results at all?**
The most common causes are an overly narrow keyword combined with a restrictive location, or a `customDomains` list that excludes the domains people in that niche actually use. Try one broad keyword with the default domains and no location to establish a baseline, then tighten from there.

**Some results do not look relevant to my keyword. Why?**
Search matching operates on page text, so a page can rank for a term that appears incidentally rather than as its subject. Use `title` and `description` to filter the dataset after collection, and make your keywords more specific — "wedding photographer" rather than "photographer".

**Can I get duplicate email addresses?**
Addresses are de-duplicated during collection, so the same address should not appear twice. If you merge several runs, de-duplicate on `email` afterwards, since separate runs have no knowledge of each other's results.

**The run seems slow for a large `maxEmails` value.**
Higher limits mean more search pages and more result pages to fetch, so runtime grows with the target. Splitting one large run into several smaller keyword-grouped runs gives you usable results sooner and makes it easier to see which keywords are productive.

***

### ❓ Frequently Asked Questions About KakaoTalk Email Scraping

**What does the KakaoTalk email scraper do?**
It searches for publicly indexed KakaoTalk-related pages using the keywords you supply, extracts email addresses matching your chosen domains, and returns each address with its keyword, page title, description and source URL.

**Do I need a KakaoTalk account to use it?**
No. The scraper works with publicly accessible, indexed pages and does not require login credentials of any kind.

**How do I search for emails by keyword?**
Put your search terms into the `keywords` array. Each term is processed in turn and the originating term is recorded in the `keyword` field of every result.

**Can I restrict results to specific email domains?**
Yes. `customDomains` controls which domains are matched. The default is `@gmail.com` and `@yahoo.com`, and you can replace or extend that list freely.

**How many emails can I collect in one run?**
`maxEmails` accepts values from 1 to 10000. The default is 20, and the run stops as soon as the limit is reached or the available results are exhausted.

**Does a higher `maxEmails` guarantee more results?**
No. It raises the ceiling but cannot create contacts that do not exist. Yield depends on how many relevant pages publish addresses in your chosen domains.

**Can I filter results by location?**
Yes. Set `location` to a place name to narrow the search geographically. Leaving it as an empty string disables geographic filtering.

**Does the scraper use proxies?**
Yes. Requests are routed through rotating proxy infrastructure automatically, so no proxy setup is required on your side.

**What is the `network` field for?**
It records the network that the result belongs to, which is useful when the dataset is merged with output from other contact-discovery sources.

**How do I know which keyword produced a given contact?**
Every record carries the originating term in its `keyword` field, so grouping the dataset by keyword gives you an immediate view of which searches are productive.

**Can I export the results to CSV or Excel?**
Yes. Apify datasets export as JSON, JSONL, CSV, Excel, XML and RSS from the Console, or through the dataset API.

**Are the extracted email addresses verified?**
No. This Actor extracts addresses as published on the source pages. If you need deliverability checks such as MX or SMTP verification, run the exported list through a dedicated verification step before sending.

**Can I schedule the KakaoTalk email scraper to run automatically?**
Yes. Apify Schedules run the Actor on a cron expression, which suits recurring lead-generation workflows where you want a steady flow of new contacts.

**How do I use the results for outreach responsibly?**
Keep `url` alongside each address so you can prove provenance, honour opt-out requests immediately, and follow the anti-spam rules that apply in your jurisdiction and the recipient's.

**Is it legal to scrape email addresses this way?**
The Actor collects information that is already publicly published. Your obligations concern how you store and use it — see the disclaimer below for the privacy and marketing rules that apply.

***

### 🆘 Support & Feedback

Run into a problem with the KakaoTalk email scraper? Open a report on the **Issues** tab of the Actor page and include your input configuration and the run ID so the behaviour can be reproduced.

Need a custom build? For different search sources, additional enrichment such as email verification, or direct integration with your CRM or outreach platform, write to **scraperhubapi@gmail.com** with an outline of what you need.

If the Actor saved you hours of manual prospecting, please leave a review on the Apify Store. Reviews help other users find the tool and directly influence what gets improved.

***

### ⚖️ Disclaimer

This KakaoTalk email scraper collects only publicly available information — pages that are openly indexed and email addresses that have been deliberately published on them. It does not access private conversations, log into accounts, or bypass any access control.

You are responsible for how you use the data. Email addresses are personal data under the GDPR, Korea's PIPA, the CCPA and similar frameworks. Before contacting anyone, establish a lawful basis for processing, provide the disclosures your jurisdiction requires, honour unsubscribe and erasure requests without delay, and retain the data only as long as you genuinely need it. Keeping the `url` field with each record is a practical way to evidence where an address came from.

Marketing to scraped addresses is regulated by anti-spam legislation including CAN-SPAM, CASL and the ePrivacy rules, and compliance rests entirely with you. Respect the terms of service of every platform and website involved, along with any applicable rate limits.

If you would like your data removed from a dataset produced by this Actor, contact **scraperhubapi@gmail.com** and the request will be handled promptly.

# Actor input Schema

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

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# Actor output Schema

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

Records scraped by Kakaotalk Email Scraper Fast Advanced And Cheapest, 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest").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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/kakaotalk-email-scraper-fast-advanced-and-cheapest"
        }
    }
}

```

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/ZZlC6pldhN7ribt4Z/builds/EdigUKOGYmZYftaqT/openapi.json