# Google SERP Scraper | $0.10/1K | Titles, Snippets, Thumbnails (`monkey.d.scraping/google-serp-fast`) Actor

Fast, cheap Google search results API: titles, URLs, snippets, thumbnails, page metadata, result type and domain positions for up to 1,000 keywords per run. Country, language and time filters. From $0.08 per 1,000 results. 谷歌搜索结果采集

- **URL**: https://apify.com/monkey.d.scraping/google-serp-fast.md
- **Developed by:** [Monkey D. Scraping](https://apify.com/monkey.d.scraping) (community)
- **Categories:** SEO tools, Developer tools, AI
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.08 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google SERP Scraper — Fast & Cheap Search Results API | 谷歌搜索结果采集

Scrape Google search results for up to **1,000 keywords in one run** and get clean, deduplicated rows: title, URL, snippet, domain, result type, favicon, thumbnail, page description and published date. Choose country, language and time range. Results start landing in your dataset within a second of starting the run.

**From $0.08 per 1,000 results**, platform usage included. One result = one dataset row, so you pay only for what you receive.

Also known as: Google SERP scraper, Google search API, SERP API, Google keyword scraper, organic results extractor, Google search results exporter, bulk Google search, search engine results page scraper.

### Why this Google SERP scraper?

- **Fast.** 100 keywords × 20 results (2,000 rows) finished in 10 seconds of run time; 500 keywords × 10 results in 3 minutes (measured on the Apify platform, November 2026).
- **Cheap.** From $0.08 per 1,000 results on paid plans, platform usage included. No separate proxy or compute charges.
- **More than links.** Every row includes the result type (web, video, PDF), favicon, page thumbnail, Open Graph image, description, site name and published date when the page provides them.
- **Deduplicated.** Tracking parameters are stripped and each URL appears once per query. Optionally keep each URL only once across the whole run.
- **Localized.** 34 countries and 21 interface languages, plus time filters: past hour, day, week, month or year.
- **Operators work.** Use `site:`, `intitle:`, `inurl:`, `filetype:`, quotes and minus signs like you would on Google.
- **Parallel.** Up to 1,000 queries per run, processed up to 20 at a time.
- **Domain positions built in.** List your domains and every query reports the position of each one in the collected results; matching rows are labelled.
- **Markdown digest.** A `MARKDOWN` record groups titles, links and descriptions by query, ready to paste into an LLM prompt.
- **LLM-ready.** Flat JSON rows with titles, snippets and descriptions, ready for RAG pipelines and AI agents.

### How it compares

| | This Actor | Lofomachines | ScraperLink | API Dojo |
|---|---|---|---|---|
| Price per 1,000 results, paid plans | **$0.08–0.10, usage included** | $0.14 + platform usage | $0.50 per 1,000 pages | $2 per 1,000 queries + extras |
| Fields per result | **18** | 11 | 4 | 4 |
| Thumbnail, image, description, site name, published date | **yes** | no | no | no |
| Result type (web / video / PDF) | **yes** | no | no | no |
| Domain positions per query | **yes** | no | no | no |
| Markdown digest for LLMs | **yes** | no | no | no |
| Deduplication across queries | **yes** | no | no | no |
| Time range, country, language | yes | yes | yes | partial |
| Keywords per run | 1,000 | 1,000 | 1 per run | unlimited |

Listed prices and fields were read from the public Store pages on November 8, 2026.

### Use cases

- **SEO monitoring** — collect the results for your keyword list every day and see which domains appear, and where, for each query.
- **Competitor and SERP analysis** — see which domains, videos and PDFs show up for a topic in each country.
- **AI, LLM and RAG pipelines** — give your agent fresh, deduplicated web sources with snippets and descriptions.
- **Lead generation** — find companies, directories and suppliers for `"keyword" site:.de` style queries.
- **Brand and news monitoring** — run brand terms with `timeRange: "day"` to catch new pages fast.
- **Content research** — gather titles, descriptions and publication dates for hundreds of topics at once.
- **Market research** — compare results across countries and languages in a single run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | array | — | One keyword or search query per line. Google operators work. 1 to 1,000 queries per run. |
| `maxResultsPerQuery` | integer | `10` | Results to collect for each query, 1 to 300. |
| `trackDomains` | array | — | Domains to watch, one per line. Each query reports the position of every listed domain in the collected results. |
| `country` | string | `us` | Country for localized results (`us`, `gb`, `de`, `it`, `jp`, `cn`, `tw` …). |
| `language` | string | `en` | Interface language (`en`, `de`, `es`, `zh-CN`, `zh-TW`, `ja` …). |
| `timeRange` | string | `any` | `any`, `hour`, `day`, `week`, `month` or `year`. |
| `includePageMetadata` | boolean | `true` | Add thumbnail, image, description, site name and published date. |
| `deduplicateAcrossQueries` | boolean | `false` | Keep each URL only for the first query that returns it. |
| `safeSearch` | boolean | `false` | Filter explicit content. |
| `maxConcurrency` | integer | `10` | Queries processed in parallel, 1 to 20. |
| `proxyConfiguration` | object | Apify proxy | Apify proxy settings; datacenter proxies are included in the price. |
| `searchEngineId` | string | — | Optional Programmable Search Engine ID to search your own set of sites. |

#### Example input

```json
{
  "queries": ["web scraping tools", "best espresso machine"],
  "maxResultsPerQuery": 20,
  "country": "us",
  "language": "en",
  "timeRange": "any"
}
```

### Output

One row per result. Example:

```json
{
  "query": "web scraping tools",
  "position": 1,
  "rank": null,
  "title": "Welcome to Python.org",
  "url": "https://www.python.org/",
  "displayedUrl": "www.python.org",
  "domain": "python.org",
  "snippet": "Get Started. Whether you're new to programming or an experienced developer, it's easy to learn and use Python.",
  "resultType": "web",
  "favicon": "https://www.google.com/s2/favicons?domain=python.org&sz=64",
  "page": 1,
  "description": "The official home of the Python Programming Language",
  "siteName": "Python.org",
  "thumbnail": "https://encrypted-tbn0.gstatic.com/images?q=tbn:...",
  "image": "https://www.python.org/static/opengraph-icon-200x200.png",
  "publishedDate": null
}
```

| Field | Meaning |
|---|---|
| `query` | The query that produced the row. |
| `position` | Order of the result in the collected list for that query, starting at 1. |
| `rank` | Reserved; currently `null`. Use `position` for ordering. |
| `title`, `url`, `displayedUrl`, `domain` | Result title, destination URL, URL as displayed and registrable domain. |
| `snippet` | Text snippet shown with the result. |
| `resultType` | `web`, `video` (YouTube, Vimeo) or `pdf`. |
| `favicon` | Favicon URL for the domain. |
| `page` | Results page the row was collected from. |
| `description`, `siteName`, `image`, `thumbnail`, `publishedDate` | Page metadata when the page publishes it (Open Graph and article tags). |

A `SUMMARY` record in the run's key-value store lists every query with its status, number of results, estimated total results on Google and collection time, plus a `queriesToRetry` list you can paste into a new run and, when `trackDomains` is set, `domainPositions` per query. A `MARKDOWN` record holds the same results as a Markdown digest grouped by query.

### Pricing

You pay per result row. Platform usage is included.

| Plan | Price per 1,000 results |
|---|---|
| Free | $0.25 |
| Starter | $0.10 |
| Scale | $0.09 |
| Business and above | $0.08 |

Examples on the Starter plan: 100 keywords × 10 results = 1,000 rows = $0.10. 1,000 keywords × 20 results = 20,000 rows = $2.00.

### How to use it

1. Paste your keywords into **Search queries**, one per line.
2. Set **Results per query** (10 for a first page, up to 100).
3. Pick **Country**, **Language** and **Time range** if you need localized or recent results.
4. Click **Start**. Download the dataset as JSON, CSV, Excel or XML, or read it through the API.

#### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/monkey.d.scraping~google-serp-fast/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["apify", "web scraping"], "maxResultsPerQuery": 10, "country": "us"}'
```

#### Real-time Google SERP API for apps and AI agents

Need results inside an HTTP response instead of a dataset? Use the **Server** tab. Send the same JSON input to `POST /search` (or use `GET /search?q=...`) and the results come back in the response within seconds, ready for SEO tools, AI agents, RAG pipelines, n8n and Make.

```bash
curl -X POST "https://YOUR_SERVER_URL/search" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["apify"], "maxResultsPerQuery": 10, "country": "us"}'
```

Copy the server URL from the Server tab. Results cost the same per result as a normal run, and failed queries are free. Bulk runs, schedules and dataset exports keep working exactly as before.

The server supports both **single-tenant** (each user gets a separate server run in their own account) and **multi-tenant** (shared server instances, with every request's results kept separate and returned only to its caller). Apify activates one mode at a time; the Server tab shows the active one. For long keyword lists, a normal run is the better fit; if the server is busy, retry after a few seconds.

#### Integrations

Works with the Apify API, scheduler and webhooks, and with n8n, Make, Zapier, Google Sheets, Slack and the Apify MCP server, so your AI agent can call it as a tool.

### FAQ

**How many results can I get per keyword?** Up to 300 per query; Google typically lists around 100 to 120 distinct pages for a query. Use 10 for the first page, 20 to 100 for deeper coverage.

**Which countries and languages are supported?** 34 countries and 21 interface languages are available in the input form, including Chinese (Simplified and Traditional), Japanese, Korean, German, French, Spanish, Italian and Portuguese.

**Does it return ads, People Also Ask or AI overviews?** It returns organic results with metadata. For ads, use our Google Ads Transparency Scraper.

**How does deduplication work?** Tracking parameters such as `utm_*`, `gclid` and `fbclid` are removed and each URL appears once per query. With **Return each URL once across all queries** enabled, a URL is kept only for the first query that returns it.

**How fast is it?** 2,000 results from 100 keywords took about 10 seconds of run time in our November 2026 measurements.

**Is scraping Google search results legal?** Search results are publicly available data. Review the terms that apply to your use case and the privacy rules of your jurisdiction.

### Related Google Actors by Monkey D. Scraping

- [Google Trends Scraper — Keyword History API](https://apify.com/monkey.d.scraping/google-trends-keyword-analysis)
- [Google News Scraper — Company News & Article URLs](https://apify.com/monkey.d.scraping/google-news-scraper-lite)
- [Google Ads Scraper — Transparency Center](https://apify.com/monkey.d.scraping/google-ads-transparency-scraper)
- [Google Shopping Price Tracker & Seller Monitor](https://apify.com/monkey.d.scraping/google-shopping-price-change-seller-monitor)
- [Google Hotels Room Offers Scraper](https://apify.com/monkey.d.scraping/google-hotels-room-offers)

### More tools for marketers

- [YouTube Scraper | Transcripts, Comments, Shorts](https://apify.com/monkey.d.scraping/youtube-scraper) — videos, Shorts, channels and playlists with transcripts and up to 100 comments per video included, from $0.19/1K.
- [Website SEO Audit & Contact Scraper](https://apify.com/monkey.d.scraping/website-opportunity-auditor)
- [Apify Store Rank Tracker & Visibility Monitor](https://apify.com/monkey.d.scraping/store-visibility-monitor)
- [LinkedIn Ad Library Scraper](https://apify.com/monkey.d.scraping/linkedin-ad-library-scraper)
- [TikTok Ads Library Scraper](https://apify.com/monkey.d.scraping/tiktok-ads-library-scraper)
- [Facebook Comments Scraper](https://apify.com/monkey.d.scraping/facebook-comments-scraper)

***

### 谷歌搜索结果采集器（简体中文）

**快速、低价的谷歌 SERP API。** 一次运行最多 **1,000 个关键词**，每个关键词最多 100 条结果。输出字段包括标题、链接、摘要、域名、结果类型（网页 / 视频 / PDF）、网站图标、缩略图、页面描述、站点名称和发布日期。支持按国家、语言和时间范围筛选。

**价格：付费套餐每 1,000 条结果最低 $0.08**，已包含平台用量。一条结果 = 一行数据，只为收到的结果付费。

#### 与其他采集器的比较

| | 本采集器 | Lofomachines | ScraperLink | API Dojo |
|---|---|---|---|---|
| 付费套餐每 1,000 条结果 | **$0.08–0.10，含平台用量** | $0.14 + 平台用量 | 每 1,000 页 $0.50 | 每 1,000 次查询 $2 + 额外 |
| 每条结果字段数 | **18** | 11 | 4 | 4 |
| 缩略图、图片、描述、站点名称、发布日期 | **有** | 无 | 无 | 无 |
| 结果类型（网页 / 视频 / PDF） | **有** | 无 | 无 | 无 |
| 每个关键词的域名位置 | **有** | 无 | 无 | 无 |
| 面向大模型的 Markdown 摘要 | **有** | 无 | 无 | 无 |
| 跨关键词去重 | **有** | 无 | 无 | 无 |
| 每次运行关键词数 | 1,000 | 1,000 | 1 | 不限 |

价格与字段信息取自 2026 年 11 月 8 日的公开 Store 页面。

#### 为什么选择它

- **快：** 100 个关键词 × 20 条结果（2,000 行），运行时间 10 秒；500 个关键词 × 10 条结果，3 分钟（2026 年 11 月在 Apify 平台实测）。
- **内置域名位置：** 填写 `trackDomains`，每个关键词都会报告各域名在采集结果中的位置。
- **Markdown 摘要：** `MARKDOWN` 记录按关键词汇总标题、链接和描述，可直接用于大模型提示词。
- **便宜：** 付费套餐每 1,000 条结果最低 $0.08，无额外代理或计算费用。
- **信息更全：** 每行附带结果类型、网站图标、缩略图、Open Graph 图片、描述、站点名称和发布日期（页面提供时）。
- **自动去重：** 去除 `utm_*`、`gclid` 等跟踪参数，每个关键词下每个链接只出现一次；可选在整次运行中只保留一次。
- **本地化：** 34 个国家、21 种界面语言，支持 `zh-CN`、`zh-TW`、`cn`、`tw`、`hk`、`sg`；时间范围：过去 1 小时 / 1 天 / 1 周 / 1 个月 / 1 年。
- **支持搜索运算符：** `site:`、`intitle:`、`inurl:`、`filetype:`、引号和减号。

#### 输入参数

| 字段 | 类型 | 默认值 | 说明 |
|---|---|---|---|
| `queries` | 数组 | — | 每行一个关键词或搜索语句，1 到 1,000 个。 |
| `maxResultsPerQuery` | 整数 | `10` | 每个关键词采集的结果数，1 到 300。 |
| `trackDomains` | 数组 | — | 要跟踪的域名，每行一个；每个关键词报告各域名的首次位置。 |
| `country` | 字符串 | `us` | 国家代码，如 `cn`、`tw`、`hk`、`sg`、`us`。 |
| `language` | 字符串 | `en` | 界面语言，如 `zh-CN`、`zh-TW`、`en`。 |
| `timeRange` | 字符串 | `any` | `any`、`hour`、`day`、`week`、`month`、`year`。 |
| `includePageMetadata` | 布尔 | `true` | 添加缩略图、图片、描述、站点名称和发布日期。 |
| `deduplicateAcrossQueries` | 布尔 | `false` | 整次运行中每个链接只保留一次。 |
| `safeSearch` | 布尔 | `false` | 过滤成人内容。 |
| `maxConcurrency` | 整数 | `10` | 并行处理的关键词数，1 到 20。 |

示例：

```json
{
  "queries": ["网络爬虫 工具", "跨境电商 选品"],
  "maxResultsPerQuery": 20,
  "country": "cn",
  "language": "zh-CN",
  "timeRange": "month"
}
```

#### 输出字段

`query`（关键词）、`position`（顺序）、`title`（标题）、`url`（链接）、`displayedUrl`（显示链接）、`domain`（域名）、`snippet`（摘要）、`resultType`（`web` / `video` / `pdf`）、`favicon`（网站图标）、`page`（结果页码）、`description`（页面描述）、`siteName`（站点名称）、`image`（Open Graph 图片）、`thumbnail`（缩略图）、`publishedDate`（发布日期）。

运行的键值存储中有一条 `SUMMARY` 记录，列出每个关键词的状态、结果数、谷歌预估结果总数和采集耗时，以及可直接粘贴到新运行的 `queriesToRetry` 列表。

#### 价格

| 套餐 | 每 1,000 条结果 |
|---|---|
| Free | $0.25 |
| Starter | $0.10 |
| Scale | $0.09 |
| Business 及以上 | $0.08 |

#### 使用步骤

1. 在 **Search queries** 中粘贴关键词，每行一个。
2. 设置 **Results per query**（首页填 10，最多 100）。
3. 按需选择 **Country**、**Language** 和 **Time range**。
4. 点击 **Start**，以 JSON、CSV、Excel 或 XML 下载数据集，或通过 API 读取。可接入 n8n、Make、Zapier、Google Sheets 和 Apify MCP 服务器。

#### 常见问题

**每个关键词最多多少条结果？** 最多 300 条；谷歌通常为一个关键词列出约 100 到 120 个不同页面。首页用 10，深度采集用 20 到 100。

**是否包含广告、People Also Ask 或 AI 概览？** 返回自然搜索结果及页面元数据。广告请使用我们的谷歌广告采集器。

**去重如何工作？** 去除跟踪参数后，每个关键词下每个链接只出现一次；开启跨关键词去重后，整次运行只保留第一次出现的链接。

***

### 谷歌搜尋結果擷取器（繁體中文）

**快速、低價的 Google SERP API。** 一次執行最多 **1,000 個關鍵字**，每個關鍵字最多 300 筆結果。輸出包含標題、網址、摘要、網域、結果類型（網頁 / 影片 / PDF）、網站圖示、縮圖、頁面描述、網站名稱與發布日期。支援依國家、語言與時間範圍篩選（`tw`、`hk`、`zh-TW`）。

**價格：付費方案每 1,000 筆結果最低 $0.08**，已包含平台用量。一筆結果 = 一列資料。

- 參數、輸出欄位與價格請參考上方 [简体中文说明](#谷歌搜索结果采集器简体中文)；欄位名稱與英文版相同。
- 範例：`{"queries": ["網路爬蟲 工具"], "maxResultsPerQuery": 20, "country": "tw", "language": "zh-TW"}`
- 支援 `site:`、`intitle:`、`filetype:` 等搜尋運算子，並自動去除 `utm_*` 等追蹤參數。

# Actor input Schema

## `queries` (type: `array`):

One keyword or search query per line, up to 1,000 per run. Google operators such as site:, intitle: and quotes work.

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

How many results to collect for each query (1–300). Each result is one dataset row.

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

Country used for localized results.

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

Interface language of the results.

## `timeRange` (type: `string`):

Only return pages indexed within this period.

## `trackDomains` (type: `array`):

Optional. Domains to track, one per line (for example yourbrand.com). Each query reports the first position of every tracked domain and matching rows are labelled.

## `includePageMetadata` (type: `boolean`):

Add thumbnail, image, description, site name and published date taken from each page's metadata when available.

## `deduplicateAcrossQueries` (type: `boolean`):

When several queries share a URL, keep it only for the first query that returns it.

## `safeSearch` (type: `boolean`):

Filter explicit content.

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

How many queries run at the same time (1–20).

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

Apify proxy used to spread queries across connections. Datacenter proxies are included; choose residential for the most demanding workloads.

## `searchEngineId` (type: `string`):

Optional. Use your own Google Programmable Search Engine ID to search a custom set of sites.

## Actor input object example

```json
{
  "queries": [
    "web scraping tools",
    "best espresso machine"
  ],
  "maxResultsPerQuery": 10,
  "country": "us",
  "language": "en",
  "timeRange": "any",
  "includePageMetadata": true,
  "deduplicateAcrossQueries": false,
  "safeSearch": false,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per result: query, position, title, url, domain, snippet, resultType, favicon, thumbnail, image, description, siteName, publishedDate.

## `summary` (type: `string`):

Per-query status, result counts, estimated totals, domain positions and queries to retry.

## `markdown` (type: `string`):

Results grouped by query as Markdown, ready for LLM prompts.

# 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 = {
    "queries": [
        "web scraping tools",
        "best espresso machine"
    ],
    "maxResultsPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("monkey.d.scraping/google-serp-fast").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 = {
    "queries": [
        "web scraping tools",
        "best espresso machine",
    ],
    "maxResultsPerQuery": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("monkey.d.scraping/google-serp-fast").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 '{
  "queries": [
    "web scraping tools",
    "best espresso machine"
  ],
  "maxResultsPerQuery": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call monkey.d.scraping/google-serp-fast --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,monkey.d.scraping/google-serp-fast"
        }
    }
}
```

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/U6EoPyM7pAdBvfT7B/builds/hphrcBBhOdgbYEl4b/openapi.json