# Google Search Results Scraper (`fetch_cat/google-search-results-scraper`) Actor

Extract organic Google rankings, snippets, URLs, People Also Ask questions, and related searches for SEO and market research.

- **URL**: https://apify.com/fetch\_cat/google-search-results-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** SEO tools, Marketing
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 search 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

## Google Search Results Scraper

Extract organic Google Search results, rankings, snippets, result URLs, People Also Ask questions, and related searches for SEO research.

### Input recipes

- **Small test**: Start with the default input and a low result limit.
- **Focused run**: Use one specific public URL, query, profile, or location before expanding the input.
- **Scheduled monitoring**: Save the input as a task and schedule repeat runs when you need fresh data.

### What does Google Search Results Scraper do?

Google Search Results Scraper turns public Google result pages into structured datasets.

Use it to monitor search rankings, collect SERP snippets, compare localized results, and discover question or related-search ideas.

The actor accepts one or more search queries and returns one dataset row for each organic result.

Each row includes the query, rank, title, URL, displayed URL, snippet, page number, locale, timestamp, and SERP context.

It is designed for repeatable SEO and market research workflows on Apify.

### Who is this Google SERP scraper for?

SEO agencies use it to track client ranking positions across important keywords.

Growth teams use it to benchmark competitors and discover content opportunities.

Market researchers use it to collect the visible sources Google surfaces for a topic.

Founders use it to understand which products, directories, and articles appear for buyer-intent terms.

Content teams use People Also Ask and related searches to plan article outlines.

Local businesses can compare country-specific or language-specific search visibility.

### Why use this actor?

✅ Structured output instead of manual copying from search pages.

✅ Rank numbers saved with each organic result.

✅ Locale inputs for country and language targeting.

✅ Page controls for first-page checks or deeper rank monitoring.

✅ SERP context arrays for People Also Ask and related searches.

✅ Dataset output that works with Apify API, webhooks, integrations, and exports.

### Input settings

| Setting | JSON key | Type / default | Description |
| --- | --- | --- | --- |
| Queries | `queries` | array, default `["apify actors","best crm software"]` | Google searches to run. Add keywords, brands, questions, or local-intent phrases exactly as you would type them into Google. |
| Country / GL | `country` | string, default `"US"` | Two-letter Google country code used for localized rankings, for example US, GB, DE, FR, AU. |
| Language / HL | `language` | string, default `"en"` | Google interface language code, for example en, de, fr, es, it. |
| Results per query | `numResults` | integer, default `10` | Maximum organic results to save per query. Use 10 for a quick first run; increase for rank monitoring across pages. |
| Start page | `startPage` | integer, default `1` | First Google results page to scrape. Page 1 starts at rank 1; page 2 starts around rank 11. |
| Maximum pages per query | `maxPages` | integer, default `1` | How many Google pages to open for each query. The actor stops earlier when it reaches Results per query. |
| Include People Also Ask | `includePeopleAlsoAsk` | boolean, default `true` | Save visible question suggestions from Google SERPs when present. |
| Include related searches | `includeRelatedSearches` | boolean, default `true` | Save visible related search suggestions from Google SERPs when present. |
| Proxy configuration | `proxyConfiguration` | object, default `{"useApifyProxy":true,"apifyProxyGroups":["GOOGLE_SERP"]}` | Optional Apify Proxy settings. The default uses Apify's GOOGLE\_SERP proxy group for stable Google result-page downloads. |

### Output fields

| JSON key | Type | Description |
| --- | --- | --- |
| `query` | string | Search query that produced the row. |
| `rank` | integer | Organic Google rank for the result. When `startPage` is 2, ranks start around 11. |
| `title` | string | Result title shown by Google. |
| `url` | string | Destination URL after Google redirect cleanup. |
| `displayUrl` | string or null | Displayed URL/citation text when present. |
| `snippet` | string or null | Visible result snippet when present. |
| `resultType` | string | Currently `organic`. |
| `page` | integer | Google results page number that produced the row. |
| `peopleAlsoAsk` | string\[] | Visible People Also Ask questions from the same SERP page. |
| `relatedSearches` | string\[] | Visible related-search suggestions from the same SERP page. |
| `timestamp` | string | ISO timestamp when the page was processed. |
| `country` | string | Google `gl` country code used for the run. |
| `language` | string | Google `hl` language code used for the run. |
| `searchUrl` | string | Google Search URL requested for the page. |

### Pricing

This Actor uses pay-per-event pricing configured in `.actor/actor.json`.

| Event | Price | Charged when |
| --- | --- | --- |
| Start (`start`) | $0.005 per event | One-time fee per run |
| Search result (`result`) | $0.001 per event at Bronze, about $1.00 per 1,000 events | Per organic Google result saved to the dataset |

Store discount tiers for saved search results:

| Tier | Price per result |
| --- | ---: |
| Free | $0.00115 |
| Bronze | $0.00100 |
| Silver | $0.00078 |
| Gold | $0.00060 |
| Platinum | $0.00040 |
| Diamond | $0.00028 |

### Quick start

1. Open the actor on Apify.

2. Enter your search queries.

3. Choose country and language.

4. Set the number of results per query.

5. Keep the first test small.

6. Run the actor.

7. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input: queries

Add search terms exactly as you want Google to process them.

Examples:

- `apify actors`

- `best crm software`

- `pizza near me`

- `site:example.com pricing`

- `content marketing agency london`

Each query is processed independently.

### Input: country and language

Use `country` for Google country localization.

Use `language` for the Google interface language.

Common examples:

- `US` and `en`

- `GB` and `en`

- `DE` and `de`

- `FR` and `fr`

- `ES` and `es`

Localized rankings can differ significantly, so keep these fields consistent for monitoring.

### Input: result limits

`numResults` controls the maximum organic results saved per query.

`startPage` controls the first Google page to open.

`maxPages` controls how many pages can be opened per query.

For example, `numResults = 20`, `startPage = 1`, and `maxPages = 2` checks roughly the first two SERP pages.

The actor stops early when it reaches the requested number of results.

### Input: SERP blocks

Enable `includePeopleAlsoAsk` to attach visible questions from the result page.

Enable `includeRelatedSearches` to attach visible related-search suggestions.

These values are page-level context and are repeated on result rows from the same page.

They are useful for content briefs and keyword expansion.

### Input: proxy configuration

Google Search can be sensitive to automated access.

For the most stable runs, use Apify Proxy and match the proxy country to your `country` input.

Start with small jobs before running large batches.

If Google returns a challenge, reduce volume, use a suitable proxy group, and keep locale settings consistent.

### Example input

```json
{
  "queries": [
    "apify actors",
    "best crm software"
  ],
  "country": "US",
  "language": "en",
  "numResults": 10,
  "startPage": 1,
  "maxPages": 1,
  "includePeopleAlsoAsk": true,
  "includeRelatedSearches": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

### Output example

```json
{
  "query": "apify actors",
  "rank": 1,
  "title": "Apify Store",
  "url": "https://apify.com/store",
  "displayUrl": "https://apify.com › store",
  "snippet": "Browse ready-made web scraping and automation actors.",
  "resultType": "organic",
  "page": 1,
  "peopleAlsoAsk": ["What is an Apify actor?"],
  "relatedSearches": ["apify actor examples"],
  "timestamp": "2026-06-18T06:00:00.000Z",
  "country": "US",
  "language": "en",
  "searchUrl": "https://www.google.com/search?q=apify+actors"
}
```

### Tips for best results

Keep the first run small.

Use one country and language pair per monitoring workflow.

Avoid mixing very broad and very specific queries in the same cost test.

Use stable query wording if you compare ranks over time.

Export datasets to CSV for spreadsheets or JSON for automation.

### Common SEO workflows

Track weekly keyword positions for a client.

Compare first-page competitors for buyer-intent terms.

Collect snippets for messaging research.

Find People Also Ask questions for article briefs.

Discover related searches for keyword expansion.

Check how results differ by country or language.

### Integrations

Send finished datasets to Google Sheets through Apify integrations.

Trigger Slack notifications when a run completes.

Store historical rankings in a database.

Connect webhooks to a reporting pipeline.

Use Make, Zapier, or custom API scripts to schedule repeat checks.

### API usage

Run Google Search Results Scraper from your own code with the Apify API.

**Node.js**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const input = {
  "queries": [
    "apify actors",
    "best crm software"
  ],
  "country": "US",
  "language": "en",
  "numResults": 10,
  "startPage": 1
};

const run = await client.actor('fetch_cat/google-search-results-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python**

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fetch_cat/google-search-results-scraper").call(run_input={
  "queries": [
    "apify actors",
    "best crm software"
  ],
  "country": "US",
  "language": "en",
  "numResults": 10,
  "startPage": 1
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-search-results-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["apify actors","best crm software"],"country":"US","language":"en","numResults":10,"startPage":1}'
```

### Use with AI agents via MCP

Google Search Results Scraper can be used by AI assistants through the hosted Apify MCP server.

**Claude Code setup**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/google-search-results-scraper"
```

**Claude Desktop, Cursor, or VS Code JSON config**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/google-search-results-scraper"
    }
  }
}
```

**Example prompts**

- "Run Google Search Results Scraper with this input JSON and summarize the dataset."
- "Export the latest Google Search Results Scraper results to a table I can review."
- "Schedule this Actor for monitoring and tell me what changed between runs."

### Scheduling

Create an Apify schedule to run the same keyword set daily, weekly, or monthly.

Keep query lists small enough for your monitoring cadence.

Store each run's dataset ID if you want historical rank comparisons.

### Data quality notes

Google result pages vary by country, language, device, time, and personalization controls.

The actor disables personalized search with the public search parameters it controls.

SERP layouts can change, so optional blocks may be missing on some pages.

Ranks refer to extracted organic results, not ads or every visual module.

### Troubleshooting: no results

If a run saves no results, Google may have returned a consent page, empty page, or automation challenge.

Try a smaller input first.

Use Apify Proxy with a country that matches your locale.

Avoid unusually high page counts during early testing.

### Troubleshooting: localized results look unexpected

Confirm the `country` and `language` inputs.

Use two-letter country codes such as `US`, `GB`, or `DE`.

Use language codes such as `en`, `de`, or `fr`.

Remember that Google can still vary results based on availability and current SERP experiments.

### Legal and ethical use

This actor extracts public search result information.

Use it responsibly and respect applicable laws, platform terms, and privacy requirements.

Do not use scraped data for spam, credential collection, or abusive automation.

If you process personal data, ensure you have a lawful basis and appropriate safeguards.

### Related actors

- [Bing SERP & Search Results Scraper](https://apify.com/fetch_cat/bing-search-results-scraper)
- [DuckDuckGo Search Results Scraper](https://apify.com/fetch_cat/duckduckgo-search-results-scraper)
- [Google Ads Transparency Scraper](https://apify.com/fetch_cat/google-ads-transparency-scraper)
- [Google Autocomplete Scraper](https://apify.com/fetch_cat/google-autocomplete-scraper)
- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)

### FAQ

#### Does this scrape paid ads?

Not in v1. The first version focuses on organic Google results and visible SERP context.

#### Can I scrape multiple countries?

Run separate jobs for separate countries to keep outputs easy to compare.

#### Can I get more than 10 results?

Yes. Increase `numResults` and `maxPages`.

#### Why do ranks change between runs?

Google rankings are dynamic and can vary by time, locale, device, and SERP experiments.

#### Can I schedule recurring rank checks?

Yes. Use Apify schedules and store the output dataset from each run.

#### What export formats are supported?

Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or HTML.

#### Is a proxy required?

A proxy is recommended for reliable Google SERP scraping, especially for repeated or localized runs.

#### How should I start?

Use one query, `US`, `en`, and 10 results. Review the output before scaling.

### Support

Report bugs, wrong output, blocked runs, or missing fields from the Actor page. Include the Apify run ID or run URL, your input JSON, what you expected, what the Actor returned, and one reproducible public URL so the issue can be tested quickly.

# Actor input Schema

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

Google searches to run. Add keywords, brands, questions, or local-intent phrases exactly as you would type them into Google.

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

Two-letter Google country code used for localized rankings, for example US, GB, DE, FR, AU.

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

Google interface language code, for example en, de, fr, es, it.

## `numResults` (type: `integer`):

Maximum organic results to save per query. Use 10 for a quick first run; increase for rank monitoring across pages.

## `startPage` (type: `integer`):

First Google results page to scrape. Page 1 starts at rank 1; page 2 starts around rank 11.

## `maxPages` (type: `integer`):

How many Google pages to open for each query. The actor stops earlier when it reaches Results per query.

## `includePeopleAlsoAsk` (type: `boolean`):

Save visible question suggestions from Google SERPs when present.

## `includeRelatedSearches` (type: `boolean`):

Save visible related search suggestions from Google SERPs when present.

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

Optional Apify Proxy settings. The default uses Apify's GOOGLE\_SERP proxy group for stable Google result-page downloads.

## Actor input object example

```json
{
  "queries": [
    "apify actors",
    "best crm software"
  ],
  "country": "US",
  "language": "en",
  "numResults": 10,
  "startPage": 1,
  "maxPages": 1,
  "includePeopleAlsoAsk": true,
  "includeRelatedSearches": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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": [
        "apify actors",
        "best crm software"
    ],
    "country": "US",
    "language": "en",
    "numResults": 10,
    "startPage": 1,
    "maxPages": 1,
    "includePeopleAlsoAsk": true,
    "includeRelatedSearches": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "GOOGLE_SERP"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-search-results-scraper").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": [
        "apify actors",
        "best crm software",
    ],
    "country": "US",
    "language": "en",
    "numResults": 10,
    "startPage": 1,
    "maxPages": 1,
    "includePeopleAlsoAsk": True,
    "includeRelatedSearches": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["GOOGLE_SERP"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/google-search-results-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "apify actors",
    "best crm software"
  ],
  "country": "US",
  "language": "en",
  "numResults": 10,
  "startPage": 1,
  "maxPages": 1,
  "includePeopleAlsoAsk": true,
  "includeRelatedSearches": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "GOOGLE_SERP"
    ]
  }
}' |
apify call fetch_cat/google-search-results-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/google-search-results-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/LUhhSBG3VVK4ImvoE/builds/pa1BSdkuYMpyY89jx/openapi.json