EN
Bulk SERP API

Bulk SERP API for large-scale Google data collection

Queue a million Google searches in minutes, then let Semscraper collect them. Up to 1,000 keywords per API call, asynchronous processing, signed callbacks and free retrieval of every result.

  • 1,000 keywords per call
  • Async with signed callbacks
  • About €30 per 100,000 SERPs
  • 1000 free requests
  • No credit card
100,000 Google SERPs for about €30. First page of results (about 10 results per keyword), at the standard rate before the 1 to 10% discount on top-ups. Only pages Google actually returns are billed, and fetching results is free.

Queue 1 million Google searches in minutes

Submit up to 1,000 keywords per API call, with up to 500 calls per minute, without waiting for previous batches to complete. Your requests are queued immediately and processed progressively as capacity becomes available. Submission capacity is not processing throughput: actual completion times depend on queue load and available capacity, which we expand as demand grows.

1. Send

Batches of 1,000 keywords, as many calls as you need. Each keyword carries its own country, language, city, device and depth.

2. We collect

Every SERP is rendered in a real browser. Each account has its own queue, accounts are served in turn, and a priority from 1 to 10 orders your own requests.

3. Receive

Each result is posted to your callback URL as soon as it is ready, or you fetch the finished results in batches whenever you like.

Built for production volume

What a team running tens of thousands of searches a day actually needs.

Signed callbacks

Every callback carries an HMAC SHA-256 signature of its body in the X-Signature header, computed with the key from your API keys menu.

Nothing lost, nothing paid twice

Finished results that were never fetched stay available and can be listed in one call. Fetching results is free and can be repeated: only creating a search is billed.

Full SERPs, up to 10 pages

Organic results with rank and pixel position, AI Overviews, ads, local pack and every other block, in JSON or HTML. See the Google Search API for the full list.

What it costs at scale

Pay per SERP, no subscription. Your balance never expires.

SERPsPage 1 (about 10 results)10 pages (about 100 results)
10,000€3.00€21.00
100,000€30.00€210.00
1,000,000€300.00€2,100.00

Standard rate, before the 1 to 10% discount on top-ups. If Google returns fewer pages than requested, only the pages found are billed. Detailed pricing.

A working example, tested

Python: queue a keyword list, verify the callbacks, then catch up on anything your server missed. Run against the live API on 9 October 2026: callbacks received with valid signatures, catch-up loop run twice with nothing left on the second pass, and no charge for fetching.

1. Queue every keyword
import requests

API = "https://api.semscraper.com/v1/serp"
HEADERS = {"Authorization": "Bearer API_KEY"}

keywords = open("keywords.txt").read().splitlines()  # e.g. 10,000 keywords

# 1,000 keywords per call, without waiting for the previous batch
for i in range(0, len(keywords), 1000):
    batch = [{
        "search_engine": "google_search",
        "keyword": kw,
        "device": "desktop",
        "location": "en",
        "language": "en",
        "depth": 1,
        "callback_url": "https://your-server.com/serp-callback",
    } for kw in keywords[i:i + 1000]]
    r = requests.post(API, json=batch, headers=HEADERS, timeout=60)
    r.raise_for_status()
    print(r.json()["count"], "keywords queued")
2. Receive and verify each callback (Flask)
import hashlib, hmac, json
from flask import Flask, request

SECRET = b"hmac_..."  # HMAC key from your API keys menu
app = Flask(__name__)

@app.post("/serp-callback")
def serp_callback():
    raw = request.get_data()
    expected = hmac.new(SECRET, raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get("X-Signature", "")):
        return "Invalid signature", 401
    for serp in json.loads(raw):  # a list holding the finished SERP
        save(serp)                # your own storage
    return {"status": "ok"}       # anything but 200 leaves it unfetched
3. Catch up on anything missed
# finished results that were never fetched, up to 1,000 per call
while True:
    pending = requests.get(API, headers=HEADERS, timeout=60).json().get("data", [])
    if not pending:
        break
    ids = [p["id"] for p in pending]
    for i in range(0, len(ids), 100):
        r = requests.get(API, headers=HEADERS, timeout=60,
                         params={"ids": ",".join(ids[i:i + 100]), "output": "json"})
        for serp in r.json()["data"]:
            save(serp)  # fetching marks it as fetched, and is never billed

Measured on 958,176 SERPs

For our AI Overviews study, we queued close to a million French keywords on 12 September 2026. All 958,176 SERPs were collected and retrieved within 4 hours 23 minutes of the first request, with zero errors. The busiest hour delivered 237,043 SERPs. This is a real collection on our own account, not a guaranteed throughput: completion time depends on depth, the number of requests waiting and available capacity.

958,176

one-page SERPs collected and retrieved, with zero errors.

4 h 23

from the first request to the last result.

237,043

SERPs in the busiest hour of the run.

What to expect

TopicHow it works
One SERP vs a whole batchA single SERP takes about thirty seconds in median, about a minute for 10 pages, because it is rendered in a real browser. Many robots work in parallel, so a batch is processed progressively and finishes far sooner than the sum of its SERPs.
CapacityOur robot fleet grows with demand: we add capacity as volumes increase. If you plan recurring very large volumes, tell us ahead and we will size it for you.
Callback deliveryEach result is posted once. If your endpoint does not answer HTTP 200, the result simply stays unfetched and the catch-up loop picks it up.
Fetching by IDUp to 100 IDs per call. For large volumes, rely on callbacks or on the list of finished, unfetched results (up to 1,000 per call).
Real timeBuilt for collection at scale, not for answering a chatbot in the moment. For AI datasets and agents, see the SERP API for AI.
FAQ

Frequently asked questions

How many keywords can I send at once?
Up to 1,000 per call and up to 500 calls per minute. There is no need to wait for a batch to finish before sending the next one: everything is queued immediately and processed progressively.
What happens if my callback endpoint was down?
Nothing is lost. A callback that does not get an HTTP 200 leaves the result unfetched. Calling GET /v1/serp without IDs lists up to 1,000 finished, unfetched results, which you then fetch by ID. Fetching is never billed.
How do I verify that a callback comes from Semscraper?
Compute an HMAC SHA-256 of the raw request body with the HMAC key shown in your API keys menu (it starts with hmac_), and compare it with the X-Signature header using a constant-time comparison.
Can one batch mix countries, devices and depths?
Yes. Each item of the batch has its own location, language, geolocation, device, depth and priority. One rule: a keyword must not contain a comma, as it would be split into two searches.
How long will 100,000 SERPs take?
We do not guarantee a duration: it depends on depth and on the load of the queue when you submit. As a reference, our own run of 958,176 one-page SERPs completed in 4 hours 23 minutes. Our infrastructure scales with demand: for recurring very large volumes, contact us beforehand and we will add the capacity you need.

Start with your own keyword list

1,000 free requests, no credit card required.