Migrate from Serper.dev to Litescrape in one line

01 / configuration

Change the base URL and key

If your product reads SERPER_BASE_URL and appends /search, set the base URL to https://api.litescrape.com. Put your Litescrape key in SERPER_API_KEY. Keep /search out of the base URL so the client does not append it twice.

1export SERPER_BASE_URL="https://api.litescrape.com" SERPER_API_KEY="ls_live_your_litescrape_key"

An environment variable only works when your client reads it. If your integration hardcodes https://google.serper.dev/search, change that full URL to https://api.litescrape.com/search. If it exposes a full endpoint setting, use the full URL there too. A Serper-issued key will not work on Litescrape.

1curl 'https://google.serper.dev/search' \2  --header "X-API-KEY: $SERPER_API_KEY" \3  --header 'Content-Type: application/json' \4  --data '{"q":"coffee grinders","num":5,"gl":"us","hl":"en"}'

The route also accepts Authorization: Bearer with a Litescrape key. When both authentication headers are present, X-API-KEY takes precedence. Keep keys in headers; keys in the URL or JSON body are not supported.

02 / runnable client

Keep the code that reads organic results

Save this file as serper_migration.py. It needs Python 3.10 or newer and httpx, reads the two settings above, and raises an HTTP error for unsuccessful responses. The server handles the field conversion.

1"""Call Litescrape's Serper-compatible web-search route.
2
3Requires Python 3.10+ and httpx. Set SERPER_BASE_URL and SERPER_API_KEY.
4The key must be issued by Litescrape when using api.litescrape.com.
5
6    python serper_migration.py "coffee grinders" --num 5 --gl us --hl en
7"""
8
9from __future__ import annotations
10
11import argparse
12import json
13import os
14from typing import Any
15
16import httpx
17
18
19def search(query: str, **parameters: Any) -> dict[str, Any]:
20    base_url = os.environ["SERPER_BASE_URL"].rstrip("/")
21    response = httpx.post(
22        f"{base_url}/search",
23        headers={"X-API-KEY": os.environ["SERPER_API_KEY"]},
24        json={"q": query, **parameters},
25        timeout=90.0,
26    )
27    response.raise_for_status()
28    return response.json()
29
30
31def main() -> None:
32    parser = argparse.ArgumentParser(description=__doc__)
33    parser.add_argument("query")
34    parser.add_argument("--num", type=int, default=10)
35    parser.add_argument("--page", type=int, default=1)
36    parser.add_argument("--gl", default="us")
37    parser.add_argument("--hl", default="en")
38    parser.add_argument("--location")
39    args = parser.parse_args()
40    parameters = {
41        name: value
42        for name, value in vars(args).items()
43        if name != "query" and value is not None
44    }
45    print(json.dumps(search(args.query, **parameters), indent=2, ensure_ascii=False))
46
47
48if __name__ == "__main__":
49    main()

1python -m pip install httpx2python serper_migration.py "coffee grinders" --num 5 --gl us --hl en

Your existing loop over result["organic"] can stay in place for the mapped fields. This is an illustrative response showing the JSON structure, not a captured search result or a guarantee of how many rows Google will return.

1{2  "searchParameters": {3    "q": "coffee grinders",4    "gl": "us",5    "hl": "en",6    "num": 5,7    "page": 1,8    "autocorrect": true,9    "type": "search",10    "engine": "google"11  },12  "organic": [13    {14      "title": "Example coffee grinder guide",15      "link": "https://example.com/coffee-grinders",16      "snippet": "An illustrative result showing the supported field names.",17      "position": 118    }19  ],20  "credits": 121}

03 / parameters

The supported request fields

POST /search accepts one JSON object, or query-string parameters with an empty body. GET /search accepts the same query-string fields. When a field appears in both the query string and JSON body, the JSON value wins.

Use JSON numbers for num and page, and a JSON boolean for autocorrect. Query strings use decimal numbers and true or false. Optional null values are treated as omitted. Unknown fields, repeated query-string fields and malformed JSON are rejected before billing. The JSON body limit is 16 KiB.

04 / response

What your parser receives

Successful responses always contain searchParameters, organic and credits: 1. The parameters show the effective values, including defaults. organic can be empty. Other modules depend on what Google supplies and which fields are mapped into the response.

Read optional modules defensively, for example result.get("peopleAlsoAsk", []). Native search_metadata, native pagination and modules outside this map are not part of the compatibility response. Use the native API reference if your application needs Litescrape's full response format.

05 / limits

Keep page size fixed while paging

With num=10, pages 1, 2 and 3 request native offsets 0, 10 and 20. With num=5, page 2 requests offset 5. Changing num midway changes the offset calculation and can introduce gaps or overlap.

1from serper_migration import search2 3# page=2, num=10 maps to Google's start=10.4result = search("coffee grinders", num=10, page=2, gl="us", hl="en")5for item in result["organic"]:6    print(item["position"], item["title"], item["link"])

Positions restart at 1 on each returned page. Google can return fewer rows than num; a short page alone is not a reliable end-of-results signal. Set a page budget and deduplicate links if you collect several pages. The endpoint does not return a next-page token or promise access to an unlimited result set.

Send individual requests for multiple queries. JSON array batches are rejected, and changing type does not turn this route into another Serper endpoint. Maps, reviews, shopping and other Litescrape products have their own native routes and response contracts.

06 / operations

Check the HTTP status before parsing organic

Errors use {"message":"The API key is invalid.","statusCode":401}. The HTTP status is authoritative. X-Request-ID and applicable Retry-After headers are preserved.

Each successful request consumes one Litescrape call, including a successful response with an empty organic array. Authentication and validation failures consume none; worker, rendering and deadline failures refund the reservation. The response's credits: 1 is the cost of that successful request, not your remaining balance.

These requests share your key's balance and concurrency allowance with native endpoints. Check GET /api/keys/status with Authorization: Bearer for remaining_calls and concurrency_limit. That status request consumes no call. The default configured concurrency is 25; this counts requests in flight, not requests per second.

07 / pricing

$0.15 per 1,000 successful searches

Serper's published prepaid rates, checked September 19, 2026, depend on the pack size. The table compares unit rates; the pack price is the upfront Serper purchase needed for that rate.

At the Starter unit rate, Litescrape costs 85% less per search. Against Ultimate's unit rate, it costs 50% less. One million successful Litescrape requests consume $150 of credits. These comparisons exclude taxes and free trial allowances.

Litescrape starts with 10 free calls and paid top-ups from $10. Credits last six months from each top-up. See Litescrape pricing for the purchase terms and current rates.

08 / questions

FAQ

Can I keep my existing Serper API key?

Keep the setting name, but replace its value with a Litescrape-issued key. A Serper-issued key cannot authenticate with Litescrape.

Is changing SERPER_BASE_URL enough?

Only if your client reads that setting and appends /search. Set it to https://api.litescrape.com and replace the key. Clients with a hardcoded URL need that URL changed explicitly.

Will my organic result parser still work?

The response includes organic with title, link, snippet and page-local position when the source supplies those fields. Check any rich modules or extra fields your application uses against the response map.

Does this endpoint support Serper batches, Images, News or Places?

No. It accepts one Google web-search query per request on /search. Array batches and other Serper paths are outside its scope. Other Litescrape endpoints use their native request and response formats.

Does Litescrape forward my request to Serper?

No. The compatibility route uses Litescrape's Google Search worker and translates the response into the supported Serper fields.

Are the rankings and rich results identical?

No identical-ranking guarantee is made. Google chooses the results and modules for each request. This endpoint returns the fields listed in the response map.