# SERP API response format: every block and field of the JSON

> The SerpCrypto SERP API answer, field by field: search_metadata, organic_results, ai_overview, people_also_ask, local pack, ads and per-engine arrays.

- URL: https://serpcrypto.com/docs/response/
- Last updated: 2026-10-22
- Publisher: SerpCrypto (https://serpcrypto.com)

One frame on every engine, then one block per part of the results page. This page lists each block, its fields and their types. In the examples, IDs, counts, prices and results are illustrative.

**Quick answer — What does a SerpCrypto SERP API response contain?**

Each **SerpCrypto** response is one JSON object: `search_metadata` (status, engine, credits used), `search_parameters` (the settings applied), `search_information`, then one block per part of the results page, such as `organic_results`, `ai_overview`, `people_also_ask` or `local_results`. Absent parts are simply missing. One page costs 1 credit, from $0.30/1K searches; paid in crypto, no KYC.

## What does a full Google response look like?

The example below is a Google search for `standing desk` in the United Kingdom, shortened to one item per array. A real answer has about ten organic results and every other block the page showed for that query, location and device.

*engine=google, gl=gb: shortened, illustrative values*

```json
{
  "search_metadata": {
    "id": "srch_2b81d0c6fa47",
    "status": "success",
    "engine": "google",
    "created_at": "2026-10-22T10:02:31Z",
    "credits_used": 1
  },
  "search_parameters": {
    "engine": "google",
    "q": "standing desk",
    "gl": "gb",
    "hl": "en",
    "google_domain": "google.co.uk",
    "device": "desktop",
    "page": 1
  },
  "search_information": { "total_results": 52400000, "query_displayed": "standing desk" },
  "ai_overview": {
    "text": "A standing desk lets you work while standing or sitting…",
    "references": [
      { "index": 1, "title": "How to choose a standing desk", "link": "https://www.example.co.uk/guide", "source": "Example Guide" }
    ]
  },
  "ads": [
    { "position": 1, "block": "top", "title": "Electric Standing Desks", "link": "https://shop.example.com/desks", "displayed_link": "shop.example.com", "description": "Free delivery on…" }
  ],
  "organic_results": [
    {
      "position": 1,
      "title": "Best standing desks 2026, tested",
      "link": "https://www.example.co.uk/best-standing-desks",
      "displayed_link": "www.example.co.uk › reviews",
      "snippet": "We tested 14 electric and manual desks…",
      "date": "12 Oct 2026",
      "sitelinks": [ { "title": "Budget picks", "link": "https://www.example.co.uk/best-standing-desks#budget" } ]
    }
  ],
  "people_also_ask": [
    { "question": "Is it healthy to stand all day at a desk?", "snippet": "…", "title": "Standing at work", "link": "https://www.example.org/standing" }
  ],
  "shopping_results": [
    { "position": 1, "title": "Example Desk Pro 140 cm", "price": "£299.00", "source": "Example Store", "link": "https://shop.example.com/desk-pro" }
  ],
  "related_searches": [ { "query": "standing desk electric" }, { "query": "standing desk converter" } ],
  "pagination": { "current": 1, "next_page": 2 }
}
```

## Why are some blocks missing from my response?

Because the results page did not show them. Google decides per query, place and device whether to show ads, an AI Overview, a local pack or top stories. SerpCrypto returns what the page showed and leaves the rest out, rather than sending empty placeholders.

Read every block with a default value, as in the Python lines below. The same rule applies inside a block: optional fields such as `date` or `sitelinks` appear only on results that have them.

*Python: read optional blocks safely*

```python
data = response.json()

# A block is present only when the results page shows it: read with a default.
overview = data.get("ai_overview") or {}
organic = data.get("organic_results", [])
questions = [item["question"] for item in data.get("people_also_ask", [])]

if overview:
    print("AI Overview sources:", [ref["link"] for ref in overview.get("references", [])])
print(len(organic), "organic results,", len(questions), "questions")
```

## What is in search_metadata?

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | Identifier of the search. Quote it when you contact support. |
| `status` | string | `success` on a 200 answer. |
| `engine` | string | The engine that ran the search. |
| `created_at` | string | Time of the search, ISO 8601 in UTC. |
| `credits_used` | integer | Credits taken by this search: 1 on success. |

## What are search_parameters and search_information?

Store `search_parameters` with your results: it records exactly which country, language, place and device a ranking came from.

| Field | Type | Description |
| --- | --- | --- |
| `search_parameters` | object | The parameters applied, with defaults filled in: `engine`, `q`, `gl`, `hl`, `location`, `google_domain`, `device`, `page` and the others you sent. |
| `search_information.total_results` | integer | The result count the engine displayed, when it displayed one. An estimate, not an exact figure. |
| `search_information.query_displayed` | string | The query as the results page showed it. |

## What fields does organic_results have?

Organic results are the unpaid web results. On Bing, `organic_results` has the same shape.

| Field | Type | Description |
| --- | --- | --- |
| `position` | integer | Order of the result in this block on this page, starting at 1. |
| `title` | string | The blue-link title. |
| `link` | string | The URL of the result. |
| `displayed_link` | string | The URL or breadcrumb as shown under the title. |
| `snippet` | string | The text shown under the title. |
| `date` | string | Date shown next to the snippet, as written on the page. Optional. |
| `sitelinks` | array | Extra links shown under the result, each with `title` and `link`. Optional. |

## How is the AI Overview returned?

`ai_overview` is present only when Google shows an AI Overview for that query and place. Many queries have none.

| Field | Type | Description |
| --- | --- | --- |
| `ai_overview.text` | string | The text of the AI Overview as shown on the page. |
| `ai_overview.references[].index` | integer | Order of the source in the overview. |
| `ai_overview.references[].title` | string | Title of the cited page. |
| `ai_overview.references[].link` | string | URL of the cited page. |
| `ai_overview.references[].source` | string | Name of the site, as shown. |

## What do ads and people_also_ask contain?

| Field | Type | Description |
| --- | --- | --- |
| `ads[].position` | integer | Order within its block. |
| `ads[].block` | string | `top` or `bottom` of the page. |
| `ads[].title`, `link`, `displayed_link` | string | Headline, landing URL and shown URL of the ad. |
| `ads[].description` | string | Ad text. |
| `people_also_ask[].question` | string | The question as shown. |
| `people_also_ask[].snippet` | string | The answer text shown when the question is opened. |
| `people_also_ask[].title`, `link` | string | Title and URL of the page the answer comes from. |

## Which other Google blocks can appear?

| Block | Fields | What it is |
| --- | --- | --- |
| `local_results` | `position`, `title`, `address`, `rating`, `reviews`, `type` | The local pack: businesses on a map for queries with a place intent. |
| `knowledge_graph` | `title`, `type`, `description`, `source.name`, `source.link` | The knowledge panel about a person, place, company or thing. |
| `top_stories` | `title`, `link`, `source`, `date` | News articles shown in a carousel. |
| `inline_videos` | `title`, `link`, `source`, `duration` | Video results shown inside the web results. |
| `shopping_results` | `position`, `title`, `price`, `source`, `link` | Product listings shown inside the web results. |
| `related_searches` | `query` | Searches suggested at the bottom of the page. |
| `pagination` | `current`, `next_page` | Current page number and the next one, when there is one. |

## What do the other engines return?

Each vertical keeps the same frame and adds its own array. On Google Maps, `local_results` is richer than the local pack of a web search.

| `engine` | Main array | Fields |
| --- | --- | --- |
| `google_news` | `news_results` | `position`, `title`, `link`, `source`, `date`, `snippet`, `thumbnail` |
| `google_images` | `images_results` | `position`, `title`, `original`, `original_width`, `original_height`, `thumbnail`, `source`, `link` |
| `google_maps` | `local_results` | `position`, `title`, `place_id`, `address`, `phone`, `website`, `rating`, `reviews`, `type`, `hours`, `gps_coordinates.latitude`, `gps_coordinates.longitude` |
| `google_shopping` | `shopping_results` | `position`, `title`, `price`, `extracted_price`, `currency`, `source`, `link`, `delivery`, `rating`, `reviews` |
| `bing` | `organic_results`, `related_searches` | Same fields as the Google organic results |

## How are prices, ratings and dates typed?

Values keep the form the page used whenever the page wrote them as text. `price` is a string with its currency sign, such as `£299.00`, and Google Shopping adds `extracted_price` as a number with `currency` as a code. `rating` is a number and `reviews` an integer. Dates such as `date` stay as written on the page, for example `12 Oct 2026` or `3 days ago`, so parse them in your own code if you need a timestamp.

## How do I build an overall rank across several pages?

Store the page number with each result. `position` gives the order inside its block on one page, and `search_parameters.page` tells you which page that was. About 10 organic results per page, as Google has served since it stopped honouring num=100 in September 2025; each extra page is one more credit.

For rank tracking, most teams keep `link`, `position`, `page`, `gl`, `location`, `device` and `created_at` per keyword and day. That is enough to chart a ranking and to explain a change by place or device. See [rank tracking](https://serpcrypto.com/use-cases/rank-tracking/) for the full method.

## Response format questions

### Is the field naming stable?

Yes within version 1. New blocks or fields can be added, so ignore keys you do not know. Removing or renaming a field would come with a new version in the path, such as `/api/v2/`.

### Can I get the raw HTML of the page?

No. Version 1 returns parsed JSON only. The parsed blocks cover what most tools need: results, ads, questions, the AI Overview, the local pack and the knowledge panel.

### Why does total_results differ from what I counted?

It is the estimate the engine prints, not a count of the results you can page through. Pages stop long before that number; use `pagination.next_page` to know whether another page exists.

### Does a response with no organic results cost a credit?

Yes, if the search succeeded: an empty page is still a result. Only errors are free. 1 credit = 1 successful search request, which returns one page of results on any supported engine. A request that fails is not charged.

---

SerpCrypto: SerpCrypto is a SERP API for developers and AI agents that returns Google and Bing results as JSON, paid in crypto with no ID upload. Prepaid search credits from $0.30/1K searches never expire. No KYC — no ID, no selfie, no documents. Pay in crypto.