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

GitHub Email Scraper extracts developer emails from GitHub profiles and repositories by keyword, location or custom domain. 👨‍💻 Fast, budget-friendly sourcing for technical recruiting, developer outreach and B2B lead generation.

- **URL**: https://apify.com/scrapers-hub/github-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

## GitHub Email Scraper

### 📧 GitHub Email Scraper – Developer Contact & Lead Data Extraction by Keyword

The **GitHub Email Scraper** finds publicly indexed email addresses associated with GitHub profiles and repositories, returning each one as a structured lead record containing the address, the keyword that surfaced it, the page title and description, and the source URL. It is built for technical recruiters, developer-relations teams, open-source maintainers running outreach, and B2B sales teams selling developer tooling.

The Actor works by issuing targeted search queries scoped to `github.com`, combining each of your keywords with each of your chosen email domains — a search-operator technique that surfaces addresses developers have chosen to publish on their profiles and project pages. You supply the keywords, optionally a location filter and a list of email domains, set a cap on how many addresses to collect, and the Actor works through every keyword-and-domain combination until it hits your limit.

Because collection is bounded by an explicit `maxEmails` cap and progress is persisted between pages, this GitHub email scraper is predictable to run and cheap to control — you decide exactly how much data a run should produce before it starts.

***

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

Each dataset item is one unique email address together with the context in which it was found:

| Category | Fields | What you get |
|---|---|---|
| 📧 Contact data | `email` | The extracted email address, deduplicated across the run |
| 🔍 Search attribution | `keyword` | The specific keyword from your input list that produced this result |
| 📄 Page context | `title`, `description` | The result title and the surrounding descriptive text from the source page |
| 🔗 Provenance | `url` | The canonical URL of the page where the address was discovered |
| 🌐 Source platform | `network` | The platform the record came from — `Github.com` for every item this Actor produces |

The field doing the most useful work is `keyword`. Because each address carries the exact search term that surfaced it, you can measure which keywords actually produce contacts and which are wasted effort — turning your next run's `keywords` list into an informed decision rather than a guess.

***

### 🌟 Key Features of the GitHub Email Scraper

| Feature | Description |
|---|---|
| 🔍 Multi-keyword search | `keywords` accepts a list of queries — job titles, technologies, roles — and each is combined with every configured email domain |
| 📮 Custom email domain targeting | `customDomains` lets you specify which mailbox providers or corporate domains to hunt for, defaulting to `@gmail.com` and `@yahoo.com` |
| 📍 Optional location filtering | The `location` field adds a geographic term to each query, narrowing results to developers who list that location |
| 🎯 Hard collection cap | `maxEmails` stops the run at your chosen number, anywhere from 1 to 10,000, giving you direct control over run cost and duration |
| 🧹 Automatic deduplication | Addresses already seen during a run are tracked and never written twice, so the dataset contains unique contacts |
| 💾 Resumable progress | The keyword and domain cursor is persisted to a key-value store, so a long extraction resumes from where it left off rather than restarting |
| 🔁 Automatic proxy rotation | Proxy handling, session rotation and retry logic are managed internally — no proxy configuration is required from you |
| 🖥️ Rotating browser fingerprints | Requests cycle through a pool of realistic mobile user-agent strings, reducing the chance of a run being interrupted |
| ⚡ Browser-free architecture | Pages are fetched and parsed directly rather than rendered in headless Chrome, keeping runs fast and memory-light |

***

### 🚀 Why Choose This GitHub Email Scraper?

**Domain targeting makes the output segmented by design.** `customDomains` controls exactly which mailbox providers appear in your results. Set it to consumer providers for individual developer outreach, or to specific corporate domains when you are targeting employees of a particular company. The filtering happens in the query itself, so you are not paying to collect addresses you intended to discard.

**Every result is fully attributable.** `keyword`, `title`, `description` and `url` travel with each address. A recruiter can see at a glance which search produced a contact and what the source page said about them, which is what makes a first outreach message specific rather than generic — and what makes the dataset defensible from a compliance standpoint.

**Cost is bounded before the run starts.** `maxEmails` is a hard stop, not a suggestion. Combined with persisted progress tracking, this means a run either delivers the number of contacts you asked for or exhausts the available results — there is no scenario where an unbounded crawl runs away with your budget.

**Sensible defaults, minimal setup.** Only `keywords` is required, and even that ships with a working prefill. Location is optional, domains have defaults, and the cap starts at a conservative 20. You can produce a useful first dataset in under a minute and refine from there.

***

### 📥 Input

The GitHub email scraper needs one required field, `keywords`. Everything else refines the search.

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

#### 🔧 GitHub 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 | `""` (empty) | Location to filter search results |
| `customDomains` | array | No | `["@gmail.com", "@yahoo.com"]` | List of custom email domains |
| `maxEmails` | integer | No | `20` | Maximum number of emails to collect. The scraper stops once this limit is reached. Setting a higher limit allows for more potential results but does not guarantee reaching that number. Minimum 1, maximum 10,000 |

#### 💡 Input Examples

**Targeting backend engineers in Berlin:**

```json
{
  "keywords": ["backend engineer", "golang developer"],
  "location": "Berlin",
  "customDomains": ["@gmail.com"],
  "maxEmails": 100
}
```

**Broad technical recruiting sweep:**

```json
{
  "keywords": ["machine learning", "data engineer", "devops", "site reliability"],
  "customDomains": ["@gmail.com", "@outlook.com", "@protonmail.com"],
  "maxEmails": 500
}
```

**Quick validation run:**

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

***

### 📤 Output

Each unique email address becomes one dataset item. A representative record:

```json
{
  "network": "Github.com",
  "keyword": "backend engineer",
  "title": "alexdev (Alex Moreau) · GitHub",
  "description": "Backend engineer working on distributed systems in Go and Rust. Berlin. Reach me at alex.moreau.dev@gmail.com for collaboration.",
  "url": "https://github.com/alexdev",
  "email": "alex.moreau.dev@gmail.com"
}
```

#### 🧾 GitHub Email Scraper Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | null | Network of the item |
| `keyword` | string | null | Keyword that produced this item |
| `title` | string | null | Title of the item |
| `description` | string | null | Long-form description text |
| `url` | string | null | Canonical URL of the scraped item |
| `email` | string | null | Email address found for the item |

The `network` field is constant at `Github.com` for this Actor, which is useful when you merge its output with datasets from other platform scrapers — it keeps the combined table unambiguous about where each contact originated. All fields are nullable.

***

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

#### Step 1: Open the GitHub Email Scraper on Apify

Sign in to Apify and open the Actor page, then press **Start** to bring up the input form. A free account is enough to get going, and it provides a console where every run's log, configuration and dataset is preserved. That history is worth having for lead generation work — being able to point at the exact run that produced a contact is part of keeping the process auditable.

#### Step 2: Choose your keywords carefully

`keywords` is the single most influential input. Job titles work well (`backend engineer`, `data scientist`), as do technology names (`kubernetes`, `pytorch`) and role descriptors (`founder`, `maintainer`). Supply several related terms rather than one broad one — the Actor runs every keyword against every domain, so a list of four keywords and three domains produces twelve distinct search combinations, each contributing to your total. Overly generic single words return diffuse results; specific technical terms return fewer but far better matches.

#### Step 3: Decide whether to apply a location filter

`location` is optional and defaults to empty. Leaving it blank gives the broadest reach. Adding a value narrows every query to results that also mention that location, which is exactly what you want for regional hiring but will substantially reduce your yield. If a run with a location filter returns very little, try removing it or using a broader region — a country name rather than a city, for instance — before concluding the keywords are at fault.

#### Step 4: Configure your target email domains

`customDomains` defaults to `@gmail.com` and `@yahoo.com`. Adjust it to match who you are trying to reach. Consumer providers surface individual developers using personal addresses on their profiles. Adding corporate domains lets you target employees of specific organisations. Each domain multiplies the number of query combinations, so adding domains increases both reach and run duration.

#### Step 5: Set your collection cap

`maxEmails` defaults to 20, which is a sensible size for a first run. Keep it low while you evaluate whether your keyword and domain combination is producing relevant contacts. Once you are satisfied with the quality, raise it — up to 10,000 — and extend the run timeout in Run Options accordingly, since larger caps mean many more search pages to work through.

#### Step 6: Start the run and watch the log

Press **Start**. The log reports each keyword-and-domain pair as it is processed and prints every email as it is found and pushed to the dataset. This live visibility is genuinely useful: if the addresses appearing are not the kind you wanted, you can stop the run early, adjust the input, and restart rather than paying for a full run of unusable data. The log also surfaces suggestions when results are thin, such as removing a restrictive location filter.

#### Step 7: Review, verify and export

Open the **Output** tab and inspect the dataset before doing anything with it. Read a handful of `description` and `title` values to confirm the contacts genuinely match your target profile, and spot-check a few `url` values against the live pages. Export to CSV or JSON, then run every address through an email verification service before any outreach — extracted addresses are only as current as the page that published them.

***

### 🔌 API Access & Integrations

Run the GitHub email scraper through the Apify API and get the dataset back in a single call:

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

The same with the official Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "keywords": ["backend engineer", "golang developer"],
    "location": "Berlin",
    "customDomains": ["@gmail.com"],
    "maxEmails": 100,
}

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

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["email"], "|", item["keyword"], "|", item["url"])
```

The Actor also connects to Zapier, Make, Google Sheets, Slack, Airtable and any custom endpoint through Apify webhooks, so newly discovered developer contacts can flow directly into your CRM or ATS as each run finishes.

***

### 💡 Best Use Cases for GitHub Contact Data

#### 🧑‍💻 Technical Recruiting and Talent Sourcing

Recruiters can set `keywords` to the stack they are hiring for — `rust developer`, `kubernetes`, `react native` — and optionally add a `location` to focus on a hiring region. The `description` field usually carries the developer's own profile bio, which gives a sourcer real context for a first message rather than a template. The `url` links straight back to the profile for verification.

#### 🛠️ Developer Relations and Community Outreach

DevRel teams building relationships around a technology can search for keywords matching their ecosystem and reach maintainers who have published contact details. Grouping results by `keyword` shows which parts of the ecosystem have the densest active community, which is a useful input for deciding where to invest advocacy effort.

#### 💼 B2B Sales for Developer Tooling

Companies selling CI/CD platforms, observability tools or developer infrastructure need to reach practitioners, not procurement. Keywords describing the relevant technical role, combined with corporate values in `customDomains`, produce a prospect list of people who actually use the category of product being sold.

#### 🌍 Open-Source Contributor Discovery

Maintainers looking to grow a project can search keywords matching adjacent technologies to find developers already working in the same space. The `title` and `description` fields give enough signal to judge whether someone is a plausible contributor before any approach is made.

#### 📊 Developer Ecosystem Research

Analysts studying technology adoption can run broad keyword sets and examine the distribution of results across terms. Because `keyword` is recorded per row, the relative volume of contacts surfaced by `pytorch` versus `tensorflow`, or `golang` versus `rust`, is a rough but genuine indicator of published activity in each area.

#### 📣 Targeted Regional Campaigns

Setting `location` to a specific city or country and running a focused keyword set produces a geographically scoped contact list. Marketing teams use this for regional event promotion, local meetup recruitment, or campaigns where time zone and language matter to the message.

#### 🔗 Partner and Freelancer Sourcing

Agencies needing specialist contractors can search for niche technical keywords that full-time job boards rarely cover well. The combination of `description` and `url` lets you assess actual published work before making contact, which is a stronger signal than a self-reported CV.

***

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

- **Use specific technical keywords rather than generic ones.** `distributed systems engineer` returns far more relevant contacts than `engineer`, and the per-row `keyword` field will show you which terms earned their place.
- **Start without a location filter.** `location` narrows every query and can cut yield sharply. Establish that your keywords work first, then add geography.
- **Expand `customDomains` to widen reach.** More domains means more query combinations and more potential results, at the cost of a longer run. Add corporate domains when targeting a specific employer.
- **Keep `maxEmails` low for the first run.** Twenty results is enough to judge relevance. Scale up only once you are confident the input is producing the right kind of contact.
- **Extend the run timeout for large caps.** A `maxEmails` value in the hundreds or thousands means many search pages. Increase the timeout in Run Options — the default is 3600 seconds — so a productive run is not cut short.
- **Verify addresses before any outreach.** Published addresses go stale. A verification pass protects your domain's sending reputation and keeps bounce rates manageable.

***

### 🛠️ Troubleshooting

**The run returned fewer emails than `maxEmails`. Why?**
`maxEmails` is a ceiling, not a target. If your keyword, domain and location combination does not surface that many publicly indexed addresses, the run ends when results are exhausted. Broaden your `keywords`, add more entries to `customDomains`, or remove a restrictive `location` filter.

**I set a location and got almost nothing back.**
Location filtering adds a literal term to every query, which is a significant constraint. Try a broader region — a country instead of a city — or remove the filter entirely and filter geographically afterwards using the `description` field.

**Why are some `title` or `description` values empty?**
All output fields are nullable. Not every search result exposes a usable title or descriptive snippet, and the Actor records `null` rather than inventing a value.

**Can I configure my own proxy?**
No proxy setting is exposed in the input. Proxy rotation, session handling and retry logic are managed internally by the Actor.

**The run is taking a long time. What should I do?**
Long runs are usually a large `maxEmails` combined with many keyword-and-domain combinations. Reduce the cap, trim the keyword list, or extend the run timeout in Run Options. Progress is persisted, so the cursor position is not lost between pages.

***

### ❓ Frequently Asked Questions About GitHub Email Scraping

**What does the GitHub Email Scraper actually do?**
It runs targeted searches scoped to `github.com`, combining each of your keywords with each of your chosen email domains, extracts the email addresses found in those results, and outputs each as a record with the keyword, page title, description and source URL.

**What is the only required input?**
`keywords`. The location filter, custom domains and maximum email count all have defaults and are optional.

**How does the domain filtering work?**
Each domain in `customDomains` is included in the search query itself, so results are constrained to pages publishing addresses on those domains. Defaults are `@gmail.com` and `@yahoo.com`.

**Can I target corporate email domains instead of consumer ones?**
Yes. Replace the defaults in `customDomains` with the domains you want, for example `@acme.com`. This is the standard approach for reaching employees of a specific organisation.

**How many emails can a single run collect?**
`maxEmails` accepts values from 1 to 10,000. Larger values require a correspondingly longer run timeout.

**Do I need a GitHub account or personal access token?**
No. The Actor requires only your Apify token when run through the API, and nothing beyond a signed-in console session otherwise.

**Are duplicate email addresses removed?**
Yes. Addresses seen earlier in a run are tracked and are not written to the dataset again.

**What does the `network` field contain?**
The constant value `Github.com`, identifying the source platform. It is useful when merging this dataset with output from scrapers covering other platforms.

**Are the extracted addresses verified as deliverable?**
No. The Actor extracts addresses exactly as published on the source pages. Run them through a dedicated verification service before any campaign.

**Can I search multiple keywords in one run?**
Yes. `keywords` is an array, and every keyword is combined with every configured domain. Each output row records the specific `keyword` that produced it.

**Does the GitHub email scraper use a headless browser?**
No. It fetches and parses pages directly, which keeps runs faster and lighter than browser-based approaches.

**Can I resume a run that was interrupted?**
The Actor persists its keyword and domain cursor to a key-value store as it progresses, so a restarted run picks up from its recorded position rather than beginning again from scratch.

**What export formats are supported?**
JSON, CSV, Excel, XML, HTML table and RSS, from the Apify dataset view or through the API.

**Can I schedule the GitHub email scraper to run automatically?**
Yes. Use the Schedules feature in the Apify console to rerun the same configuration periodically and build a growing contact database.

**Is scraping email addresses from GitHub legal?**
The Actor collects only publicly indexed information that developers have chosen to publish. However, email addresses relating to identifiable individuals are personal data under GDPR, CCPA and similar regimes. You need a lawful basis for processing, must honour opt-out requests, and must comply with anti-spam legislation such as GDPR, CAN-SPAM and PECR before sending any outreach.

***

### 🆘 Support & Feedback

If a run fails, results look wrong, or a field behaves differently from what is documented here, please open a report in the **Issues** tab on the Actor page so it can be tracked and resolved.

Need a custom build — additional fields, different source platforms, a tailored output shape, or a bespoke contact extraction workflow — email **scraperhubapi@gmail.com** with your requirements.

If the GitHub Email Scraper is useful to your work, a review on the Apify Store helps other users find it and directly shapes what gets improved next.

***

### ⚖️ Disclaimer

The GitHub Email Scraper collects only publicly available, publicly indexed information — email addresses that individuals have chosen to publish on profiles and project pages. It does not access private repositories, authenticated areas, or any data behind access controls.

Email addresses are personal data. If you use this GitHub email scraper to collect addresses relating to identifiable individuals, you become a data controller under GDPR, the UK GDPR, CCPA and comparable frameworks. That carries real obligations: you need a documented lawful basis for processing — legitimate interest is the usual route for B2B and recruitment outreach, and the balancing test must actually be performed; you must inform data subjects of your processing; you must honour access, rectification and erasure requests; and you must retain data only as long as it is genuinely needed.

Outreach using extracted addresses is separately regulated. GDPR, CAN-SPAM, CASL, PECR and equivalent anti-spam laws impose requirements around consent, accurate sender identification, truthful subject lines and working opt-out mechanisms. These apply regardless of how an address was obtained, and breaching them carries genuine penalties.

You are also responsible for complying with the terms of service of GitHub and of any search platform whose results the extraction touches, and for keeping request volumes at a level that does not burden those services.

This Actor is not affiliated with, endorsed by, or sponsored by GitHub, Inc. or Microsoft Corporation. If you believe data collected by this Actor relates to you and you would like it removed, 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 Github 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/github-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/github-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/github-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/github-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/CCfETqexpevc1VSIe/builds/aUb0M1aoNxeEHTbtt/openapi.json