# YouTube Channel Email & Metadata Scraper API (`lance_api/youtube-channel-email-metadata-scraper-api`) Actor

Extract public email addresses and rich metadata from YouTube channels, including channel details, subscriber counts, descriptions, links, and other available contact information. Built for lead generation, creator outreach, CRM enrichment, and API automation.

- **URL**: https://apify.com/lance\_api/youtube-channel-email-metadata-scraper-api.md
- **Developed by:** [LanceAPI](https://apify.com/lance_api) (community)
- **Categories:** AI, Social media
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## 📧 YouTube Channel Email Scraper API

**Find YouTube creators, extract public business emails, and collect channel data in one API-ready workflow.**

Submit YouTube channel URLs, handles, channel IDs, or video URLs—or search by niche and keyword. Get structured records containing **public emails, phone numbers, websites, social profiles, subscriber counts, views, channel metadata, and processing status**.

Built for **creator outreach, influencer discovery, sponsorship research, lead generation, CRM enrichment, market analysis, and automated data pipelines**. Start with a single channel or discover hundreds of creators without building your own search, resolution, deduplication, and data-cleaning workflow.

- **Flexible input:** known channels, handles, IDs, videos, or keywords
- **Contact-ready output:** public emails, phones, websites, and social profiles
- **Developer-friendly:** stable JSON, documented fields, and API examples
- **Clear pricing:** low-cost pay-per-result pricing with Store discounts
- **Public data only:** no private access, login-wall bypass, or CAPTCHA solving

### ⭐ Key features

#### Find creators in two ways

Process creators you already know or use keyword search to discover channels by topic, niche, or market. Both modes can run together.

#### Extract public contact information

Return public email strings, phone numbers, websites, and social profiles exposed through supported YouTube channel data.

#### Enrich every result with channel intelligence

Combine contact fields with channel name, handle, ID, subscribers, total views, video count, country, join date, avatar, banner, and verification status.

#### Accept practical YouTube input formats

Use channel URLs, `@handles`, channel IDs, custom/user URLs, standard video URLs, Shorts URLs, or `youtu.be` links. Video inputs are resolved to their uploader channels.

#### Build automation-ready datasets

Each returned channel uses a predictable schema with source context, normalized fields, success/failure status, timestamps, and error details.

#### Understand hidden business-email signals

`hasHiddenEmail` indicates that YouTube appears to show a business-email option behind its verification flow. It does **not** mean the hidden address was extracted.

### 🚀 Quick input example

```json
{
  "urls": [
    "https://www.youtube.com/@Google"
  ],
  "searchQueries": [
    "AI automation creators"
  ],
  "maxResultsPerQuery": 20,
  "country": "US",
  "language": "en-US"
}
```

### Short output example

```json
{
  "status": "success",
  "channelName": "Example Creator",
  "channelHandle": "@examplecreator",
  "channelId": "UCwx4iod3ECHlNOk9iEJB9xA",
  "channelUrl": "https://www.youtube.com/channel/UCwx4iod3ECHlNOk9iEJB9xA",
  "youtubeEmail": "business@example.com",
  "hasEmail": true,
  "hasHiddenEmail": false,
  "subscriberCount": 125000,
  "country": "United States",
  "websiteUrl": "https://example.com/",
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

A complete output example with contact arrays, social links, metadata, and run fields appears in [Complete output example](#complete-output-example).

### Input

Provide at least one non-empty value in `urls` or `searchQueries`.

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `urls` | string\[] | No\* | `[]` | Up to 200 channel URLs, handles, channel IDs, custom/user URLs, video URLs, Shorts URLs, or `youtu.be` links. |
| `searchQueries` | string\[] | No\* | `[]` | Up to 20 keywords used to discover YouTube channels. |
| `maxResultsPerQuery` | integer | No | `20` | Final channel limit per keyword after filtering. Minimum 1, maximum 200. |
| `country` | string | No | empty | Country localization for keyword search relevance. Ignored for direct inputs. |
| `language` | string | No | empty | Language localization for keyword search relevance. Ignored for direct inputs. |
| `joinedDateFrom` | string | No | empty | Keep channels created on or after this date. Format: `YYYY-MM-DD`. |
| `joinedDateTo` | string | No | empty | Keep channels created on or before this date. Format: `YYYY-MM-DD`. |

\* At least one of `urls` or `searchQueries` is required.

#### Input behavior

- Each non-empty direct input is processed independently, including repeated inputs.
- Video and Shorts URLs resolve to the uploader channel.
- Search results are deduplicated by stable channel ID.
- Direct and search modes can be combined in one run.
- `maxResultsPerQuery` limits final matching results, not raw search candidates.
- `country` and `language` localize search relevance; they do not hard-filter returned channel metadata.
- If a join-date filter is active, channels with unknown join dates are excluded.

### Input examples

#### Process known channels and videos

```json
{
  "urls": [
    "https://www.youtube.com/@Google",
    "@LinusTechTips",
    "UCXuqSBlHAE6Xw-yeJA0Tunw",
    "https://www.youtube.com/watch?v=dQw4w9WgXcQ"
  ]
}
```

#### Discover creators by keyword

```json
{
  "searchQueries": [
    "SaaS marketing creators",
    "creator economy podcast"
  ],
  "maxResultsPerQuery": 50,
  "country": "US",
  "language": "en-US"
}
```

#### Filter by channel join date

```json
{
  "searchQueries": [
    "AI automation creators"
  ],
  "maxResultsPerQuery": 30,
  "joinedDateFrom": "2022-01-01",
  "joinedDateTo": "2026-12-31"
}
```

#### Combine direct inputs and discovery

```json
{
  "urls": [
    "https://www.youtube.com/@Google"
  ],
  "searchQueries": [
    "science education creators"
  ],
  "maxResultsPerQuery": 20
}
```

### API usage

Actor ID used in all examples:

```text
lance_api/youtube-channel-email-metadata-scraper-api
```

Set your Apify API token in the standard `APIFY_TOKEN` environment variable. Do not hard-code secrets in application source code.

#### JavaScript

Install the client:

```bash
npm install apify-client
```

Run the Actor and retrieve its dataset:

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

const client = new ApifyClient({
    token: process.env.APIFY_TOKEN,
});

const input = {
    searchQueries: ['AI automation creators'],
    maxResultsPerQuery: 20,
    country: 'US',
    language: 'en-US',
};

const run = await client
    .actor('lance_api/youtube-channel-email-metadata-scraper-api')
    .call(input);

const { items } = await client
    .dataset(run.defaultDatasetId)
    .listItems();

console.log(items);
```

#### Python

Install the client:

```bash
pip install apify-client
```

Run the Actor and iterate through its dataset:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run_input = {
    "urls": ["https://www.youtube.com/@Google"],
    "searchQueries": ["science education creators"],
    "maxResultsPerQuery": 20,
}

run = client.actor(
    "lance_api/youtube-channel-email-metadata-scraper-api"
).call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### cURL

Start a run and wait for it to finish:

```bash
curl --request POST \
  "https://api.apify.com/v2/acts/lance_api~youtube-channel-email-metadata-scraper-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  --header "Content-Type: application/json" \
  --data '{
    "searchQueries": ["AI automation creators"],
    "maxResultsPerQuery": 20,
    "country": "US",
    "language": "en-US"
  }'
```

For larger runs, use the asynchronous Actor run endpoint and retrieve the default dataset after completion.

### Output

The Actor writes each returned record to the default dataset with a clear processing status and consistent field structure.

Output is available through:

- Apify Console
- Dataset API
- JavaScript and Python clients
- JSON, CSV, Excel, XML, RSS, and HTML exports
- Tasks, schedules, webhooks, Make, and Zapier integrations

The default Output view provides channel, contact, and performance fields. The **Contacts and links** view focuses on outreach-ready contact data.

### Complete output field reference

#### Channel identity and metadata

| Field | Type | Description |
| --- | --- | --- |
| `channelName` | string or null | Public channel title. |
| `channelHandle` | string or null | Public YouTube `@handle`. |
| `channelId` | string or null | Stable YouTube channel ID. |
| `channelUrl` | string or null | Canonical channel URL. |
| `description` | string or null | Public channel description. |
| `subscriberCount` | number or null | Normalized subscriber count. |
| `subscriberCountText` | string or null | Original subscriber-count text. |
| `viewCount` | number or null | Normalized total view count. |
| `viewCountText` | string or null | Original view-count text. |
| `videoCount` | number or null | Normalized video count. |
| `videoCountText` | string or null | Original video-count text. |
| `country` | string or null | Public channel country when available. |
| `joinedDate` | string or null | Channel join date in `YYYY-MM-DD` format. |
| `thumbnailUrl` | string or null | Channel avatar URL. |
| `bannerUrl` | string or null | Channel banner URL. |
| `isVerified` | boolean or null | Public verification state when available. |

#### Email and phone fields

| Field | Type | Description |
| --- | --- | --- |
| `youtubeEmail` | string or null | First public email returned for the channel. |
| `emails` | object\[] | All deduplicated public emails with source labels. |
| `hasEmail` | boolean | Whether at least one public email was returned. |
| `hasHiddenEmail` | boolean or null | Whether a hidden YouTube business-email option appears to exist. This is not an extracted address. |
| `phones` | object\[] | Public phone strings with source labels. |
| `hasPhone` | boolean | Whether at least one phone string was returned. |

Contact source labels can include:

- `channel-about`: channel About/description data
- `channel-description`: public channel-description text
- `channel-link`: text or URL exposed through the YouTube channel; the linked destination is not crawled

Returned emails are extracted public strings. They are not MX-, SMTP-, mailbox-, or deliverability-verified.

#### Website and social fields

| Field | Type | Description |
| --- | --- | --- |
| `websiteUrl` | string or null | Primary website when identified. |
| `instagramUrl` | string or null | Instagram profile URL. |
| `xUrl` | string or null | X/Twitter profile URL. |
| `linkedinUrl` | string or null | LinkedIn URL. |
| `facebookUrl` | string or null | Facebook URL. |
| `tiktokUrl` | string or null | TikTok URL. |
| `discordUrl` | string or null | Discord URL. |
| `telegramUrl` | string or null | Telegram URL. |
| `whatsappUrl` | string or null | WhatsApp URL. |
| `patreonUrl` | string or null | Patreon URL. |
| `skoolUrl` | string or null | Skool URL. |
| `hasLinks` | boolean | Whether any user-facing links were returned. |
| `socialLinks` | object | Links grouped by detected type. |
| `allLinks` | object\[] | All normalized links with URL, title, type, and source. |

#### Processing fields

| Field | Type | Description |
| --- | --- | --- |
| `status` | string | Processing status: `success` or `failed`. |
| `inputUrl` | string or null | Original direct input. |
| `source` | string | Input mode: `url` or `search`. |
| `searchQuery` | string or null | Keyword that discovered the channel. |
| `scrapedAt` | ISO 8601 string | Processing timestamp. |
| `error` | string or null | Failure message when `status` is `failed`. |

### Status values

| Status | Meaning |
| --- | --- |
| `success` | Channel data was processed and returned. |
| `failed` | A direct input could not be resolved or processed. Check the `error` field for details. |

Search candidates that fail before a returnable record is created can be skipped and may not appear as failed dataset items.

### Complete output example

The example below uses reserved example contact information and does not represent a real person's private details.

```json
{
  "status": "success",
  "inputUrl": "https://www.youtube.com/@examplecreator",
  "source": "url",
  "searchQuery": null,
  "channelName": "Example Creator",
  "channelHandle": "@examplecreator",
  "channelId": "UCwx4iod3ECHlNOk9iEJB9xA",
  "channelUrl": "https://www.youtube.com/channel/UCwx4iod3ECHlNOk9iEJB9xA",
  "description": "Technology videos. Business: business@example.com",
  "subscriberCount": 125000,
  "subscriberCountText": "125K subscribers",
  "viewCount": 18400000,
  "viewCountText": "18.4M views",
  "videoCount": 312,
  "videoCountText": "312 videos",
  "country": "United States",
  "joinedDate": "2019-05-14",
  "thumbnailUrl": "https://yt3.ggpht.com/example-avatar",
  "bannerUrl": null,
  "isVerified": false,
  "youtubeEmail": "business@example.com",
  "emails": [
    {
      "email": "business@example.com",
      "source": "channel-about"
    }
  ],
  "hasEmail": true,
  "hasHiddenEmail": false,
  "phones": [],
  "hasPhone": false,
  "websiteUrl": "https://example.com/",
  "instagramUrl": "https://www.instagram.com/examplecreator/",
  "xUrl": null,
  "linkedinUrl": null,
  "facebookUrl": null,
  "tiktokUrl": null,
  "discordUrl": null,
  "telegramUrl": null,
  "whatsappUrl": null,
  "patreonUrl": null,
  "skoolUrl": null,
  "hasLinks": true,
  "socialLinks": {
    "website": ["https://example.com/"],
    "instagram": ["https://www.instagram.com/examplecreator/"]
  },
  "allLinks": [
    {
      "url": "https://example.com/",
      "title": "Website",
      "type": "website",
      "source": "channel-link"
    },
    {
      "url": "https://www.instagram.com/examplecreator/",
      "title": "Instagram",
      "type": "instagram",
      "source": "channel-link"
    }
  ],
  "scrapedAt": "2026-01-01T00:00:00.000Z",
  "error": null
}
```

### 💰 Pricing

This Actor uses **pay-per-result pricing** with a low base cost of **$1 per 1,000 returned results**. You pay for the records you receive, with no Actor setup fee or recurring subscription.

When a result contains at least one public email, an additional email-found fee applies—**as low as $3 per 1,000 results with email**, depending on your Apify Store discount tier. This fee is charged **once per result, not once per email**: whether a result contains one email or three, it still counts as a single email-found result. If no public email is returned, there is **no email-found fee**.

Keyword-based creator discovery costs **$0.05 per submitted search query**. Channels excluded by your filters are not returned as results.

See the Actor's **Pricing** tab for the complete prices, Store discounts, and platform charges applicable to your plan.

### 🎯 Use cases

#### Creator outreach

Build contact-ready YouTube creator lists containing public emails, phone numbers, websites, social profiles, and channel statistics.

#### Influencer discovery

Search by topic or niche, identify relevant channels, and enrich every returned creator record.

#### Sponsorship prospecting

Use audience size, channel activity, geography, public links, and contact availability to prioritize partnership candidates.

#### Lead generation

Turn channel, handle, and video lists into structured records for qualification and outreach workflows.

#### CRM enrichment

Add stable channel IDs, handles, public contacts, social profiles, subscriber counts, country, join dates, and processing timestamps to existing creator records.

#### Market and competitor research

Analyze public YouTube channel data across niches, localized searches, creator segments, and markets.

#### Developer and AI automation

Connect the Actor to applications, data warehouses, agent workflows, Tasks, schedules, webhooks, Make, Zapier, or custom APIs.

### Public data and responsible use

This Actor is designed for responsible workflows involving publicly available YouTube channel data.

- It extracts email addresses only from supported **public channel sources**.
- It does not access private accounts, private content, or non-public user information.
- It does not bypass YouTube login, sign-in, or verification walls.
- It does not solve CAPTCHA or reCAPTCHA challenges.
- It does not reveal email addresses hidden behind YouTube's verification flow.
- It does not visit linked external websites to search for additional contact information.
- It does not validate whether an email mailbox exists or is deliverable.

You are responsible for complying with YouTube's Terms of Service, Apify's Terms of Service, applicable privacy and anti-spam laws, and any other rules relevant to your use case.

If you use contact data for outreach, review requirements under CAN-SPAM, GDPR, ePrivacy, and applicable local regulations. Do not use the Actor for spam, harassment, unlawful profiling, or attempts to access non-public information.

### FAQ

#### Does this Actor return every YouTube business email?

No. It returns public email strings available through supported channel-level data. YouTube can place business emails behind login and verification flows that this Actor does not bypass.

#### What does `hasHiddenEmail` mean?

It means YouTube appears to show a business-email option for the channel. It does not mean the address was revealed or returned.

#### Why did a channel return no email?

Many channels do not publish an email publicly. In that case, `hasEmail` is `false`, `youtubeEmail` is `null`, and `emails` is empty. You pay no email-found fee for that result.

#### Are the returned emails verified?

No. They are extracted public strings, not deliverability-verified mailboxes.

#### Can I submit a video or Shorts URL?

Yes. The Actor resolves the uploader channel and returns channel-level contact information and metadata.

#### Can I combine direct inputs and keyword search?

Yes. Both modes can run together. Search-discovered channels are deduplicated by stable channel ID.

#### How does keyword search pricing work?

Keyword discovery costs $0.05 per submitted query. The channels it returns follow the same pay-per-result pricing, and the email-found fee applies only to results containing at least one public email.

#### How are duplicate inputs handled?

Each non-empty direct input is processed independently. Search-discovered channels are deduplicated by stable channel ID.

#### Does the Actor scan external websites, video descriptions, or pinned comments?

No. The current version focuses on supported channel-level data and does not crawl linked destinations, video descriptions, or pinned comments.

#### Why can `websiteUrl` be null when `allLinks` contains values?

`websiteUrl` is reserved for a link classified as a primary website. Social or other links can remain in `allLinks` without being assigned to that field.

#### How can I control run cost?

Set the maximum charge limit when starting the run, reduce `maxResultsPerQuery`, and test with a small input first.

### Limitations

- Only publicly available YouTube channel data is supported.
- Private, deleted, restricted, renamed, blocked, or temporarily unavailable channels can fail.
- Some fields can be `null` when the channel does not publish them.
- Hidden business-email indicators do not contain the hidden email address.
- Public email strings are not mailbox- or deliverability-verified.
- Linked external websites are not crawled.
- Video descriptions and pinned comments are not scanned.
- Search localization influences relevance but does not guarantee channel country or content language.
- Join-date filtering excludes channels whose join date is unknown.
- Search may return fewer items than `maxResultsPerQuery` when results are exhausted, filtered, unavailable, or duplicated.
- Temporary YouTube, network, or upstream-data changes can affect availability.
- Search candidates that fail before a returnable record is created may be skipped rather than written as failed items.

### 🛠️ Support

Need help, want to report an issue, or have a feature request?

- Open the Actor's **Issues** tab in Apify Console
- Email **lanceapi2026@hotmail.com**

For the fastest diagnosis, include the run ID and a non-sensitive example input. Never send your Apify API token.

# Actor input Schema

## `urls` (type: `array`):

YouTube channel URLs, @handles, channel IDs, custom channel URLs, user URLs, or video URLs. Each valid or invalid direct input that is written to the dataset counts as one result.

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

Keywords used to discover YouTube channels. Each submitted keyword has a $0.05 discovery fee; returned channels follow the standard result pricing.

## `maxResultsPerQuery` (type: `integer`):

Cap how many final channels each keyword can return after details are fetched and joined-date filters are applied.

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

Localize keyword search results. Ignored for direct URL input. This affects search relevance only and does not remove returned channels by country.

## `language` (type: `string`):

Localize keyword search results. Ignored for direct URL input.

## `joinedDateFrom` (type: `string`):

Skip channels created before this date. Leave empty to include all. Use YYYY-MM-DD.

## `joinedDateTo` (type: `string`):

Skip channels created after this date. Leave empty to include all. Use YYYY-MM-DD.

## Actor input object example

```json
{
  "urls": [
    "https://www.youtube.com/@Google",
    "UCXuqSBlHAE6Xw-yeJA0Tunw"
  ],
  "searchQueries": [
    "AI automation creators",
    "fitness coach"
  ],
  "maxResultsPerQuery": 20,
  "country": "",
  "language": ""
}
```

# Actor output Schema

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

Public contact details, YouTube channel metadata, source context, and processing status.

# 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 = {
    "urls": [
        "https://www.youtube.com/@Google",
        "UCXuqSBlHAE6Xw-yeJA0Tunw"
    ],
    "searchQueries": [
        "AI automation creators",
        "fitness coach"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lance_api/youtube-channel-email-metadata-scraper-api").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 = {
    "urls": [
        "https://www.youtube.com/@Google",
        "UCXuqSBlHAE6Xw-yeJA0Tunw",
    ],
    "searchQueries": [
        "AI automation creators",
        "fitness coach",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("lance_api/youtube-channel-email-metadata-scraper-api").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 '{
  "urls": [
    "https://www.youtube.com/@Google",
    "UCXuqSBlHAE6Xw-yeJA0Tunw"
  ],
  "searchQueries": [
    "AI automation creators",
    "fitness coach"
  ]
}' |
apify call lance_api/youtube-channel-email-metadata-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lance_api/youtube-channel-email-metadata-scraper-api"
        }
    }
}

```

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/ejsZy6hnPawWQNahU/builds/26YT0BcDuPC8c0U4r/openapi.json