Pricing

from $10.00 / 1,000 query executeds

Try for free

Go to Apify Store

Google Search Results via Serper API — Organic, PAA & Related

Try for free

Structured Google search results as clean JSON. Returns organic results, People Also Ask questions with answers, and related searches — not just a flat link list. Batch multiple queries per run. Country, language, device and pagination supported. Fast, no browser, no proxies needed.

Pricing

from $10.00 / 1,000 query executeds

Rating

0.0

(0)

Developer

morrbiz llc

Actor stats

Bookmarked

Total users

Monthly active users

25 days ago

Last modified

.dockerignore

node_modules
dist
.git
*.log
storage
apify_storage
.env
.env.local

.gitignore

node_modules
dist
apify_storage
storage
*.log

Dockerfile

# Google Search SERP Scraper
# Node 20, Apify's own base image (pre-cached on their build servers).
FROM apify/actor-node:20

COPY package*.json ./
RUN npm install --include=dev --audit=false

COPY . ./
RUN npm run build \
 && npm prune --omit=dev --audit=false

CMD ["npm", "start", "--silent"]

main.ts

1// main.ts — Google Search SERP Scraper (Apify actor)
2//
3// Native: calls Serper's API directly from inside the actor. Does not proxy
4// through uxus.finance — no extra hop, no dependency on that deployment's
5// uptime, and the actor's own SERPER_API_KEY budget is entirely separate from
6// the hosted endpoint's. The mapper (lib/serper-map.ts) is a byte-identical
7// copy of the one backported into the hosted /api/search — same convention
8// as apify-actor/lib/*.ts being copies of uxus.finance's production code.
9//
10// SERPER_API_KEY must be set as an Actor environment variable (Console ->
11// this Actor -> Settings -> Environment variables), not as run input — it's
12// a secret, not a per-run parameter.
13//
14// NEVER EXIT FAILED ON A HANDLED CONDITION. Apify's automated QA runs the actor
15// with the INPUT_SCHEMA prefill values and marks it "Under maintenance" on any
16// run that is not SUCCEEDED within 5 minutes. So every code path below that is
17// not a genuine crash — missing key, empty/oversized input, an upstream 401/403/
18// 429/5xx, a timeout, an unparseable response, a charge limit — pushes a dataset
19// item that says what happened and exits SUCCEEDED (exit code 0). Only an
20// unexpected exception in main() reaches Actor.fail().
21
22import { Actor, log } from "apify";
23import { mapSerperResponse } from "@/lib/serper-map";
24
25const MAX_QUERIES = 1000;
26const CHARGE_EVENT = "query-executed";
27const REQUEST_TIMEOUT_MS = 30_000;
28const RETRY_DELAY_MS = 1_500;
29
30interface Input {
31  queries?: string[] | string;
32  num?: number;
33  country?: string;
34  language?: string;
35  page?: number;
36  device?: string;
37}
38
39function withScores(results: { title: string; url: string; description: string }[]) {
40  const n = results.length || 1;
41  return results.map((r, i) => ({ ...r, score: Math.round(((n - i) / n) * 1000) / 1000 }));
42}
43
44/** Map an upstream HTTP failure to a stable, human-readable error code + hint. */
45function classifyUpstream(status: number, detail: string): { error: string; hint: string } {
46  const d = detail.toLowerCase();
47  if (d.includes("credit")) {
48    return { error: "upstream_credits_exhausted", hint: "The Serper account behind this Actor has no credits left. Top up at serper.dev." };
49  }
50  if (status === 401 || status === 403) {
51    return { error: "upstream_auth_error", hint: "Serper rejected the API key. Check SERPER_API_KEY under this Actor's Settings -> Environment variables." };
52  }
53  if (status === 429) return { error: "upstream_rate_limited", hint: "Serper rate limit hit. Retry the run in a minute." };
54  if (status >= 500) return { error: "upstream_unavailable", hint: "Serper returned a server error. Retry the run later." };
55  return { error: "upstream_error", hint: "Serper rejected the request. See message for its response." };
56}
57
58async function main(): Promise<void> {
59  await Actor.init();
60
61  let pushed = 0;
62  let errors = 0;
63
64  /** Push a record that explains what happened. `query` stays a string (dataset schema). */
65  const notice = async (query: string, error: string, message: string, extra: { status?: number; hint?: string } = {}) => {
66    await Actor.pushData({ query, error, message, ...extra, checked_at: new Date().toISOString() });
67    pushed++;
68    errors++;
69  };
70
71  /** Every path ends here: guarantee at least one dataset item, then exit SUCCEEDED. */
72  const finish = async (statusMessage: string): Promise<void> => {
73    if (pushed === 0) {
74      await Actor.pushData({ query: "", error: "no_output", message: "The run completed without producing any results.", checked_at: new Date().toISOString() });
75      pushed++;
76    }
77    log.info(statusMessage);
78    await Actor.exit({ statusMessage, exitCode: 0 });
79  };
80
81  const input = (await Actor.getInput<Input>()) ?? {};
82  const rawQueries = Array.isArray(input.queries) ? input.queries : typeof input.queries === "string" ? [input.queries] : [];
83  let queries = rawQueries.map((q) => String(q ?? "").trim()).filter(Boolean);
84  const num = Math.min(Math.max(Math.trunc(Number(input.num)) || 10, 1), 100);
85  const { country, language, device } = input;
86  const page = Number.isInteger(Number(input.page)) && Number(input.page) >= 1 ? Number(input.page) : undefined;
87
88  const apiKey = (process.env.SERPER_API_KEY ?? "").trim();
89  if (!apiKey) {
90    await notice("", "missing_api_key", "SERPER_API_KEY is not set for this Actor, so no search was run.", {
91      hint: "Add SERPER_API_KEY under this Actor's Settings -> Environment variables in the Apify Console, then run again.",
92    });
93    return finish("No search run: SERPER_API_KEY is not configured (see the dataset item).");
94  }
95
96  if (queries.length === 0) {
97    await notice("", "no_queries", 'Input must include a non-empty "queries" array, so no search was run.', {
98      hint: 'Example input: { "queries": ["web scraping tools"], "num": 3 }',
99    });
100    return finish('No search run: no "queries" in the input (see the dataset item).');
101  }
102
103  if (queries.length > MAX_QUERIES) {
104    const skipped = queries.length - MAX_QUERIES;
105    queries = queries.slice(0, MAX_QUERIES);
106    await notice("", "too_many_queries", `Got ${MAX_QUERIES + skipped} queries; this Actor caps at ${MAX_QUERIES} per run. The first ${MAX_QUERIES} were run; ${skipped} were skipped.`, {
107      hint: "Split the remaining queries into another run.",
108    });
109  }
110
111  let processed = 0;
112  let stopped = false;
113
114  for (const q of queries) {
115    if (stopped) break;
116    const started = Date.now();
117    const body: Record<string, unknown> = { q, num };
118    if (country) body.gl = country;
119    if (language) body.hl = language;
120    if (page) body.page = page;
121    if (device) body.device = device;
122
123    // One retry for a transient upstream condition (rate limit / 5xx / network); nothing is charged for failures.
124    let res: Response | null = null;
125    let networkError: unknown = null;
126    for (let attempt = 0; attempt < 2; attempt++) {
127      try {
128        res = await fetch("https://google.serper.dev/search", {
129          method: "POST",
130          headers: { "X-API-KEY": apiKey, "Content-Type": "application/json" },
131          body: JSON.stringify(body),
132          signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
133        });
134        networkError = null;
135        if (res.status !== 429 && res.status < 500) break;
136      } catch (e) {
137        networkError = e;
138        res = null;
139      }
140      if (attempt === 0) await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
141    }
142
143    if (!res) {
144      const e = networkError as Error | null;
145      const timedOut = e?.name === "TimeoutError" || e?.name === "AbortError";
146      await notice(q, timedOut ? "request_timeout" : "request_failed", String(e?.message ?? e ?? "request failed"), {
147        hint: "Network error reaching Serper. Retry the run later.",
148      });
149      continue;
150    }
151
152    if (!res.ok) {
153      const detail = await res.text().catch(() => "");
154      const { error, hint } = classifyUpstream(res.status, detail);
155      await notice(q, error, detail.slice(0, 500) || `HTTP ${res.status}`, { status: res.status, hint });
156      // Auth / credit failures repeat for every remaining query — stop instead of burning the loop.
157      if (error === "upstream_auth_error" || error === "upstream_credits_exhausted") {
158        stopped = true;
159        log.warning(`${error}: stopping — the same failure would repeat for every remaining query.`);
160      }
161      continue; // no charge — Serper didn't return results
162    }
163
164    let mapped;
165    try {
166      const raw = await res.json();
167      mapped = mapSerperResponse(raw);
168    } catch (e) {
169      await notice(q, "invalid_upstream_response", `Serper returned a response that could not be read: ${String((e as Error)?.message ?? e)}`.slice(0, 500), {
170        status: res.status,
171        hint: "Retry the run. If it persists, the upstream response format may have changed.",
172      });
173      continue;
174    }
175
176    const results = withScores(mapped.organic.map((o) => ({ title: o.title, url: o.url, description: o.description })));
177
178    await Actor.pushData({
179      query: q,
180      results,
181      organic: mapped.organic, // same rows, richer: position/sitelinks/attributes/date kept intact
182      ads: mapped.ads,
183      people_also_ask: mapped.people_also_ask,
184      related_searches: mapped.related_searches,
185      knowledge_graph: mapped.knowledge_graph,
186      answer_box: mapped.answer_box,
187      shopping: mapped.shopping,
188      ai_overview: mapped.ai_overview,
189      // Count fields exist purely so the Console table view (.actor/dataset_schema.json)
190      // can show them as columns — the schema's display system has no built-in way to
191      // derive an array's length, so it has to be computed and stored here instead.
192      results_count: results.length,
193      organic_count: mapped.organic.length,
194      people_also_ask_count: mapped.people_also_ask.length,
195      related_searches_count: mapped.related_searches.length,
196      latency_ms: Date.now() - started,
197      checked_at: new Date().toISOString(),
198    });
199    pushed++;
200    processed++;
201
202    // The result is already delivered; a charging problem must never fail the run.
203    try {
204      const charge = await Actor.charge({ eventName: CHARGE_EVENT, count: 1 });
205      if (charge?.eventChargeLimitReached) {
206        await notice("", "charge_limit_reached", "The maximum charge for this run was reached, so remaining queries were not run.", {
207          hint: "Raise the run's maximum cost and run the remaining queries again.",
208        });
209        stopped = true;
210      }
211    } catch (e) {
212      log.warning(`Actor.charge failed (result kept, run continues): ${String((e as Error)?.message ?? e)}`);
213    }
214  }
215
216  await finish(`Executed ${processed}/${queries.length} quer${queries.length === 1 ? "y" : "ies"}${errors ? `; ${errors} error record${errors === 1 ? "" : "s"} in the dataset` : ""}.`);
217}
218
219// A genuine crash (a bug, out of memory, the dataset itself unwritable) is the ONLY thing that may fail the run.
220main().catch(async (err) => {
221  log.exception(err as Error, "Unhandled error in main()");
222  await Actor.fail(err instanceof Error ? err.message : String(err));
223});

package.json

{
  "name": "google-search-serp-scraper",
  "version": "0.1.0",
  "description": "Native Google SERP scraper via Serper: organic results, People Also Ask, and related searches — confirmed live. Ads/shopping/knowledge graph/answer box/AI Overview pass through when present but aren't guaranteed for every query.",
  "private": true,
  "type": "commonjs",
  "scripts": {
    "build": "tsc -p tsconfig.json && tsc-alias -p tsconfig.json",
    "start": "node dist/main.js",
    "start:dev": "npm run build && node dist/main.js"
  },
  "dependencies": {
    "apify": "^3.2.6"
  },
  "devDependencies": {
    "@types/node": "^20",
    "tsc-alias": "^1.9.5",
    "typescript": "^5.6.0"
  }
}

tsconfig.json

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "moduleResolution": "node",
    "lib": ["ES2020", "dom"],
    "outDir": "./dist",
    "rootDir": ".",
    "baseUrl": ".",
    "paths": { "@/*": ["./*"] },
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "resolveJsonModule": true,
    "forceConsistentCasingInFileNames": true
  },
  "include": ["main.ts", "lib/**/*.ts"]
}

.actor/actor.json

{
  "actorSpecification": 1,
  "name": "google-search-serp-scraper",
  "title": "Google Search Results via Serper API — Organic, PAA & Related",
  "version": "0.1",
  "buildTag": "latest",
  "dockerfile": "../Dockerfile",
  "input": "../INPUT_SCHEMA.json",
  "readme": "../README.md",
  "output": "./output_schema.json",
  "storages": {
    "dataset": "./dataset_schema.json"
  }
}

.actor/dataset_schema.json

{
  "actorSpecification": 1,
  "fields": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "The search query executed."
      },
      "results": {
        "type": "array",
        "description": "Organic results in the stable {title,url,description,score} shape used across this publisher's search tools.",
        "items": {
          "type": "object",
          "properties": {
            "title": {
              "type": "string"
            },
            "url": {
              "type": "string"
            },
            "description": {
              "type": "string"
            },
            "score": {
              "type": "number"
            }
          }
        }
      },
      "organic": {
        "type": "array",
        "description": "Same organic rows as results, richer: position, and sitelinks/attributes/date when Google returns them.",
        "items": {
          "type": "object",
          "properties": {
            "title": {
              "type": "string"
            },
            "url": {
              "type": "string"
            },
            "description": {
              "type": "string"
            },
            "position": {
              "type": [
                "number",
                "null"
              ]
            },
            "sitelinks": {
              "type": "array"
            },
            "attributes": {
              "type": "object"
            },
            "date": {
              "type": "string"
            }
          }
        }
      },
      "people_also_ask": {
        "type": "array",
        "description": "Confirmed to populate live. The expandable question list Google shows.",
        "items": {
          "type": "object",
          "properties": {
            "question": {
              "type": "string"
            },
            "snippet": {
              "type": "string"
            },
            "title": {
              "type": "string"
            },
            "url": {
              "type": "string"
            }
          }
        }
      },
      "related_searches": {
        "type": "array",
        "description": "Confirmed to populate live. Query-refinement suggestions.",
        "items": {
          "type": "string"
        }
      },
      "ads": {
        "type": "array",
        "description": "Passed through verbatim when the upstream response includes them. Not observed to populate across 13 test queries on 2 accounts — present in the schema, not guaranteed in practice."
      },
      "shopping": {
        "type": "array",
        "description": "Passed through verbatim when the upstream response includes them. Not observed to populate across 13 test queries on 2 accounts."
      },
      "knowledge_graph": {
        "type": [
          "object",
          "null"
        ],
        "description": "Populated when Google returns an entity panel and Serper surfaces it. Not observed to populate across 13 test queries on 2 accounts, including canonical trigger queries."
      },
      "answer_box": {
        "type": [
          "object",
          "null"
        ],
        "description": "Populated when Google returns a direct-answer box and Serper surfaces it. Not observed to populate across 13 test queries on 2 accounts."
      },
      "ai_overview": {
        "description": "Passed through verbatim if present. Not observed to populate; presence/shape not confirmed as stable."
      },
      "results_count": {
        "type": "number",
        "description": "Length of results — computed at push time so it can be shown as a table column."
      },
      "organic_count": {
        "type": "number",
        "description": "Length of organic — computed at push time so it can be shown as a table column."
      },
      "people_also_ask_count": {
        "type": "number",
        "description": "Length of people_also_ask — computed at push time so it can be shown as a table column."
      },
      "related_searches_count": {
        "type": "number",
        "description": "Length of related_searches — computed at push time so it can be shown as a table column."
      },
      "latency_ms": {
        "type": "number",
        "description": "Time the Serper call took, in milliseconds."
      },
      "checked_at": {
        "type": "string",
        "description": "ISO timestamp of the query."
      },
      "error": {
        "type": "string",
        "description": "Present on records that describe a condition instead of results: missing_api_key, no_queries, too_many_queries, request_failed, request_timeout, upstream_auth_error, upstream_credits_exhausted, upstream_rate_limited, upstream_unavailable, upstream_error, invalid_upstream_response, charge_limit_reached, no_output. The run still SUCCEEDS."
      },
      "status": {
        "type": "number",
        "description": "HTTP status from the upstream error, present only on an upstream_error record."
      },
      "message": {
        "type": "string",
        "description": "Error detail, present only on a failed query record."
      },
      "hint": {
        "type": "string",
        "description": "What to do about an error record (present on error records only)."
      }
    }
  },
  "views": {
    "overview": {
      "title": "Overview",
      "transformation": {
        "fields": [
          "query",
          "results_count",
          "organic_count",
          "people_also_ask_count",
          "related_searches_count",
          "latency_ms",
          "checked_at"
        ]
      },
      "display": {
        "component": "table",
        "properties": {
          "query": {
            "label": "Query",
            "format": "text"
          },
          "results_count": {
            "label": "Results",
            "format": "number"
          },
          "organic_count": {
            "label": "Organic",
            "format": "number"
          },
          "people_also_ask_count": {
            "label": "PAA",
            "format": "number"
          },
          "related_searches_count": {
            "label": "Related",
            "format": "number"
          },
          "latency_ms": {
            "label": "Latency (ms)",
            "format": "number"
          },
          "checked_at": {
            "label": "Checked at",
            "format": "date"
          }
        }
      }
    }
  }
}

.actor/output_schema.json

{
  "actorOutputSchemaVersion": 1,
  "title": "Output of Google Search Results via Serper API",
  "properties": {
    "searchResults": {
      "type": "string",
      "title": "Search results",
      "description": "One record per query executed: organic results, People Also Ask, related searches, plus ads/shopping/knowledge_graph/answer_box/ai_overview when the upstream response includes them.",
      "template": "{{links.apiDefaultDatasetUrl}}/items?view=overview"
    }
  }
}

lib/serper-map.ts

1// lib/serper-map.ts — pure mapper for Serper's raw Google-search JSON payload.
2// Shared verbatim between the hosted /api/search route (via lib/search-core.ts)
3// and apify-actor-search/ (copied there byte-identical, same convention as
4// apify-actor/lib/*.ts).
5//
6// organic/knowledgeGraph/answerBox/peopleAlsoAsk/relatedSearches/shopping field
7// names are cross-checked against three independently maintained Serper
8// clients (go-serper's client.go, mcp-server-serper's src/types/serper.ts,
9// langchain-community's google_serper.py) as of 2026-09 and agree.
10//
11// `ads` and `aiOverview` have no stable documented schema anywhere those three
12// clients or Serper's own public docs confirm — neither client implements
13// them at all. Rather than guess field names and risk silently dropping
14// whatever's actually in there (the exact bug this mapper exists to fix),
15// both are passed through verbatim, unmodified.
16
17export interface SerperSitelink {
18  title: string;
19  url: string;
20}
21
22export interface SerperOrganic {
23  title: string;
24  url: string;
25  description: string;
26  position: number | null;
27  sitelinks?: SerperSitelink[];
28  attributes?: Record<string, string>;
29  date?: string;
30}
31
32export interface SerperKnowledgeGraph {
33  title?: string;
34  type?: string;
35  website?: string;
36  image_url?: string;
37  description?: string;
38  description_source?: string;
39  description_link?: string;
40  attributes?: Record<string, string>;
41}
42
43export interface SerperAnswerBox {
44  answer?: string;
45  title?: string;
46  url?: string;
47  snippet?: string;
48  snippet_highlighted?: string[];
49}
50
51export interface SerperPeopleAlsoAsk {
52  question: string;
53  snippet?: string;
54  title?: string;
55  url?: string;
56}
57
58export interface SerperShoppingItem {
59  title?: string;
60  source?: string;
61  url?: string;
62  price?: string;
63  delivery?: string;
64  image_url?: string;
65  rating?: number;
66  rating_count?: number;
67  offers?: string;
68  product_id?: string;
69  position?: number;
70}
71
72export interface SerperMapped {
73  organic: SerperOrganic[];
74  ads: unknown[];
75  people_also_ask: SerperPeopleAlsoAsk[];
76  related_searches: string[];
77  knowledge_graph: SerperKnowledgeGraph | null;
78  answer_box: SerperAnswerBox | null;
79  shopping: SerperShoppingItem[];
80  ai_overview: unknown | null;
81}
82
83function str(v: unknown): string {
84  return typeof v === "string" ? v : "";
85}
86
87// eslint-disable-next-line @typescript-eslint/no-explicit-any
88export function mapSerperResponse(raw: any): SerperMapped {
89  const organic: SerperOrganic[] = Array.isArray(raw?.organic)
90    ? raw.organic.map((r: Record<string, unknown>) => ({
91        title: str(r?.title),
92        url: str(r?.link),
93        description: str(r?.snippet),
94        position: typeof r?.position === "number" ? r.position : null,
95        ...(Array.isArray(r?.sitelinks)
96          ? {
97              sitelinks: (r.sitelinks as Record<string, unknown>[]).map((s) => ({
98                title: str(s?.title),
99                url: str(s?.link),
100              })),
101            }
102          : {}),
103        ...(r?.attributes && typeof r.attributes === "object" ? { attributes: r.attributes as Record<string, string> } : {}),
104        ...(r?.date ? { date: str(r.date) } : {}),
105      }))
106    : [];
107
108  const people_also_ask: SerperPeopleAlsoAsk[] = Array.isArray(raw?.peopleAlsoAsk)
109    ? raw.peopleAlsoAsk.map((p: Record<string, unknown>) => ({
110        question: str(p?.question),
111        ...(p?.snippet ? { snippet: str(p.snippet) } : {}),
112        ...(p?.title ? { title: str(p.title) } : {}),
113        ...(p?.link ? { url: str(p.link) } : {}),
114      }))
115    : [];
116
117  const related_searches: string[] = Array.isArray(raw?.relatedSearches)
118    ? raw.relatedSearches.map((r: Record<string, unknown>) => str(r?.query)).filter(Boolean)
119    : [];
120
121  const kg = raw?.knowledgeGraph as Record<string, unknown> | undefined;
122  const knowledge_graph: SerperKnowledgeGraph | null = kg
123    ? {
124        ...(kg.title ? { title: str(kg.title) } : {}),
125        ...(kg.type ? { type: str(kg.type) } : {}),
126        ...(kg.website ? { website: str(kg.website) } : {}),
127        ...(kg.imageUrl ? { image_url: str(kg.imageUrl) } : {}),
128        ...(kg.description ? { description: str(kg.description) } : {}),
129        ...(kg.descriptionSource ? { description_source: str(kg.descriptionSource) } : {}),
130        ...(kg.descriptionLink ? { description_link: str(kg.descriptionLink) } : {}),
131        ...(kg.attributes && typeof kg.attributes === "object" ? { attributes: kg.attributes as Record<string, string> } : {}),
132      }
133    : null;
134
135  const ab = raw?.answerBox as Record<string, unknown> | undefined;
136  const answer_box: SerperAnswerBox | null = ab
137    ? {
138        ...(ab.answer ? { answer: str(ab.answer) } : {}),
139        ...(ab.title ? { title: str(ab.title) } : {}),
140        ...(ab.link ? { url: str(ab.link) } : {}),
141        ...(ab.snippet ? { snippet: str(ab.snippet) } : {}),
142        ...(Array.isArray(ab.snippetHighlighted) ? { snippet_highlighted: ab.snippetHighlighted as string[] } : {}),
143      }
144    : null;
145
146  const shopping: SerperShoppingItem[] = Array.isArray(raw?.shopping)
147    ? raw.shopping.map((s: Record<string, unknown>) => ({
148        ...(s?.title ? { title: str(s.title) } : {}),
149        ...(s?.source ? { source: str(s.source) } : {}),
150        ...(s?.link ? { url: str(s.link) } : {}),
151        ...(s?.price ? { price: str(s.price) } : {}),
152        ...(s?.delivery ? { delivery: str(s.delivery) } : {}),
153        ...(s?.imageUrl ? { image_url: str(s.imageUrl) } : {}),
154        ...(typeof s?.rating === "number" ? { rating: s.rating } : {}),
155        ...(typeof s?.ratingCount === "number" ? { rating_count: s.ratingCount } : {}),
156        ...(s?.offers ? { offers: str(s.offers) } : {}),
157        ...(s?.productId ? { product_id: str(s.productId) } : {}),
158        ...(typeof s?.position === "number" ? { position: s.position } : {}),
159      }))
160    : [];
161
162  return {
163    organic,
164    ads: Array.isArray(raw?.ads) ? raw.ads : [],
165    people_also_ask,
166    related_searches,
167    knowledge_graph,
168    answer_box,
169    shopping,
170    ai_overview: raw?.aiOverview ?? null,
171  };
172}

Google Search SERP Crawler

radiant_martian/google-search-serp-crawler

This is a Google Search crawler with comprehensive information categorized for your AI agent or RPA use.

DataGarage

192

Google Search Scraper (Legacy)

mina_safwat/Google-Search-Scraper

Scrape Google search results with customizable parameters including language, region, and SafeSearch settings. Results include URL, title, and description for each search result.

Mina

3.0

(1)

Google Search Scraper

burbn/google-search-scraper

Fastest real-time Google Search scraper! Extract organic results, AI Overviews (SGE), community answers, and snippets. Supports city-level localization, time filters, and mobile/desktop emulation. Perfect for SEO tracking and SERP analysis.

Kevin

301

Bing Search Result Scraper

curious_coder/bing-search-scraper

Bing Search Result Scraper extracts organic and paid results, ads, Related, People Also Ask, News, Videos and Images Answers. Supports all available markets and languages. Download data as HTML table, JSON, CSV, Excel, XML or RSS.

Curious Coder

1.1K

Google Search Results Scraper

thirdwatch/google-search-scraper

Scrape Google Search results for any query. Get titles, URLs, snippets, and site links. Supports web, news, images, videos, and shopping. Filter by country, language, and time range.

Thirdwatch

Google Search Results Scraper (SERP)

apidojo/google-search-scraper

SERP - Google Search Scraper with unbeatable pricing! $0.002/query gets you 10 results FREE + $0.0002/extra item. Event-based billing = pay only for what you need. Ideal for SEO monitoring, keyword research & market analysis. No proxy required!

API Dojo

1.7K

3.9

(11)

DataForSEO SERP API - Google Organic, Maps & News Results

santhej/dataforseo-serp-api

DataForSEO-powered SERP API. Scrape Google Organic, Google Maps and Google News results for any keywords as clean structured JSON. Set location, language, device and depth. Pay per SERP page — no DataForSEO account or subscription needed.

Santhej Kallada

Google Search Results Scraper (~$0.045/1K Results)

alfalfa/google-serp-scraper

Google search results scraper and Google SERP API replacement: organic results with resolved URLs, ads, shopping ads, People Also Ask, related searches, pagination, any country and language. One record per result page: $0.45 per 1,000 pages, ~$0.045 per 1,000 results, final price, no start fee.

Alfalfa

Google Search Results Scraper — Cheaper SERP API

prodiger/google-search-scraper

Scrape Google Search result pages by query or URL. Extract organic results, related searches, People Also Ask, best-effort ads, and HTML snapshots. Slightly cheaper pay-per-event pricing than Apify's Google Search Results Scraper.

Arnas

Google Search Results Scraper: SERP, Ads & AI Overview

santamaria-automations/google-search-scraper

Scrape Google search result pages: organic results, paid ads, People Also Ask with answers, related queries, featured snippet and AI Overview with sources. Pay per SERP page, no subscription.

NanoScrape

401

4.5

(2)

Google Search Results via Serper API — Organic, PAA & Related

.dockerignore

.gitignore

Dockerfile

main.ts

package.json

tsconfig.json

.actor/actor.json

.actor/dataset_schema.json

.actor/output_schema.json

lib/serper-map.ts

You might also like

Google Search SERP Crawler

Google Search Scraper (Legacy)

Google Search Scraper

Bing Search Result Scraper

Google Search Results Scraper

Google Search Results Scraper (SERP)

DataForSEO SERP API - Google Organic, Maps & News Results

Google Search Results Scraper (~$0.045/1K Results)

Google Search Results Scraper — Cheaper SERP API

Google Search Results Scraper: SERP, Ads & AI Overview

.dockerignore

.gitignore

Dockerfile

main.ts

package.json

tsconfig.json

.actor/actor.json

.actor/dataset_schema.json

.actor/output_schema.json

lib/serper-map.ts