Google Scholar Scraper

sfoln/google-scholar-search · AI, Education, Developer tools On request

Search Google Scholar: one row per paper with title, link, parsed authors, venue and year, citation count, snippet and PDF link, plus a per-query summary with total citations. $8 per 1,000 result pages of up to 10 papers.

Request access Run it$8 / 1,000 google scholar results page

About

What it does

Google Scholar Scraper searches Google Scholar and returns one clean row per paper: title, link, parsed authors, venue and year, citation count, snippet and PDF link when Google shows one. Each query also gets a summary row with total citations and the most-cited paper. Built for literature reviews, research dashboards, citation tracking and AI research agents.

Price

Price per delivered record

Event	Price	Per 1,000	Charged for
Google Scholar results page `google-scholar-query`	$0.008	$8 / 1,000	Charged once per Google Scholar results page of up to 10 papers (one upstream credit).

Apify free plan: up to 10 items per run. Paid plans have no per-run cap; set maxTotalChargeUsd to cap spend.

Run

Call it from code, an agent or the Console

This API is private on Apify for now. Email us and we will publish it for you, usually within two working days. The calls below work once it is public. contact@sfoln.com

curl · synchronous run, rows in the response

curl -X POST "https://api.apify.com/v2/actors/sfoln~google-scholar-search/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["attention is all you need"]}'

mcp.json · hosted Apify MCP server

{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=sfoln/google-scholar-search"
    }
  }
}

asynchronous run · for large batches

POST https://api.apify.com/v2/actors/sfoln~google-scholar-search/runs?maxTotalChargeUsd=1
GET  https://api.apify.com/v2/actor-runs/{runId}            # until status is SUCCEEDED
GET  https://api.apify.com/v2/datasets/{defaultDatasetId}/items?format=json

Authenticate with an Apify API token. MCP clients can instead sign in with OAuth when prompted. Example prompt for an agent: Search Google Scholar for "attention is all you need" and list the 10 most-cited papers with their authors, year and citation counts.

Input

Input fields

Enter Google Scholar searches (one per line). Each query writes one row per paper plus one `query_summary` row.

Field	Type	Default	Meaning
`queries` *	`array`	required	Scholar queries Topics, paper titles or author names to search in Google Scholar, one per line. Accounts on the Apify free plan can process up to 10 queries per run.
`resultsPerQuery`	`integer`	`10`	Papers per query How many papers to fetch per query, rounded up to a multiple of 10. Each page of 10 papers is one google-scholar-query event. Range 10–100.
`page`	`integer`	`1`	Start page Result page to start from (1 = most relevant). Range 1–100.
`yearFrom`	`integer`	—	Published from (year) Keep only papers published in or after this year. The filter runs on the returned papers (see README), so pages are charged even when papers get filtered out. Range 1700–2100.
`yearTo`	`integer`	—	Published until (year) Keep only papers published in or before this year (same filtering rules as yearFrom). Range 1700–2100.
`language`	`string`	`"en"`	Language (hl) Interface language code, e.g. en, de.
`maxQueries`	`integer`	`1000`	Max queries Safety cap on the number of queries processed in this run. Range 1–10000.
`concurrency`	`integer`	`5`	Concurrency How many queries run in parallel. Range 1–10.
`includeRaw`	`boolean`	`false`	Include raw upstream response Attach the unmodified upstream pages to each query_summary row.

Example input

{
  "queries": [
    "attention is all you need"
  ]
}

Output

One record per input item

Records land in the run's dataset; a synchronous call returns them directly. Each has a status (ok is charged; everything else is free) and a charged flag. The run's OUTPUT record totals items and charges.

Field	Type	Meaning
`input`	`string`	Input
`query`	`string`	Query e.g. `"attention is all you need"`
`resultType`	`string`	Result type paper \| query_summary (one per query, not charged itself) e.g. `"paper"`
`rank`	`integer \| null`	Rank Overall position among the papers Google returned (before the year filter): (page − 1) × 10 + place on its page.
`position`	`integer \| null`	Position on page
`page`	`integer \| null`	Page
`title`	`string \| null`	Title
`url`	`string \| null`	URL
`domain`	`string \| null`	Domain
`publicationInfo`	`string \| null`	Publication info (raw) Authors – venue, year – host line as shown by Google Scholar.
`authors`	`array`	Authors Parsed from publicationInfo (Google abbreviates first names).
`authorsTruncated`	`boolean`	Authors truncated true when Google cut the author list with …
`venue`	`string \| null`	Venue
`year`	`integer \| null`	Year
`snippet`	`string \| null`	Snippet
`citedBy`	`integer \| null`	Cited by
`pdfUrl`	`string \| null`	PDF URL
`htmlUrl`	`string \| null`	HTML URL
`scholarId`	`string \| null`	Scholar ID
`totalPapers`	`integer \| null`	Papers
`returnedByGoogle`	`integer \| null`	Returned by Google
`filteredOutByYear`	`integer \| null`	Filtered out by year
`pagesFetched`	`integer \| null`	Pages fetched
`creditsUsed`	`number \| null`	Credits used query_summary: upstream credits the query used.
`creditsCharged`	`number \| null`	Credits charged query_summary: google-scholar-query events charged for the query, before any of its rows was written (equal to creditsUsed unless the maximum cost per run was reached).
`totalCitations`	`integer \| null`	Total citations
`mostCitedTitle`	`string \| null`	Most cited
`newestYear`	`integer \| null`	Newest year query_summary: latest publication year among the papers written.
`oldestYear`	`integer \| null`	Oldest year query_summary: earliest publication year among the papers written.
`yearFrom`	`integer \| null`	Year from query_summary: yearFrom filter applied, or null.
`yearTo`	`integer \| null`	Year to query_summary: yearTo filter applied, or null.
`status`	`string`	Status ok \| not_found \| error \| skipped_budget \| skipped_free_plan
`charged`	`boolean`	Charged true on a paper row covered by the google-scholar-query charge of its results page; the query_summary row is never charged itself (see creditsCharged).
`chargedEvent`	`string`	Charged event
`chargedCount`	`integer`	Events charged Events actually charged when the charge came back short of the requested count (present only then; a warning explains it).
`source`	`string`	Data source
`fetchedAt`	`string`	Fetched at

Example record

{
  "input": "attention is all you need",
  "query": "attention is all you need",
  "resultType": "paper",
  "rank": 1,
  "position": null,
  "page": 1,
  "title": "Attention is all you need",
  "url": "https://proceedings.neurips.cc/paper/7181-attention-is-all",
  "domain": "proceedings.neurips.cc",
  "publicationInfo": "A Vaswani, N Shazeer, N Parmar… - Advances in neural …, 2017 - proceedings.neurips.cc",
  "authors": [
    "A Vaswani",
    "N Shazeer",
    "N Parmar"
  ],
  "authorsTruncated": true,
  "venue": "Advances in neural …",
  "year": 2017,
  "snippet": "… to attend to all positions in the decoder up to and including that position…",
  "citedBy": 119097,
  "pdfUrl": null,
  "htmlUrl": null,
  "scholarId": null,
  "status": "ok",
  "charged": true,
  "chargedEvent": "google-scholar-query",
  "source": "serper",
  "fetchedAt": "2026-10-14T10:00:00.000Z"
}

Machine-readable

This page for agents

/actors/google-scholar-search.json — this API as JSON
/actors/google-scholar-search.md — this API as Markdown
/catalog.json — the whole catalogue