Google Scholar Scraper: Academic Papers, Citations and PDFs

Google Scholar Scraper turns academic search queries into structured rows of scholarly papers: titles, authors, citation counts, publication years, DOI links, open-access PDFs and abstracts. Use it as a Google Scholar API alternative for literature reviews, citation tracking and research datasets, with results drawn from the OpenAlex index of more than 250 million works.

The data source is OpenAlex. Results follow OpenAlex relevance ordering, and citation counts reflect that index. This actor preserves the inputs and paper fields of the existing Google Scholar Papers actor, so saved tasks and dataset consumers keep working. The search covers articles, preprints, books, conference papers and other scholarly works included in OpenAlex.

Google Scholar Scraper input

queries is a required array of strings. Each non-empty query is trimmed, and duplicate queries are searched once in their first-occurrence order. An input containing only empty or whitespace strings produces an empty successful run with an input error in the errors record. There is no default query: the input editor prefills large language models as a starting example.

pages is an optional integer from 1 through 10. Its default is 1. Each page represents ten papers, so requesting two pages gives up to twenty papers per query and ten pages gives up to one hundred. Fewer papers may arrive when the index has fewer matches. The position field starts at 1 for each query and continues through that query's requested results.

language optionally filters the publication language. Its default is the empty string, which searches every language. Values are trimmed and converted to lowercase before filtering. Use codes such as en, de, nl or fr. Existing tasks containing the historical hl, use_proxy or use_cookies fields continue to work; these fields have no effect on the OpenAlex search. In particular, hl does not activate a publication-language filter.

This input was measured against the live actor:

{"queries": ["large language models"]}

It returned ten papers on 3 October 2026. Search results and citation counts can change as the source index updates. Store the query and retrieval date when you need to compare successive runs.

Output fields and a real example

Each dataset row is one paper. The existing fields remain available:

• position: integer rank within the paper's query.
• title: the paper title, or null when the source has no title.
• authors_venue: up to eight author names, the publication venue and the year as one formatted string.
• year: integer publication year, or null when unavailable.
• cited_by_count: integer citation count from OpenAlex.
• title_url: DOI link when available, otherwise the publisher landing page or OpenAlex work link.
• pdf_url: direct PDF link when available, otherwise null.
• snippet: complete reconstructed abstract, or an empty string when the source provides none.
• search_query: the trimmed query that produced the row.

Additional fields make the rows easier to combine with other academic data: source, fetched_at, engine, url, query, abstract, doi, authors, venue, language and openalex_id. The authors array contains the full author list supplied by the index; it is not limited to the eight names displayed in authors_venue. The normalized doi omits the DOI URL prefix and uses lowercase. A missing DOI is null.

The following row is an actual response retrieved on 3 October 2026:

{
  "position": 1,
  "title": "Large language models in medicine",
  "authors_venue": "Arun James Thirunavukarasu, Darren Shu Jeng Ting, Kabilan Elangovan, Laura Gutiérrez, Ting Fang Tan, Daniel Shu Wei Ting - Nature Medicine - 2023",
  "year": 2023,
  "cited_by_count": 3937,
  "title_url": "https://doi.org/10.1038/s41591-023-02448-8",
  "pdf_url": null,
  "snippet": "",
  "search_query": "large language models",
  "source": "google-scholar-scraper",
  "fetched_at": "2026-10-03T17:45:52.092Z",
  "engine": "openalex",
  "url": "https://doi.org/10.1038/s41591-023-02448-8",
  "query": "large language models",
  "abstract": "",
  "doi": "10.1038/s41591-023-02448-8",
  "authors": [
    "Arun James Thirunavukarasu",
    "Darren Shu Jeng Ting",
    "Kabilan Elangovan",
    "Laura Gutiérrez",
    "Ting Fang Tan",
    "Daniel Shu Wei Ting"
  ],
  "venue": "Nature Medicine",
  "language": "en",
  "openalex_id": "https://openalex.org/W4384561707"
}

Missing abstracts and PDFs are ordinary source limitations. An empty snippet and null pdf_url preserve their existing JSON types. The actor does not invent a title, an abstract, an author list or a document link to fill a missing source value.

Pricing

The existing price remains $0.003 per delivered paper, charged through the paper event. There is no start fee. Ten delivered papers cost $0.03 and one hundred cost $0.30, before any platform execution charges. A query returning no papers creates no paper events. Charges follow the papers actually placed in the dataset.

Users without a paid Apify plan receive the first ten rows of a run. The paper-event count is limited to those delivered rows. The source search still considers the supplied queries in order, including queries after earlier searches that found nothing. Users on paid plans receive the full requested result set within the actor's run budget.

Summary and error records

The summary record keeps itemCount, errorCount and billableCount. itemCount counts collected papers before the free-plan delivery cap; billableCount counts delivered papers eligible for charging. Additional run fields describe delivery, status and any warnings. The OUTPUT record includes the delivered row count and actual recorded charges.

The errors record is written only when errors occurred. Each search error preserves the string fields code, query, page and message. A failed query does not discard results from other queries. Searches with no matches finish successfully with an empty dataset and no paper charges. A source failure can also finish successfully with an empty dataset and an error record describing the failure.

Use cases and limits

Use the actor to collect literature-review candidates, follow citation counts over time, assemble reading lists or connect papers to other datasets by DOI. Citation counts measure this index's coverage and can differ from counts shown elsewhere. They are snapshots, so comparisons should use the same index and record retrieval dates.

A paper can appear under multiple different queries. Those rows remain separate, with their own search_query and position. If your downstream analysis needs one row per work, combine on doi or openalex_id after preserving which queries found the paper. Broad subjects can have far more matches than the one hundred papers per query this actor returns; use more specific queries to explore a topic further.

Google Scholar Scraper compared with other Google Scholar APIs

Google does not offer an official Google Scholar API. The usual options are:

• Scraping the Google Scholar result page yourself. You get Google's own ordering, but the page answers automated traffic with captchas, so batch jobs stall and need constant maintenance.
• A paid SERP API. You get the Scholar result page as JSON, usually billed per search request rather than per paper, and abstracts are limited to the short snippet shown on the page.
• Calling the OpenAlex API directly. It is free, but you have to page through results, rebuild abstracts from the index's word-position format, format author lists and venues, and keep per-query rankings apart yourself.
• This actor. You send a list of queries and get finished paper rows with the complete abstract where one exists, a DOI, an open-access PDF link where one exists, and a citation count. You pay per delivered paper, and searches that find nothing cost nothing.

Choose a Google result-page scraper when the exact Google Scholar ranking matters to your analysis. Choose this actor when you need dependable paper metadata, citations and abstracts in volume.

FAQ

Does Google Scholar Scraper return Google's exact ordering?

Results use OpenAlex ordering and citation counts. The existing actor already uses that source. The data-source field engine identifies each row as openalex.

Is there an official Google Scholar API?

No. Google publishes no Scholar API, which is why scrapers and third-party APIs exist. This actor gives you the same kind of paper data through a stable scholarly index, without an API key of your own.

Do I need a separate API key?

You supply queries and run the actor in Apify. No source API key is part of the customer input.

Why is an abstract or PDF missing?

The index does not carry an abstract or PDF link for every work. The actor returns an empty abstract string or a null PDF URL when unavailable. A metadata result is still a delivered paper.

Can I search papers in another language?

Query text can contain any language. The optional language input restricts the publication language. Leave it empty to search across languages, including works without a language tag.

Are empty searches billed?

No paper event is charged when no paper rows are delivered. Empty and whitespace-only input also creates no paper events.

What happens to my existing saved tasks?

The old input names, defaults and paper fields are preserved. New academic fields are added alongside them, and the paper event price stays the same.