# SERP API | Search Engine Results Scraper | From $0.50/1K Pages (`curly/simple-serp-api`) Actor

SERP scraper with paid plans from $0.50 per 1,000 successful pages. Page events are charged only for pages that load and parse successfully. Get titles, URLs, snippets, sitelinks, related searches, and news with country, recency, and page-depth filters. Run via API or schedules.

- **URL**: https://apify.com/curly/simple-serp-api.md
- **Developed by:** [Curly](https://apify.com/curly) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 successful search result pages

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?

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

## SERP API | Search Engine Results Scraper | From $0.50/1K Pages

Run one web query and turn up to five search result pages into structured JSON through Apify. Paid plans start at **$0.50 per 1,000 successfully loaded pages**; Free-plan users pay **$0.70 per 1,000**. Beyond the small Actor-start fee, page events are charged only when a page loads and parses successfully. Undelivered pages are not charged.

Get ranked titles, URLs, snippets, result types, domains, positions, favicons, sitelinks, related searches, and relevant news when available. Target a country or recency window, then use the dataset through the API, schedules, webhooks, and integrations. No search-engine account, cookies, browser extension, or proxy setup is required.

### Why use this SERP scraper?

- **Low pay-per-page pricing:** paid plans start at $0.50 per 1,000 successfully loaded result pages; the Free-plan rate is $0.70 per 1,000.
- **Pay only for delivered pages:** beyond the Actor-start fee, unavailable or undelivered result pages do not create page charges.
- **Core SERP data in one dataset:** get titles, URLs, snippets, result types, domains, positions, favicons, sitelinks, related searches, and news when surfaced.
- **Country, recency, and depth controls:** target a supported country, choose a recent time window, and request one to five result pages.
- **Automation ready:** call the SERP API, schedule recurring searches, trigger webhooks, connect integrations, or export reusable datasets.
- **No account or cookies:** run searches without a search-engine account, connected browser session, cookies, extension, or proxy configuration.

Need only a quick one-off search? Use Curly's [free LLM web search tool](https://trycurly.xyz/llm-web-search-api) in your browser. Use this Actor for API access, scheduled searches, webhooks, integrations, and reusable datasets.

### How to use it

1. Enter one search query of up to 200 characters.
2. Optionally select a country, recency window, and number of result pages.
3. Click **Start**.
4. Open **Dataset** to view or download the result as JSON, CSV, Excel, XML, or another supported format.

Only the query is required:

```json
{
  "query": "site:openai.com API documentation",
  "country": "de",
  "time": "month",
  "pages": 2
}
```

| Field | Required | What it does |
| --- | --- | --- |
| `query` | Yes | One non-empty web search query, up to 200 characters. Search operators such as quotes and `site:` are supported. |
| `country` | No | Targets one supported country. Leave empty to use the default search region. |
| `time` | No | Limits results to the past `day`, `week`, `month`, or `year`. Leave empty for any time. |
| `pages` | No | Requests `1` to `5` result pages. Default: `1`. More pages can increase run time. |

Supported country codes:

`ar`, `at`, `au`, `be`, `br`, `ca`, `ch`, `cn`, `de`, `dk`, `es`, `fi`, `fr`, `gb`, `gr`, `ie`, `il`, `in`, `it`, `jp`, `kr`, `mx`, `nl`, `no`, `nz`, `pl`, `pt`, `ru`, `se`, `sg`, `tr`, `us`, `za`.

The Apify Console displays country names. API requests use the lowercase codes shown above. The Actor accepts exactly one query per run and only the documented input fields.

### What search data can you extract?

The Actor returns:

- The submitted query, the requested region and recency, and the number of result pages returned
- Ordered result titles, absolute URLs, snippets, result types, domains, and positions
- Organic and advertisement result classification through `kind`
- Favicons derived from each result's domain
- Sitelinks with titles, URLs, and snippets when surfaced under a result
- Related search phrases when available
- Relevant news headlines, article URLs, sources, and relative publication times when available

Optional values remain `null` when they are not surfaced. The Actor does not invent missing snippets, sitelinks, related searches, favicons, or news.

### Example output

Each successful query produces one dataset item:

#### Example result

```json
{
  "query": "site:openai.com API documentation",
  "country": "de",
  "time": "month",
  "pages": 1,
  "results": [
    {
      "title": "API Documentation - OpenAI API",
      "url": "https://platform.openai.com/docs/",
      "snippet": "Explore the OpenAI API documentation, guides, and examples.",
      "kind": "organic",
      "domain": "platform.openai.com",
      "favicon": "https://platform.openai.com/favicon.ico",
      "sublinks": [
        {
          "title": "API Reference",
          "url": "https://platform.openai.com/docs/api-reference",
          "snippet": "Complete reference for every endpoint and parameter."
        },
        {
          "title": "Guides",
          "url": "https://platform.openai.com/docs/guides",
          "snippet": "Step-by-step guides for building with the API."
        }
      ],
      "position": 1
    },
    {
      "title": "OpenAI API",
      "url": "https://openai.com/api/",
      "snippet": null,
      "kind": "organic",
      "domain": "openai.com",
      "favicon": "https://openai.com/favicon.ico",
      "sublinks": null,
      "position": 2
    }
  ],
  "relatedSearches": [
    "OpenAI API",
    "OpenAI documentation",
    "ChatGPT API"
  ],
  "news": [
    {
      "title": "OpenAI unveils a faster API platform",
      "url": "https://openai.com/index/faster-api-platform/",
      "source": "OpenAI",
      "published": "2 hours ago"
    }
  ]
}
```

The `results` array preserves result order. A completed search with no listings still stores a dataset item with an empty `results` array. The returned `pages` value shows how many result pages were successfully loaded and parsed.

### SERP API pricing

The Actor uses pay-per-event pricing with two parts:

| Charge | Free plan | Paying plans |
| --- | ---: | ---: |
| Actor start | $0.001 per run | $0.0006 per run |
| Successfully loaded result page | $0.0007 per page | $0.0005 per page |

Paid plans start at $0.50 per 1,000 successfully loaded result pages; the Free-plan rate is $0.70 per 1,000. The small Actor-start charge applies once when a run starts. Page events are charged only for result pages that load and parse successfully. A successfully parsed page is billable even when it contains no listings; requested pages that cannot be delivered are not charged. Individual links inside the `results` array are never separate billing events.

An invalid, unavailable, or rate-limited run can still incur the Actor-start charge, but it emits no page events. If a later page becomes unavailable, the run completes with the earlier pages and charges only those successfully delivered pages. The Apify Store shows the applicable prices and maximum run cost before a run starts.

Free-plan users can submit one accepted run every 12 hours. Paying Apify users are not subject to this product limit.

### Run through the API

Run the Actor synchronously and receive the stored dataset item:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/curly~simple-serp-api/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  --data '{"query":"site:openai.com API documentation","country":"de","time":"month","pages":2}'
```

The same input works with the Apify API client, JavaScript and Python clients, schedules, webhooks, and integrations. Never place a real Apify token in public code or client-side applications.

For an interactive request builder and JavaScript and Python examples, see the [Curly AI Web Search API documentation](https://trycurly.xyz/ai-web-search-api). For a one page browser test without an account, use the [free LLM web search tool](https://trycurly.xyz/llm-web-search-api).

### Common use cases

- Give AI agents and RAG pipelines current web sources with titles, snippets, and URLs
- Research topics, companies, products, competitors, or markets
- Monitor brand mentions and relevant news through scheduled searches
- Inspect ranked pages, domains, sitelinks, and related searches for SEO research
- Export search results to spreadsheets, databases, dashboards, or internal tools
- Trigger downstream workflows through the Apify API, schedules, webhooks, or integrations

### Limitations

- Each run accepts one query of up to 200 characters and requests up to five result pages.
- The number and composition of results vary by query, region, recency filter, and availability.
- Country targeting influences regional results but does not guarantee that every returned page is hosted in that country.
- Snippets, favicons, sitelinks, related searches, and news are optional and can be `null`.
- News is returned only when surfaced for the query. It is not a complete news feed.
- `news[].published` contains relative text such as `5 hours ago`, not a normalized timestamp.
- Search positions and page availability can change between runs.

### Responsible use

You are responsible for using the Actor and its output in accordance with applicable laws, privacy requirements, copyright rules, contractual obligations, and website terms. Do not use the results for spam, harassment, surveillance, or other unlawful purposes.

### FAQ

#### How much does this SERP API cost?

Paid plans cost $0.50 per 1,000 successfully loaded result pages, and the Free-plan rate is $0.70 per 1,000. Each run also has a small Actor-start charge: $0.0006 on paid plans or $0.001 on the Free plan.

#### What counts as a successful result page?

A page is successful when it loads and parses into the Actor's structured output. A successfully parsed page is billable even when its `results` array is empty. Unavailable or undelivered pages do not create page charges.

#### What data does the SERP scraper return?

The dataset includes ordered titles, URLs, snippets, result types, domains, positions, favicons, sitelinks, related searches, and relevant news when those fields are surfaced for the query.

#### Do I need a search-engine account or cookies?

No. The Actor does not require search-engine credentials, cookies, or a connected browser session.

#### How many queries and result pages can I request?

Each run accepts one query and one to five result pages. The number of listings returned can be lower because result availability varies.

#### Can I target a country or recent results?

Yes. Select one supported country and/or limit results to the past day, week, month, or year. Leave either filter empty to use the default region or any time.

#### Why did the Actor return fewer results than expected?

The `pages` input controls how many result pages the Actor requests, not a fixed listing count. Some queries or filters expose fewer pages or fewer listings.

#### Why are related searches, news, sitelinks, or snippets missing?

Those values are returned only when they are surfaced for the query. Missing optional values remain `null` rather than being inferred.

#### What happens when no results are found?

A valid search completes normally and stores a dataset item with an empty `results` array. An unavailable or rate-limited query does not create a dataset item.

#### How does billing work?

Each run has one small Actor-start charge. The Actor then charges one page event for every result page successfully loaded and parsed. Empty but successfully parsed result pages are billable; unavailable pages and individual links are not. If only part of the requested pagination succeeds, the Actor returns and charges only the completed pages.

#### Can I automate the SERP API?

Yes. Run it through the Apify API or JavaScript and Python clients, schedule recurring searches, trigger webhooks, connect integrations, and export datasets in supported formats.

### Support

For questions, missing fields, or unexpected results, contact <hello@trycurly.xyz>.

# Actor input Schema

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

The web search query to run. Search operators such as quotes and site: are supported.

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

Target regional results for a specific country.

## `time` (type: `string`):

Only show results from a recent window: the past day, week, month, or year.

## `pages` (type: `integer`):

How many result pages to request (1-5). Successfully delivered pages are billed individually, and more pages can increase run time.

## Actor input object example

```json
{
  "query": "openai software",
  "pages": 1
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

## `failedQueries` (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 = {
    "query": "openai software"
};

// Run the Actor and wait for it to finish
const run = await client.actor("curly/simple-serp-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "openai software" }

# Run the Actor and wait for it to finish
run = client.actor("curly/simple-serp-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "openai software"
}' |
apify call curly/simple-serp-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,curly/simple-serp-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/4oKvRtHXnprlHeip1/builds/KN4gSY5PgPx9HOU7M/openapi.json