# Easy Google Search Results Scraper - from $0.13/1000 results (`xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results`) Actor

No need to overpay, Get Google Search results at price you can afford.

- **URL**: https://apify.com/xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results.md
- **Developed by:** [Miso](https://apify.com/xmiso_scrapers) (community)
- **Categories:** Automation, Developer tools, SEO tools
- **Stats:** 103 total users, 2 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 4.53 out of 5 stars

## Pricing

from $0.13 / 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/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

## 🔎 Easy Google Search Results Scraper

**Fast, lightweight Google Search scraper — from $0.13 per 1,000 search results.**

Search Google programmatically and get clean, structured search results ready for automation, lead generation, research, SEO analysis, data enrichment, and AI workflows.

No browser automation. No complicated setup. Just enter your search query and get structured Google Search data.

***

### 🚀 What does this Actor do?

**Easy Google Search Results Scraper** lets you run Google searches and extract structured data including:

- 🔗 Organic Google Search results
- 📝 Result titles and snippets
- 🌐 Result URLs
- 🔢 Search result positions
- 🧠 Google Knowledge Panel data
- 🔎 Related search keywords
- ✏️ Spelling suggestions
- 📄 Pagination information
- 🌍 Country and language-specific results
- 📊 Search metadata

Results are stored directly in the Apify Dataset and can be exported as **JSON, CSV, Excel, XML, RSS**, or accessed through the **Apify API**.

***

### 💰 Simple, low-cost Google Search data

Get Google Search results **from approximately $0.13 per 1,000 results**.

This Actor is designed to be a simple and economical option when you need structured Google Search results without running and maintaining your own search scraping infrastructure.

Typical use cases include:

- Lead generation
- Company research
- Contact discovery workflows
- SEO research
- Competitor monitoring
- Website discovery
- Domain enrichment
- Market research
- AI / LLM data pipelines
- Search result monitoring
- Keyword discovery

***

### ⚡ Quick Start

Enter a search query:

```json
{
  "query": "doctor california"
}
```

That's it.

The Actor searches Google and stores the structured results in the default dataset.

For more control:

```json
{
  "query": "best restaurants new york",
  "country": "us",
  "gl": "US",
  "hl": "en",
  "page": 1,
  "include_knowledge_panel": true,
  "include_related_keywords": true
}
```

***

### 📥 Input

#### `query`

**Required**

The Google Search query you want to run.

Example:

```text
doctor california
```

Other examples:

```text
plumber chicago
```

```text
software companies germany
```

```text
best restaurants nyc
```

```text
site:linkedin.com/in CEO SaaS Germany
```

Maximum length: **500 characters**.

***

#### `country`

Country code used for the search.

Default:

```text
us
```

Examples:

```text
us
uk
de
fr
in
```

***

#### `gl`

Google geolocation parameter.

Default:

```text
US
```

Examples:

```text
US
DE
IN
FR
GB
```

Use this to influence the geographic context of the returned Google results.

***

#### `hl`

Google interface/result language.

Default:

```text
en
```

Examples:

```text
en
de
fr
es
it
```

***

#### `page`

Search results page to retrieve.

Default:

```text
1
```

Supported range:

```text
1 – 10
```

Example:

```json
{
  "query": "dentist california",
  "page": 2
}
```

***

#### `include_knowledge_panel`

Controls whether Knowledge Panel information is included.

Default:

```json
true
```

Set to `false` if you only need normal search results.

***

#### `include_related_keywords`

Controls whether related Google search keywords and available spelling suggestions are included.

Default:

```json
true
```

***

### 📤 Output

The Actor stores several types of records in the default Apify Dataset.

Every record contains an internal `_kind` field identifying its type.

The Actor provides dedicated Dataset views so you can easily browse each type separately.

***

### 🔗 Search Results

Search results use:

```text
_kind = "result"
```

Example:

```json
{
  "_kind": "result",
  "title": "Example Medical Center",
  "snippet": "Healthcare services and specialist doctors...",
  "url": "https://example.com/",
  "position": 1,
  "_search_query": "doctor california",
  "_country": "us",
  "_page": "1"
}
```

The **Search Results** dataset view contains the most useful fields:

| Field | Description |
|---|---|
| `title` | Google result title |
| `snippet` | Search result description/snippet |
| `url` | Destination URL |
| `position` | Position in Google results |
| `_search_query` | Query used for the search |
| `_page` | Search result page |

This view is ideal when you only need the actual Google Search results.

***

### 🧠 Knowledge Panel

When available and enabled, the Actor extracts Google Knowledge Panel information.

Example fields can include:

```json
{
  "_kind": "knowledge_panel",
  "name": "Example Company",
  "label": "Company",
  "description_text": "Example Company is...",
  "description_url": "https://example.com/source",
  "image_url": "https://..."
}
```

Additional Knowledge Panel sections may also be returned as separate structured records.

This can be useful for extracting information about:

- Companies
- Organizations
- Brands
- People
- Places
- Other entities recognized by Google

Knowledge Panel availability depends on the search query and Google's returned data.

***

### 🔎 Related Keywords

Related searches are stored separately:

```text
_kind = "related_keyword"
```

Example:

```json
{
  "_kind": "related_keyword",
  "search_query": "doctor california",
  "rk_position": 1,
  "keyword": "best doctors in california"
}
```

When Google provides a spelling suggestion, it can also be returned in this dataset section.

This data can be useful for:

- Keyword research
- Query expansion
- SEO workflows
- Building additional search queries
- Lead generation pipelines

***

### 📊 Metadata

Each search also produces a metadata record:

```text
_kind = "metadata"
```

Example:

```json
{
  "_kind": "metadata",
  "search_query": "doctor california",
  "page": "1",
  "country": "us",
  "language": "en",
  "next_page": 2,
  "next_start": 10
}
```

Metadata can contain:

- Search query
- Number of returned results
- Current page
- Country
- Language
- Search parameters
- Next page
- Next result offset

This is particularly useful when integrating the Actor into automated workflows.

***

### 📚 Dataset Views

For convenience, the default Dataset contains separate views.

#### Search Results

Shows only normal Google Search results:

```text
_kind = result
```

#### Related Keywords

Shows related searches and spelling suggestions:

```text
_kind = related_keyword
```

#### Knowledge Panel

Shows available Knowledge Panel information.

#### Metadata

Shows search and pagination metadata.

This means you don't need to manually filter the full Dataset when working in the Apify Console.

***

### 🌍 Localized Google Searches

You can combine `country`, `gl`, and `hl` to target different markets.

#### United States

```json
{
  "query": "roofing contractors",
  "country": "us",
  "gl": "US",
  "hl": "en"
}
```

#### Germany

```json
{
  "query": "software unternehmen",
  "country": "de",
  "gl": "DE",
  "hl": "de"
}
```

#### India

```json
{
  "query": "digital marketing agency",
  "country": "in",
  "gl": "IN",
  "hl": "en"
}
```

This makes the Actor suitable for international search and data collection workflows.

***

### 📄 Pagination

Use the `page` input to retrieve additional Google Search result pages.

For example:

```json
{
  "query": "real estate agencies florida",
  "page": 1
}
```

Then:

```json
{
  "query": "real estate agencies florida",
  "page": 2
}
```

The metadata output can also contain `next_page` and `next_start` information when available.

The Actor currently accepts pages **1 through 10**.

***

### 🔌 API Usage

Like any Apify Actor, this scraper can be integrated into your application through the Apify API.

This makes it suitable for automated pipelines such as:

```text
Search Query
     ↓
Google Search
     ↓
Structured Results
     ↓
Website / Domain Extraction
     ↓
Data Enrichment
     ↓
CRM / Database / AI Processing
```

You can also connect Actor runs with:

- Apify API
- Webhooks
- Make
- Zapier
- n8n
- Python applications
- Node.js applications
- Your own backend
- AI agents and LLM pipelines

***

### 💡 Example Use Cases

#### Lead generation

Search for businesses or professionals:

```text
dentist texas
```

```text
HVAC contractor florida
```

```text
marketing agency london
```

Extract URLs and use them as input for your existing enrichment pipeline.

#### Company discovery

Find companies matching specific search criteria:

```text
SaaS startup Germany
```

```text
solar installer California
```

#### Domain discovery

Use Google operators:

```text
"accounting firm" Chicago
```

```text
site:.de "software development"
```

#### Contact research

Use targeted queries such as:

```text
"John Smith" "Example Company"
```

or:

```text
"Example Company" CEO
```

The returned URLs and snippets can then be processed by your downstream enrichment tools.

#### SEO & keyword research

Use the related-keyword output to discover additional queries associated with your original search.

***

### ⚙️ Designed for Automation

The Actor intentionally outputs structured records instead of one large nested response.

This makes the data easier to:

- Export
- Filter
- Process
- Stream
- Store in databases
- Feed into AI models
- Use in automation workflows

The `_kind` field makes each dataset record easy to identify programmatically.

***

### ❓ FAQ

#### How much does it cost?

Pricing starts at approximately **$0.13 per 1,000 search results**.

Actual Actor usage and platform costs may depend on your Apify plan and run configuration.

#### Do I need proxies?

No proxy configuration is required from the user. Simply provide your search query and run the Actor.

#### Can I search different countries?

Yes. Use the `country`, `gl`, and `hl` parameters to control country and language targeting.

#### Does it support pagination?

Yes. Use the `page` parameter to request pages 1–10.

#### Does it extract Knowledge Panel data?

Yes, when Google returns a Knowledge Panel for the query and `include_knowledge_panel` is enabled.

#### Can I disable Knowledge Panel extraction?

Yes:

```json
{
  "include_knowledge_panel": false
}
```

#### Does it return related Google searches?

Yes. Related keywords are returned when available and when `include_related_keywords` is enabled.

#### Can I export the results?

Yes. Results are stored in the Apify Dataset and can be exported using the formats supported by Apify.

#### Can I use it through an API?

Yes. The Actor can be started and its dataset retrieved programmatically using the standard Apify API.

***

### 🏁 Start Searching

Enter your query, choose your country and language if needed, and run the Actor.

**Easy Google Search Results Scraper** handles the search and returns clean, structured data ready for your next workflow.

**Fast. Simple. Structured Google Search data — from $0.13 per 1,000 results.**

# Actor input Schema

## `query` (type: `string`):

Enter your search query (e.g., 'doctor california', 'best restaurants nyc')

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

ISO country code for search results (e.g., 'us', 'uk', 'de')

## `gl` (type: `string`):

Geolocation for search results (e.g., 'US', 'DE', 'IN')

## `hl` (type: `string`):

Language code for search interface and results (e.g., 'en', 'de', 'fr')

## `page` (type: `integer`):

Page number for pagination (1 = first page)

## `include_knowledge_panel` (type: `boolean`):

If ON, output all available Knowledge Panel data (including KP info). If OFF, output none.

## `include_related_keywords` (type: `boolean`):

If ON, output related keywords. If OFF, output none.

## Actor input object example

```json
{
  "query": "doctor california",
  "country": "us",
  "gl": "US",
  "hl": "en",
  "page": 1,
  "include_knowledge_panel": true,
  "include_related_keywords": true
}
```

# Actor output Schema

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

Organic Google Search results including title, snippet, URL, position, search query, and page.

## `relatedKeywords` (type: `string`):

Related Google search keywords and spelling suggestions returned for the search query.

## `knowledgePanel` (type: `string`):

Google Knowledge Panel information returned for the search query, when available.

## `metadata` (type: `string`):

Search metadata including result count, page, country, language, and pagination information.

# 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 = {
    "query": "doctor california",
    "country": "us",
    "gl": "US",
    "hl": "en",
    "page": 1,
    "include_knowledge_panel": true,
    "include_related_keywords": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results").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 = {
    "query": "doctor california",
    "country": "us",
    "gl": "US",
    "hl": "en",
    "page": 1,
    "include_knowledge_panel": True,
    "include_related_keywords": True,
}

# Run the Actor and wait for it to finish
run = client.actor("xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results").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 '{
  "query": "doctor california",
  "country": "us",
  "gl": "US",
  "hl": "en",
  "page": 1,
  "include_knowledge_panel": true,
  "include_related_keywords": true
}' |
apify call xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,xmiso_scrapers/easy-google-search-results-scraper---from-0-10-1000-results"
        }
    }
}
```

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/zpJrBwg77g4tn6YrP/builds/2fpCLr9SED4x6Ys4K/openapi.json