DEV Community: SerpKite

Cheaper alternatives to the Google Search API in 2026

SerpKite — Thu, 29 Oct 2026 20:49:23 +0000

We build SerpKite, one of the alternatives below. Prices come from each vendor's public pricing page, checked October 25–29, 2026, and the links let you check them yourself.

Google sells two ways to get its search results into code. The Custom Search JSON API costs $5 per 1,000 queries and stops working on January 1, 2027. Grounding with Google Search costs $14 per 1,000 requests and only hands results to a Gemini model. SERP APIs return the same public results page for $0.30 to $7.25 per 1,000.

Google's own options

Option	Price	Free	Limits	Status
Custom Search JSON API	$5 per 1,000 queries	100 queries a day	10,000 queries a day	Closed to new customers since January 20, 2026; shuts down January 1, 2027
Grounding with Google Search (Gemini API)	$14 per 1,000 requests	5,000 a month	1,500 requests a day per project	Available; returns a Gemini answer with sources, not a results list

The Custom Search cap matters at volume: 10,000 a day tops out near 300,000 a month, so a million searches a month can't fit. Grounding's daily cap on the Gemini API stops you at about 45,000 a month; Google points heavier users to Vertex AI, which has a higher quota.

Grounding also changes what you get back. You send a prompt, Gemini decides whether to search, and you receive an answer with citations. A rank tracker, an SEO tool or an agent with its own model needs the result list itself.

What 100k and 1M searches a month cost

List prices for a Google web search of 10 results. The 100k column uses each vendor's price at that volume; the 1M column uses its 1M price.

Option	$ per 1k at 100k	100k / month	1M / month	Results from
Grounding with Google Search	$14.00	Over the daily cap	Over the daily cap	Google, through Gemini
SerpApi	$7.25	$725	$3,750	Google
Custom Search JSON API	$5.00	$485	Over the daily cap	Google (Programmable Search Engine)
Brave Search API	$5.00	$500	$5,000	Brave's own index
SearchApi	$2.50	$250	$1,500	Google
Bright Data	$1.31	$131	$1,110	Google
Oxylabs	$0.90	$90	$700	Google
Serper	$0.75	$75	$500	Google
SerpKite	$0.60	$60	$600 ($300 in the batch lane)	Google
DataForSEO (Standard queue)	$0.60	$60	$600	Google
HasData	$0.50	$50	$350	Google
Scrapingdog	$0.45	$45	$290	Google

The Custom Search figure subtracts the 3,000 free queries a month (100 a day). At 100k a month, every Google-backed API in the table except SerpApi costs less than Custom Search, and Scrapingdog costs a tenth of it.

The cheapest list price is not always the cheapest invoice. Check three rules before you pick:

Credit expiry. Serper's credits expire after 6 months. SerpApi, HasData, Oxylabs, Bright Data and Scrapingdog's Lite plan reset monthly. SerpKite and DataForSEO never expire credits, so a $300 SerpKite pack covers 500,000 searches whether you use them in one month or in ten.
Failed and empty searches. SerpApi, SearchApi and Scrapingdog don't bill failed requests. SerpKite also refunds empty results, including a 200 response with no organic results. Ask the other vendors.
Minimum purchase. Serper's cheapest pack is $50 and SerpKite's is $10. If you run 3,000 searches a month, the minimum decides your price more than the per-1k rate does.

Cheaper than SerpApi

SerpApi charges $25 for 1,000 searches on its Starter plan and $7.25 per 1,000 at 100k a month. If you are leaving SerpApi over price, the other Google-backed APIs in the table cost $45 to $250 at 100k a month against SerpApi's $725.

You give up some things when you leave. SerpApi covers dozens of engines, ships 11 official SDKs, holds an SOC 2 report and offers a $2M legal shield. SearchApi also offers the shield. If your legal team requires one, compare those two first; neither Serper, Scrapingdog nor SerpKite offers one.

Moving off the Custom Search JSON API

If your code calls googleapis.com/customsearch/v1, you can keep its request and response. SerpKite serves the same shape at /customsearch/v1: items[], searchInformation and queries, with start, num, gl, hl, lr, safe, dateRestrict, siteSearch and searchType=image.

Google:

res = requests.get(
    "https://www.googleapis.com/customsearch/v1",
    params={"key": GOOGLE_API_KEY, "cx": CX, "q": query},
)
items = res.json().get("items", [])

SerpKite:

res = requests.get(
    "https://api.serpkite.com/customsearch/v1",
    params={"key": SERPKITE_API_KEY, "cx": CX, "q": query},
)
items = res.json().get("items", [])

One difference to plan for: SerpKite accepts cx and ignores it, so results come from the whole web. If your Programmable Search Engine searched a list of sites, move that list into the request with siteSearch or site: operators. The migration guide covers the Python, Node and Go client libraries, and the shutdown post has the timeline.

If you switch to a different response shape anyway, compare more than price. Brave runs its own index, so results differ from Google's. Grounding needs Gemini in the loop. A SERP API returns what a person sees on google.com.

Free options

Option	Free searches	Card
Custom Search JSON API	100 a day, until January 1, 2027, existing customers only	Billing account
Grounding with Google Search	5,000 a month on Gemini 3 models	Billing account
Bright Data	5,000 a month	Not stated
Brave Search API	$5 of calls a month (about 1,000)	Required
SerpKite	2,500 on signup + 1,000 a month for verified accounts	No
HasData	1,000 a month	Not stated
Serper	2,500 once	No
SerpApi	250 a month	Not stated
Scrapingdog	100 credits once	No

Where SerpKite is not the cheapest Scrapingdog ($0.45 at 100k, $0.136 at its top tier), HasData ($0.50) and Serper's largest packs ($0.30) list lower prices than our $0.60. Our batch lane gets to $0.30 if your jobs can wait up to 15 minutes. We compete on credits that never expire, free failed and empty searches, Markdown output for LLMs and the drop-in Custom Search endpoint.

FAQ

Is there a free Google Search API? Until January 1, 2027, existing Custom Search customers get 100 free queries a day. New accounts can't sign up. Grounding gives 5,000 free requests a month, as Gemini answers. For a free list of Google results, use a SERP API's free tier from the table above.

What does the Google Search API cost? The Custom Search JSON API costs $5 per 1,000 queries after 100 free a day, up to 10,000 a day. Grounding with Google Search costs $14 per 1,000 requests after 5,000 free a month.

What is the cheapest Google search API? On list price at volume: Scrapingdog, then HasData, Serper's large packs and the DataForSEO Standard queue. Effective price also depends on credit expiry and on whether failed and empty searches count.

More side-by-side numbers: SERP API pricing in 2026, Best SERP APIs in 2026 and the SerpApi alternatives page.

Drafted with AI assistance; the SerpKite team checked every price against the linked vendor pages. Originally published at serpkite.com.

SERP API pricing in 2026: 1,000 Google searches on 10 APIs

SerpKite — Thu, 29 Oct 2026 20:49:19 +0000

We build SerpKite, one of the ten APIs on this page, so read our picks with that in mind. Every price below links to a public pricing page we checked between October 25 and 29, 2026. We measured latency for SerpKite only; for the other nine we quote the vendor or a third-party test and say which.

A rank tracker pulling a million keywords a month and an AI agent making 2,000 searches a day pay different prices on the same API, and the cheapest list price often loses once you count expiring credits and paid failures. For one pick per use case, see Best SERP APIs in 2026.

Quick answer

You need	Start with	Why	Trade-off
The lowest price at 1M+ searches a month	Scrapingdog	$0.136 per 1k at its top list price	Lite credits reset monthly; latency "a few seconds" (vendor)
Cheap Google results below 100k a month	Serper	$0.75 per 1k at 100k, 2,500 free searches	Credits expire after 6 months; JSON only
Rank tracking that can wait a few minutes	DataForSEO (Standard queue)	$0.60 per 1k, credits never expire	About 5 minutes per task; Live mode costs $2.00
Many engines, many SDKs, a legal shield	SerpApi	11 official SDKs, $2M legal shield	$7.25 per 1k at 100k a month, monthly reset
Google results inside an LLM agent	SerpKite	Markdown output, MCP server, failed and empty searches free, credits never expire	$0.60 per 1k at best; Scrapingdog and Serper go lower at volume
SERP data bundled with a proxy network	Bright Data or Oxylabs	One vendor for proxies, unblocking and SERPs	$1.31 and $0.90 per 1k at 100k

If Google's own results don't matter for your use case, skip to APIs with their own index.

Price per 1,000 Google searches

Prices are list prices for a Google web search of 10 results, in US dollars per 1,000 searches, from each vendor's pricing page on October 25, 2026, with Oxylabs, Decodo, Brave and Scrapingdog rechecked on October 29.

API	Free tier	~$50 plan	100k / month	1M / month	Best list price	Credits expire
SerpKite	2,500 on signup + 1,000 a month, no card	$0.80	$0.60	$0.60	$0.60 ($0.30 in the batch lane)	Never
Serper	2,500 once, no card	$1.00	$0.75	$0.50	$0.30	After 6 months
Scrapingdog	100 credits	$1.00	$0.45	$0.29	$0.136	Monthly on Lite; rollover from Standard ($90) up
HasData	1,000 a month	$1.23	$0.50	$0.35	$0.35	Monthly
DataForSEO	$1 trial	$0.60 / $2.00	$0.60 / $2.00	$0.60 / $2.00	$0.60 / $2.00	Never
Oxylabs	$5 credit (~5,000 results)	$1.00	$0.90	$0.70	$0.70 self-serve ($0.50 on Enterprise)	Monthly
Bright Data	5,000 a month	$1.50	$1.31	$1.11	$1.00	Monthly
SearchApi	100 requests	$4.00	$2.50	$1.50	$1.00	Not stated
SerpApi	250 a month	$15–25	$7.25	$3.75	$1.96	Monthly reset

Oxylabs prices Google without JavaScript rendering; with rendering it starts at $1.35. Decodo folded its SERP scraper into a Web Data API priced per crawl ($49 a month for up to 65,000 crawls), so we left it out of the per-search table. DataForSEO's two numbers are its Standard queue (results in about five minutes) and Live mode (seconds). SerpKite's $0.80 and $0.60 come from the $50 Growth and $300 Pro packs; the $10 Starter pack works out to $1.00.

Divide by 1,000 and you get the price of a single search: SerpApi's 100k tier is $0.00725 per call, Scrapingdog's best is $0.000136.

Billing rules that change the bill

Two APIs with the same list price can send you different invoices. Check four rules before you compare totals.

Credit expiry. Say you buy Serper's $50 pack for 50,000 searches and your agent uses 20,000 in six months. You lose the other 30,000, so you paid $2.50 per 1k for what you used. On a monthly plan that resets, every unused search is lost at the end of the month. SerpKite and DataForSEO don't expire credits, so a pack bought in a busy month keeps working through a quiet one.

Failed and empty searches. SerpApi, SearchApi and Scrapingdog don't charge for failed requests. SerpKite refunds failed searches and empty ones, including a 200 response with no organic results. Firecrawl charges for a page that answers 403 or 404, and Perplexity's Search API charges for a successful response with no results. The other vendors don't publish a rule; ask them before you sign up, because an agent that searches rare entities hits empty pages often.

Depth. On September 14, 2025, Google stopped honoring &num=100, so the top 100 now takes ten requests. Per-page vendors charge 10× for it. Serper charges 2 credits for 11–100 results. SerpKite charges 7 credits for num=100, or 3.5 in the batch lane. We wrote up the math in num=100 is gone.

Async discounts. DataForSEO's Standard queue and SerpKite's batch lane both trade a few minutes of waiting for a lower price: $0.60 against $2.00 on DataForSEO, half price on SerpKite. A nightly rank-tracking job can wait.

Speed

API	Latency	Source
SerpKite	p50 1.0 s, p95 1.7 s (60 queries, 12 countries, 60/60 succeeded)	Our benchmark, October 24, 2026
Serper	1–2 s	Vendor
SearchApi	Under 2 s	Vendor
SerpApi	~3 s average, range 0.07–13 s	Vendor
Bright Data	Under 5 s	Vendor
DataForSEO	Live mode up to 6 s; Standard about 5 min	Vendor
Oxylabs	6 s average (sub-second "fast" API)	Vendor
Decodo	~10.7 s	Third-party test

Treat vendor numbers as claims to test. Latency depends on the country, the query and the time of day, so run your own queries from your own region (script below).

Output for LLM agents

If an LLM reads the results, the format costs money twice: once for the search and again for the tokens. On a sample of 60 queries we measured a median of 1,139 tokens for a full JSON results page and 723 for compact output. JSON vs Markdown SERPs has the method.

API	Markdown output	Official MCP server	Page content in the same call
SerpKite	Yes	Yes	`include_content`
SerpApi	Since August 2026	Yes	No
DataForSEO	No	Yes	No
Serper	No	No	Separate endpoint
Scrapingdog	No	No	No

Google also changed result links in 2026: many now go through a /goto redirect. A rank tracker or agent that stores the raw link records Google's URL, not the site. SerpKite and SerpApi return the resolved destination; check the others with a few queries before you build on them. Background: Google /goto links.

The ten APIs in short

SerpKite. Google web search and its verticals (news, images, maps, shopping, scholar and more), AI assistant answers (ChatGPT, Gemini, Copilot, Google AI Mode) and page extraction, with JSON or Markdown output, MCP and SDKs for TypeScript, Python and Go. Pick it for agents and for teams that buy credits in bursts. Skip it if you need a legal shield or SOC 2 today; we offer neither yet.

Serper. Fast, cheap JSON for Google web, images, news and places. Pick it for prototypes and steady traffic under 100k a month. Watch the six-month expiry on larger packs.

Scrapingdog. The lowest top-tier list price we found. Pick it for high-volume jobs where a few seconds per call is fine.

HasData. $0.35 per 1k at volume with 1,000 free searches a month. A good second vendor for failover.

DataForSEO. The rank-tracking workhorse, with dozens of SEO endpoints beyond SERPs. Pick the Standard queue for nightly jobs; Live mode costs more than three times as much.

Oxylabs. A proxy company with a scraper API on top; the $0.50 tier needs an Enterprise contract from $2,500 a month. Pick it if you already buy its proxies and want one invoice. Decodo fits the same profile with per-crawl pricing.

Bright Data. A big proxy network, 5,000 free requests a month and a higher per-search price than the SERP specialists.

SearchApi. Many engines beyond Google, pay-per-success billing and a $2M legal shield. The price drops to $1.00 only at high volume.

SerpApi. The oldest and broadest: dozens of engines, 11 SDKs, a $2M legal shield and an SOC 2 report. You pay for it: $7.25 per 1k at 100k a month.

Not Google: APIs with their own index

These APIs run their own index or an unnamed upstream. Results differ from Google's, which is fine for many agent tasks and wrong for SEO work or anything that has to match what a person sees on google.com.

API	Price per 1k	Free tier	Index
Brave Search API	$5.00 flat	$5 of calls a month (about 1,000 searches), card required	Brave
Tavily	$7.50 entry, $5.00 at 100k	1,000 a month	Own
Exa	$7.00 ($4.00 Lite Search)	$10 a month + $10 on signup	Own
Firecrawl	$7.60 on Hobby to $1.20 on Scale (yearly)	1,000 credits a month	Unnamed
Perplexity Search API	$5.00 ($1.00 Fast Search)	None published	Own

Test before you commit

Fifty of your own queries tell you more than any comparison page, ours included. The script below runs a query list against an API, then prints p50, p95 and how many responses came back empty. Swap the request function to test another vendor.


QUERIES = [line.strip() for line in open("queries.txt") if line.strip()]

def serpkite(q):
    r = requests.get(
        "https://api.serpkite.com/v1/search",
        params={"q": q, "country": "us"},
        headers={"Authorization": f"Bearer {os.environ['SERPKITE_API_KEY']}"},
        timeout=30,
    )
    r.raise_for_status()
    return r.json().get("results", [])

def run(search):
    times, empty, errors = [], 0, 0
    for q in QUERIES:
        t = time.perf_counter()
        try:
            results = search(q)
        except Exception:
            errors += 1
            continue
        times.append(time.perf_counter() - t)
        empty += not results
    times.sort()
    p95 = times[int(len(times) * 0.95) - 1] if times else 0
    print(f"p50 {statistics.median(times):.2f}s  p95 {p95:.2f}s  empty {empty}  errors {errors}")

run(serpkite)

Pick queries from your real workload: brand names, long-tail questions, local searches in the countries you sell to. Compare the top five links against a manual search, and count the empty responses, because some vendors bill them.

Where SerpKite loses Scrapingdog and Serper list lower prices at volume. DataForSEO's Standard queue matches our best price with a longer track record. SerpApi and SearchApi offer a $2M legal shield and SerpApi has SOC 2; we have neither. We launched in 2026, so you get less history to judge us by.

FAQ

Is there a free SERP API? Every vendor above has a free tier. For recurring free searches: SerpKite gives 1,000 a month to verified accounts, HasData 1,000, Bright Data 5,000 and SerpApi 250. Serper's 2,500 come once. Google's own Custom Search JSON API gives 100 a day, but it no longer accepts new customers and shuts down on January 1, 2027 (what to do).

Which SERP API is cheapest? On list price, Scrapingdog ($0.136 per 1k at its top tier) and Serper ($0.30 on its largest pack). Your effective price also depends on expiry and on whether failed and empty searches count.

Do I need Google results, or will Brave or Tavily do? Use Google results when you need to match what users see on google.com: SEO, rank tracking, brand monitoring, local and shopping data. Use an independent index when relevance matters more than Google parity and the price per 1k fits.

See all vendor rows side by side on our comparison pages, or try SerpKite in the playground without a card.

Drafted with AI assistance; the SerpKite team checked every price against the linked vendor pages. Originally published at serpkite.com.

Google Custom Search JSON API ends Jan 1, 2027: what to do

SerpKite — Sat, 24 Oct 2026 22:45:43 +0000

If your app calls https://www.googleapis.com/customsearch/v1, it has a hard deadline. Google closed the Custom Search JSON API to new customers on January 20, 2026, and the API shuts down on January 1, 2027. After that, requests fail.

This post covers the timeline, what your options are, and how to migrate with the smallest possible diff.

Deadline: January 1, 2027. Plan to switch at least two weeks before the deadline, so December change freezes and holidays don't catch you.

The timeline

Date	What happened
2026-01-20	Custom Search JSON API closed to new customers; shutdown date set for 2027-01-01
Aug–Sep 2026	Docs for a partner-only "Web Search Service API" appear, then get pulled
2027-01-01	The JSON API stops serving requests

The partner-only API matters because it was the only hint of an official successor. As of today there is no self-serve official Google web search API you can sign up for after the shutdown.

What breaks on January 1

The shutdown is at the endpoint, so everything that reaches it stops at once:

Direct HTTP calls to https://www.googleapis.com/customsearch/v1, whatever language or tool sends them.
Google's client libraries, which call the same endpoint: Python's googleapiclient.discovery.build("customsearch", "v1"), the Node googleapis customsearch client, the Go customsearch/v1 package and their equivalents.
No-code flows whose HTTP or "Google Custom Search" nodes point at it (n8n, Make, Zapier, Pipedream).
Plugins and integrations that fetch results as JSON for site search or "related content" features.
API keys and quotas in Google Cloud: the keys stay, but there is nothing left for them to call.

Plan for the calls to fail, not to slow down: add a timeout and an error path now, so a forgotten caller degrades instead of crashing.

Who is affected

Anything that reads items[] from the CSE JSON API:

SaaS features that "search the web" behind the scenes (research assistants, fact-checking, content tools).
Internal tools and scripts, often years old, that nobody remembers owning.
No-code flows in n8n, Make and Zapier that call the endpoint through an HTTP node.
Agent tools that wrap CSE because it was the official, cheap option.

Find them with a code search for googleapis.com/customsearch across your repos, and check your Google Cloud console for projects with the Custom Search API enabled.

Your options

Drop the feature. Sometimes right for internal scripts. Rarely right for customer-facing features.
Move to a different kind of search. AI-native search APIs (Tavily, Exa, Brave) run their own index. Results and response shapes differ, so you rewrite the integration and re-test relevance.
Use a SERP API that speaks CSE. You keep the same request and response, and the results are Google's public results page.

We built SerpKite's /customsearch/v1 endpoint for option 3. It accepts key, cx, q, start, num, gl, hl, lr, safe, dateRestrict, siteSearch and searchType=image, and returns kind, searchInformation, items[] and queries.

The migration

Before (Google):

res = requests.get(
    "https://www.googleapis.com/customsearch/v1",
    params={"key": GOOGLE_API_KEY, "cx": CX, "q": query, "start": 1},
)
items = res.json().get("items", [])

After (SerpKite):

res = requests.get(
    "https://api.serpkite.com/customsearch/v1",
    params={"key": SERPKITE_API_KEY, "cx": CX, "q": query, "start": 1},
)
items = res.json().get("items", [])

Two lines: the hostname and the key. Your parsing code doesn't change.

The one real difference: cx is ignored. SerpKite searches the public Google results page, so settings from the Programmable Search console (site lists, promotions, custom ranking) are not applied. If your engine was restricted to your own domains, add siteSearch=example.com or site:a.com OR site:b.com to the query.

A ten-week plan

When	Do
This week	Search your repos for `googleapis.com/customsearch` and `customsearch`, and list every Google Cloud project with the Custom Search API enabled
Next week	Create a SerpKite key per caller, give each a monthly credit limit, and swap the hostname on one low-risk caller
Weeks 3–4	Run a few dozen real queries through both endpoints and compare `items[].link`; recreate site restrictions with `siteSearch`
Weeks 5–7	Move the remaining callers, no-code flows included
By mid-December	Turn off the Custom Search API in Google Cloud and watch for errors from anything you missed

A checklist before January

Inventory every caller of the CSE endpoint, including no-code flows.
Swap the hostname and key. Prefer sending the key as an Authorization: Bearer header so it stays out of URLs and logs.
Recreate site restrictions with siteSearch or site: operators.
Update error handling. SerpKite errors look like {"error":{"code","message","request_id"}}. Failed calls (503) are not billed and are safe to retry.
Run a few dozen real queries through both endpoints and compare items[].link.
Set a spend cap in the dashboard so a runaway loop can't surprise you.
Deploy well before the holidays. December 31 is a bad day to find a forgotten cron job.

Cost

Google charged $5 per 1,000 queries after 100 free queries a day, with a cap of 10,000 queries a day. On SerpKite each /customsearch/v1 call is 1 credit, packs run from $1.00 per 1,000 down to $0.60, there's no daily cap, and credits never expire. You get 2,500 free credits on signup and 1,000 a month after that. Details are on the pricing page.

Next steps

The full parameter mapping and gotchas: Migrate from the Google Custom Search JSON API.
Paste an existing CSE URL into the CSE migration helper to get the SerpKite equivalent.
Need more than items[]? The Google Search API returns the knowledge graph, People Also Ask and Markdown output.

Runnable Python and Node.js versions of the migration, with a --check flag that compares response keys: SerpKite/custom-search-api-migration.

Disclosure: I work on SerpKite. This post first appeared on the SerpKite blog.

JSON vs Markdown SERPs: we measured tokens

SerpKite — Fri, 09 Oct 2026 21:22:01 +0000

When an agent calls a search tool, the whole response lands in the model's context. You pay for every token, and the model has to read past every one of them to find the three links that matter. So the format of a SERP response is not a detail: it is a cost line and a quality lever.

We took one Google results page and rendered it three ways.

These are estimates on a single sample, not a benchmark. The sample is an abridged results page (an answer box, three organic results, two People Also Ask questions, three related searches). Tokens are estimated at about 4 characters per token. Real pages are bigger and real tokenizers differ. The ratios are what to take away.

The results

Format	Estimated tokens	vs pretty JSON
JSON, pretty-printed	668	baseline
JSON, minified	534	-20%
compact JSON	248	-63%
Markdown	240	-64%

On this sample, Markdown is about 64% smaller than pretty JSON, and compact JSON about 63%. That is in line with the 60-80% reduction we see on full pages. For scale: a full, unfiltered Google SERP as JSON can reach roughly 24,700 tokens once every widget, sitelink and thumbnail is included. At that size the format choice is the difference between a cheap tool call and an expensive one.

Where the tokens go in JSON

Most of a JSON SERP is structure, not content: repeated keys ("position", "title", "link", "snippet"), quotes, braces, indentation, and fields the model never uses (the request echo, metadata, sitelinks, thumbnails). Minifying helps with whitespace but keeps every key.

Compact: JSON for tools

Compact JSON keeps the structure but shortens keys and drops fields agents rarely read. Use it when a program, not the model, consumes the output, or when your tool schema needs structured fields.

Markdown: text for models

Markdown renders the page as prose with numbered links. Models read it the way they read any document, and citations stay attached to URLs:

# best espresso machine 2026

## Results
1. **The Best Espresso Machines of 2026, Tested and Reviewed** — example.com
   https://www.example.com/best-espresso-machines
   We pulled more than 1,200 shots on 42 machines to find the best espresso makers for every budget.
2. **Espresso Machine Buying Guide (2026)** — coffee.example.org
   https://coffee.example.org/guides/espresso
   Single boiler, heat exchanger or dual boiler? What the specs mean.

## People also ask
- **What is the #1 rated espresso machine?** Reviewers most often rank dual-boiler machines with PID control at the top…

## Related searches
best espresso machine under $500 · best espresso machine for beginners

Going further: project the fields

If your agent only needs titles, links and the knowledge graph, ask for just those:

{ "q": "best espresso machine 2026", "fields": "results.title,results.link,knowledge_graph" }

Log an estimated token count per call (we return it in an X-Tokens-Estimate response header) so you can see what each tool call actually costs you.

What we recommend

Agent reads the results directly: Markdown.
Code post-processes the results: compact JSON or field projection.
You store results or need every field: full JSON.

We built this into SerpKite, a Google SERP API for AI agents, where the three formats cost the same (1 credit per page). You can try them on your own queries in the SERP token counter, and the parameters are in the docs. Whichever API you use, measure your own pages before you pick a format.

Originally published at https://serpkite.com/blog/json-vs-markdown-serp-tokens