Technical Research & API Benchmark

SearchApi vs. SerpApi: A Reproducible Google Search API Benchmark

I compared SearchApi and SerpApi using the same Google Search workload. I measured latency, success rate, payload size, organic-result count, and result overlap. The benchmark code and raw data behind every reported number are included.

View benchmark.py View analyze.py View raw CSV

Key result

Across 50 requests per provider, SearchApi recorded a median response time of 4.24 seconds, compared with 8.42 seconds for SerpApi. That is 49.7% lower median latency in this benchmark.

This is a result from one controlled workload, not a claim that one provider is universally faster.

Results

Metric	SearchApi	SerpApi
Requests	50	50
Success rate	100%	100%
Median latency	4.24 s	8.42 s
Mean latency	5.20 s	12.38 s
P95 latency	11.77 s	35.44 s
Minimum latency	2.03 s	1.38 s
Maximum latency	25.53 s	45.88 s
Mean organic results	8.02	7.92
Mean payload	75.0 KiB	80.5 KiB

SearchApi had the lower per-query median latency for 9 of 10 queries. The exception was iphone 17 review, where SerpApi had the lower median latency.

The paired responses shared an average of 6.42 organic URLs, with a mean Jaccard similarity of 71.4%. The overlap helps show that the latency comparison is based on substantially comparable result sets.

Methodology

I used 10 queries covering software, programming, weather, consumer products, travel, local search, automotive, AI, and shopping.

• Ran each query five times against each provider.
• Collected 50 measurements per provider and 100 measurements in total.
• Used Google Search with gl=us and hl=en for both providers.
• Used no_cache=true for SerpApi requests.
• Alternated provider order between runs to reduce systematic bias from always testing one provider first.
• Waited two seconds between requests.
• Ran all requests sequentially from the same client machine.
• Measured end-to-end latency with Python time.perf_counter() around the complete HTTP request.
• Recorded every measurement immediately in the raw CSV, including HTTP status, response time, payload size, organic-result count, returned organic URLs, and any error.

Query set

The exact workload is available in queries.txt.

What I measured

• Median latency as the primary latency statistic because it is less sensitive to extreme requests than the mean.
• Mean and P95 latency to expose overall cost and long-tail behavior.
• Success rate from HTTP status codes.
• Payload size from the raw HTTP response body.
• Organic-result count from each provider's organic_results.
• Result overlap using matching organic URLs and Jaccard similarity for each paired query/run.

Interpretation

The clearest difference was latency. SearchApi's median was roughly half SerpApi's in this run. Its P95 latency was 11.77 seconds, compared with 35.44 seconds for SerpApi. Both providers completed all measured requests successfully.

The result was not uniform. SerpApi produced the faster individual minimum request, and it had the lower median for one of the ten queries. The raw data also contains substantial latency outliers, which is why I report median and P95 rather than relying on a single request or only the arithmetic mean.

Organic-result counts were close on average. URL overlap was substantial but not perfect, so the providers should not be treated as returning identical SERPs.

Limitations

This benchmark is intentionally small. It was run from one client location, during one measurement session, against 10 queries and 50 requests per provider. Network path, provider load, Google result changes, account configuration, query mix, and time of day can all affect results.

The test measures end-to-end client-observed response time, not server processing time. It also does not evaluate every SERP feature, result quality, pricing, throughput under concurrency, or behavior across countries and search engines.

For those reasons, the results support the narrower statement that SearchApi showed 49.7% lower median latency for this workload and test session, not that it is universally 49.7% faster.

Reproduce the benchmark

1. Install Python 3.
2. Install dependencies with python -m pip install -r requirements.txt.
3. Copy .env.example to .env and add valid SearchApi and SerpApi API keys.
4. Run python benchmark.py.
5. Run python analyze.py to calculate the summary metrics from the generated CSV.

Running benchmark.py performs 50 requests against each provider, so API quotas should be checked before reproducing the full test.

Research files

• benchmark.py — runs the controlled benchmark and records every request.
• analyze.py — calculates summary and overlap metrics directly from the raw data.
• queries.txt — exact query workload.
• benchmark_results.csv — raw dataset from the reported run.
• requirements.txt — Python dependencies.

Raw data

The reported measurements are preserved as raw benchmark output rather than manually edited.