# Google Search Scraper (`vortex_data/google-search`) Actor

Fast Google SERP scraper for SEO teams, marketers, and agencies. Collect live organic rankings, ads, People Also Ask, related searches, and knowledge panels by keyword, country, and language in clean page-based output.

- **URL**: https://apify.com/vortex\_data/google-search.md
- **Developed by:** [VortexData](https://apify.com/vortex_data) (community)
- **Categories:** SEO tools, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does Google Search Results Scraper do?

Google Search Results Scraper collects live [Google Search](https://www.google.com/search?q=nike) SERP data for any keyword. Use it to monitor SEO rankings, analyze competitors, discover keyword ideas, check search ads, or build search result reports without opening Google manually.

Enter one or more search terms, choose a country, language, and result depth, then download structured results from Apify in JSON, CSV, Excel, HTML, XML, or RSS.

### Why use this Google SERP scraper?

- 🔎 **Live Google results** for keywords, brands, products, locations, and competitors
- 📈 **SEO-ready output** with positions, titles, URLs, descriptions, ratings, reviews, and sitelinks
- 📢 **Ads and shopping results** when they appear on the page
- ❓ **People Also Ask**, related searches, and knowledge panel data
- 🌍 **Localized SERPs** by country and language
- 📄 **Simple page-based rows**: page 1, page 2, page 3, and so on

### How to scrape Google Search results

1. Add keywords in **Search queries**. Use one search per line.
2. Choose **Results to request**: `10`, `20`, `30`, `40`, `50`, `100`, or `all`.
3. Select **Country** and **Language**.
4. Optionally enable mobile results, freshness filters, exact match, site search, or file type filters.
5. Click **Start** and export the dataset.

### Input example

```json
{
  "keyword": "nike\nbest running shoes",
  "limit": "20",
  "country": "US",
  "language": "en"
}
````

With this input, the Actor collects the first two Google results pages for each keyword.

### Output example

Each dataset item represents one Google results page.

```json
{
  "page_number": 1,
  "search_term": "nike",
  "results": [
    {
      "position": 1,
      "title": "Nike. Just Do It. Nike.com",
      "url": "https://www.nike.com/",
      "description": "Inspiring the world's athletes, Nike delivers innovative products, experiences and services."
    }
  ],
  "related_keywords": {
    "keywords": [
      { "position": 1, "keyword": "Nike shoes" }
    ]
  },
  "next_page": 2,
  "next_start": 10
}
```

### What can you use the data for?

- 📊 Track keyword rankings over time
- 🥊 Compare your website with competitors
- 🔁 Find related search terms for content planning
- 📢 Review ads shown for commercial keywords
- ❓ Collect People Also Ask questions for FAQs
- 🌍 Compare SERPs across countries and languages

### Notes

Google results can vary by location, language, device, personalization, and time. For audits or debugging, enable **Save page snapshots** to keep the original Google HTML returned during the run.

# Actor input Schema

## `keyword` (type: `string`):

Enter one Google search per line. You can also paste a full Google Search URL.

## `limit` (type: `string`):

How many results to request per search. Each 10 results equals one Google page. Select all to collect up to the standard Google result depth.

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

Two-letter country code such as US, GB, DE, FR, CA, AU, or BR. This selects the Google country domain and local results.

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

Language of the Google interface and result hints.

## `dateRange` (type: `string`):

Limit results to a recent time period.

## `mobileResults` (type: `boolean`):

Fetch the mobile version of Google results.

## `exactMatch` (type: `boolean`):

Search for each query as an exact phrase.

## `site` (type: `string`):

Limit results to a single domain, for example example.com.

## `fileTypes` (type: `array`):

Optional file extensions such as pdf, docx, xlsx, or csv.

## `includeUnfilteredResults` (type: `boolean`):

Ask Google to include similar results that are normally hidden.

## `saveHtmlToKeyValueStore` (type: `boolean`):

Keep a copy of the original Google page. Useful when you want to review exactly what was returned.

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

How many searches can run at the same time. Keep the default unless you are running a large list.

## `requestTimeoutSecs` (type: `integer`):

Maximum time in seconds to wait for one Google response.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed search before saving an error row.

## Actor input object example

```json
{
  "keyword": "Nike\nbest SEO tools",
  "limit": "10",
  "country": "US",
  "language": "en",
  "dateRange": "any",
  "mobileResults": false,
  "exactMatch": false,
  "site": "example.com",
  "fileTypes": [],
  "includeUnfilteredResults": false,
  "saveHtmlToKeyValueStore": false,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 60,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

Main table with one row per Google results page.

## `htmlSnapshots` (type: `string`):

Key-value store records. Present only when HTML snapshots are enabled.

# 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 = {
    "keyword": `Nike
best SEO tools`
};

// Run the Actor and wait for it to finish
const run = await client.actor("vortex_data/google-search").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 = { "keyword": """Nike
best SEO tools""" }

# Run the Actor and wait for it to finish
run = client.actor("vortex_data/google-search").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 '{
  "keyword": "Nike\\nbest SEO tools"
}' |
apify call vortex_data/google-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Search Scraper",
        "description": "Fast Google SERP scraper for SEO teams, marketers, and agencies. Collect live organic rankings, ads, People Also Ask, related searches, and knowledge panels by keyword, country, and language in clean page-based output.",
        "version": "0.5",
        "x-build-id": "ktAHaBrWiXzY6cAaF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vortex_data~google-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vortex_data-google-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/vortex_data~google-search/runs": {
            "post": {
                "operationId": "runs-sync-vortex_data-google-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/vortex_data~google-search/run-sync": {
            "post": {
                "operationId": "run-sync-vortex_data-google-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search queries",
                        "type": "string",
                        "description": "Enter one Google search per line. You can also paste a full Google Search URL."
                    },
                    "limit": {
                        "title": "📄 Results to request",
                        "enum": [
                            "10",
                            "20",
                            "30",
                            "40",
                            "50",
                            "100",
                            "all"
                        ],
                        "type": "string",
                        "description": "How many results to request per search. Each 10 results equals one Google page. Select all to collect up to the standard Google result depth.",
                        "default": "10"
                    },
                    "country": {
                        "title": "Country",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter country code such as US, GB, DE, FR, CA, AU, or BR. This selects the Google country domain and local results.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ru",
                            "uk",
                            "tr",
                            "ar",
                            "hi",
                            "ja",
                            "ko",
                            "zh-CN",
                            "zh-TW"
                        ],
                        "type": "string",
                        "description": "Language of the Google interface and result hints.",
                        "default": "en"
                    },
                    "dateRange": {
                        "title": "🗓️ Freshness",
                        "enum": [
                            "any",
                            "pastDay",
                            "pastWeek",
                            "pastMonth",
                            "pastYear"
                        ],
                        "type": "string",
                        "description": "Limit results to a recent time period.",
                        "default": "any"
                    },
                    "mobileResults": {
                        "title": "📱 Mobile results",
                        "type": "boolean",
                        "description": "Fetch the mobile version of Google results.",
                        "default": false
                    },
                    "exactMatch": {
                        "title": "Exact phrase match",
                        "type": "boolean",
                        "description": "Search for each query as an exact phrase.",
                        "default": false
                    },
                    "site": {
                        "title": "Search only one website",
                        "pattern": "^$|^([\\w-]+\\.)+\\w+$",
                        "type": "string",
                        "description": "Limit results to a single domain, for example example.com.",
                        "default": ""
                    },
                    "fileTypes": {
                        "title": "File types",
                        "maxItems": 10,
                        "type": "array",
                        "description": "Optional file extensions such as pdf, docx, xlsx, or csv.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeUnfilteredResults": {
                        "title": "Show omitted results",
                        "type": "boolean",
                        "description": "Ask Google to include similar results that are normally hidden.",
                        "default": false
                    },
                    "saveHtmlToKeyValueStore": {
                        "title": "Save page snapshots",
                        "type": "boolean",
                        "description": "Keep a copy of the original Google page. Useful when you want to review exactly what was returned.",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Searches at once",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many searches can run at the same time. Keep the default unless you are running a large list.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Wait time per search",
                        "minimum": 5,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Maximum time in seconds to wait for one Google response.",
                        "default": 60
                    },
                    "maxRequestRetries": {
                        "title": "Retry failed searches",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many times to retry a failed search before saving an error row.",
                        "default": 2
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
