# Google Scholar Scraper - Papers, Citations, Authors API (`topapi/google-scholar-scraper`) Actor

Google Scholar papers by keyword with year range, language, sort by date and patents; cited-by lists, all versions, author profiles with h-index, citations per year, co-authors and publications, and citation formats (APA, MLA, BibTeX). $0.33 per 1,000 papers.

- **URL**: https://apify.com/topapi/google-scholar-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Education, AI, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.33 / 1,000 papers

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Scholar Scraper - Papers, Citations, Authors API

Search Google Scholar and get every paper as a row: title, link, authors with their Scholar author IDs, journal or
conference, year, snippet, "Cited by" count, versions, and the PDF/HTML full-text link. Read "Cited by" lists, all versions
of a paper and related articles, pull full author profiles (citations, h-index, i10-index, citations per year, co-authors,
up to 2,000 publications), and add citation formats (APA, MLA, Chicago, Harvard, Vancouver plus BibTeX, EndNote, RefMan and
RefWorks links). No login, no API key.

### What you can scrape

| Input | What you get |
|---|---|
| **Search words** (`queries`) | Up to 1,000 papers per search (Scholar's own limit), 10 per Scholar page. Scholar operators work: `author:"hinton"`, `source:nature`, `"exact phrase"`, `intitle:`. |
| **Scholar links** (`startUrls`) | Any Scholar results link (search, "Cited by", "All versions", with every filter in the link kept) or an author profile link. |
| **Cited by** (`citedByIds`) | The papers citing a paper. Use the `citesId` of a paper row or the number in its "Cited by" link. |
| **All versions** (`clusterIds`) | Every version Scholar holds of a paper (`clusterId` of a paper row). |
| **Related articles** (`relatedTo`) | Scholar's related articles for a paper (`resultId` of a paper row). |
| **Author profiles** (`authorIds`) | One row per author: name, affiliation, verified email domain, homepage, interests, photo, citations / h-index / i10-index (all and since), citations per year, public-access counts, co-authors and publications. |
| **Citation formats** (`citationFormatsFor`) | Just the citation formats for a list of `resultId`s, one row each. |

### Filters

`yearFrom` / `yearTo` (Scholar's year range), `sortBy` (relevance, date = Scholar's "Sort by date": articles added in the
last year, newest first, or dateAll = everything by date), `includePatents`, `includeCitations` (keep or drop \[CITATION]
entries), `language` (interface language `hl`), `languageRestrict` (only papers in these languages, e.g. `lang_en` or
`lang_de|lang_fr`), `reviewArticlesOnly`, `similarResultsFilter`, `minCitationCount` (deliver and charge only papers cited at
least N times). Every filter Scholar can apply goes into Scholar's own query, so you only pay for rows that match.

The input names of other Google Scholar actors work too: `q`, `query`, `searchQueries`, `as_ylo`, `as_yhi`, `scisbd`,
`as_sdt` (7 = with patents), `as_vis`, `as_rr`, `lr`, `hl`, `filter`, `cites`, `cluster`, `author_id`, `profileUrls`,
`maxItems`, `max_pages`, `result_id`.

### Add-ons

- **Citation formats** (`includeCitationFormats`): every paper row gets `citationFormats` {mla, apa, chicago, harvard,
  vancouver} and `exportLinks` {bibtex, endnote, refman, refworks}. Charged per row that carries them.
- **Author profiles found in the results** (`authorProfilesFromResults` + `maxAuthorProfiles`): for each search, the full
  profile of the authors linked in the results and in Scholar's "User profiles for" box, as author rows.

### Monitoring

Turn on `monitorMode` and give a `monitorName`. A run then delivers only papers that no earlier run with the same name
delivered, and author rows whose citation count changed (`isNew: true`). Pair it with **Sort by date** for new-paper alerts
on a topic, or with `citedByIds` to catch new citations of your papers. A paper that an earlier run delivered without
citation formats comes back once when you turn the add-on on (`isNew: false`), billed for the citation formats only. The
memory is kept in a dataset named `google-scholar-scraper-monitor-<name>` in your account. A run that finds nothing new
charges nothing.

### Input example

```json
{
  "queries": ["large language models", "author:\"hinton\" deep learning"],
  "maxResults": 200,
  "yearFrom": 2022,
  "sortBy": "relevance",
  "includeCitationFormats": false,
  "authorIds": ["JicYPdAAAAAJ"],
  "maxPublications": 100
}
```

### Output

A paper row (real row from a test run, 2026-11-16):

```json
{
  "resultType": "paper",
  "searchType": "search",
  "query": "urban heat island",
  "position": 1,
  "page": 1,
  "title": "A review on the generation, determination and mitigation of Urban Heat Island",
  "link": "https://www.sciencedirect.com/science/article/pii/S1001074208600194",
  "type": null,
  "authors": "AM Rizwan, LYC Dennis",
  "authorList": [
    { "name": "AM Rizwan", "authorId": "d-G72tQAAAAJ", "profileUrl": "https://scholar.google.com/citations?user=d-G72tQAAAAJ&hl=en" },
    { "name": "LYC Dennis", "authorId": "bh5V1jYAAAAJ", "profileUrl": "https://scholar.google.com/citations?user=bh5V1jYAAAAJ&hl=en" }
  ],
  "publication": "Journal of environmental sciences",
  "year": 2008,
  "source": "Elsevier",
  "publicationInfo": "AM Rizwan, LYC Dennis - Journal of environmental sciences, 2008 - Elsevier",
  "snippet": "… temperature or heat content called Urban Heat Island (UHI) and … Urban Cool Island (UCI) or Urban Cool Valley (UCV). Higher urban heat is mainly caused due to the anthropogenic heat …",
  "citedByCount": 2956,
  "citesId": "9480472578232766132",
  "citedByUrl": "https://scholar.google.com/scholar?cites=9480472578232766132&as_sdt=2005&sciodt=0,5&hl=en",
  "relatedUrl": "https://scholar.google.com/scholar?q=related:tE5liJRnkYMJ:scholar.google.com/&scioq=urban+heat+island&hl=en&as_sdt=0,5",
  "versionsCount": 13,
  "versionsUrl": "https://scholar.google.com/scholar?cluster=9480472578232766132&hl=en&as_sdt=0,5",
  "clusterId": "9480472578232766132",
  "resultId": "tE5liJRnkYMJ",
  "resourceUrl": "http://www.upv.es/contenidos/CAMUNISO/info/U0564937.pdf",
  "resourceType": "PDF",
  "resourceSource": "upv.es",
  "citationFormats": null,
  "exportLinks": null,
  "totalResults": 1880000,
  "searchUrl": "https://scholar.google.com/scholar?q=urban+heat+island&hl=en&as_sdt=0%2C5",
  "isNew": null,
  "taskKey": "q:urban heat island",
  "scrapedAt": "2026-11-16T10:25:12.365Z"
}
```

With the citation formats add-on, a row also carries:

```json
{
  "citationFormats": {
    "mla": "Vaswani, Ashish, et al. \"Attention is all you need.\" Advances in neural information processing systems 30 (2017).",
    "apa": "Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., ... & Polosukhin, I. (2017). Attention is all you need. Advances in neural information processing systems, 30.",
    "chicago": "…", "harvard": "…", "vancouver": "…"
  },
  "exportLinks": { "bibtex": "https://scholar.googleusercontent.com/scholar.bib?q=info:…", "endnote": "…", "refman": "…", "refworks": "…" }
}
```

An author row has `authorId`, `name`, `affiliation`, `affiliationOrgId`, `verifiedEmailDomain`, `homepage`, `interests`,
`photoUrl`, `profileUrl`, `citationsAll`, `citationsSince`, `hIndexAll`, `hIndexSince`, `i10IndexAll`, `i10IndexSince`,
`metricsSinceYear`, `citationHistory` \[{year, citations}], `publicAccessAvailable`, `publicAccessNotAvailable`, `coauthors`
\[{name, authorId, affiliation, verifiedEmail, profileUrl}], `publications` \[{title, citationId, link, authors, publication,
year, citedByCount, citesId, citedByUrl}], `publicationsCount` and `hasMorePublications`.

#### How full the fields are

Measured on a 995-paper run ("reinforcement learning") and five 150-paper runs (15 topics), 2026-11-16:

| Field | Filled |
|---|---|
| title, link, authors, year, source, snippet, citedByCount, citesId, clusterId, resultId, relatedUrl, totalResults | 100% |
| versionsCount | 99% |
| publication (venue) | 95-96% (Scholar prints none for some books and web pages) |
| resourceUrl / resourceType (PDF or HTML link) | 80-91% (only when Scholar shows one) |
| type (BOOK, CITATION, PDF, HTML tag) | 14% (ordinary articles carry no tag) |
| authorList\[].authorId | 72-74% of authors (only authors with a Scholar profile) |

Author rows (5 profiles found through a search): affiliation, email domain, homepage, interests, metrics, citations per year
and publications 5/5; photo 4/5; co-authors 4/5 (one profile lists none).

### Pricing

Pay per row, no start fee:

| Event | Price |
|---|---|
| `paper` - one paper row | $0.00033 ($0.33 per 1,000) |
| `author-profile` - one author row, publications included | $0.0018 |
| `citation-formats` - add-on, per paper row that carries the formats | $0.0027 |

A search that finds nothing, a profile that does not exist and a monitor run with nothing new are not charged. Set a maximum
charge for the run and the actor stops cleanly at it, without delivering a row it cannot charge.

### Limits

- Scholar shows at most 1,000 results per search (100 pages of 10). Split a large topic with `yearFrom` / `yearTo` to get
  more.
- Scholar now asks for sign-in before its author search page ("search authors by name"), so author profiles are found by ID,
  by link, or through the authors linked in search results (`authorProfilesFromResults`).
- Scholar decides how it prints authors (initials, a shortened list ending in "…") and venues; the rows keep exactly what
  Scholar shows.
- Google limits how fast one connection can read Scholar. The actor spreads its requests over many connections and keeps
  going; a run that is refused on every connection stops with the rows it has and says so in its status.

### FAQ

**How do I get the papers that cite one paper?** Copy `citesId` from its row into `citedByIds`, or paste its "Cited by"
link into `startUrls`.

**Can I get an author's full publication list?** Yes: `authorIds` with `maxPublications` up to 2,000, in the order you
choose with `publicationSort` (most cited, newest, title).

**Can I export to BibTeX?** Turn on `includeCitationFormats`: each row gets a BibTeX link (plus EndNote, RefMan, RefWorks)
and the APA, MLA, Chicago, Harvard and Vancouver text.

# Actor input Schema

## `queries` (type: `array`):

One Google Scholar search per line. Scholar's own operators work: author:"hinton", source:nature, "exact phrase", intitle:review.

## `startUrls` (type: `array`):

Scholar search links (scholar.google.com/scholar?...), "Cited by" or "All versions" links, or author profile links (scholar.google.com/citations?user=...). Every filter in the link is kept.

## `citedByIds` (type: `array`):

The papers that cite a paper. Give the number from its "Cited by" link (cites=...), or the citesId field of a paper row.

## `clusterIds` (type: `array`):

Every version Scholar holds of a paper. Give the number from its "All versions" link (cluster=...), or the clusterId field of a paper row.

## `relatedTo` (type: `array`):

Scholar's "Related articles" for a paper. Give the 12-character resultId of a paper row.

## `authorIds` (type: `array`):

Google Scholar author IDs (the user= value of a profile link, e.g. JicYPdAAAAAJ) or full profile links. One row per author with metrics, citations per year, co-authors and publications.

## `citationFormatsFor` (type: `array`):

Just the citation formats (MLA, APA, Chicago, Harvard, Vancouver and BibTeX/EndNote/RefMan/RefWorks links) for these 12-character resultIds. One row per ID.

## `maxResults` (type: `integer`):

Papers to deliver for each search, cited-by list or versions list. Scholar shows at most 1,000 per search (10 per page).

## `yearFrom` (type: `integer`):

Only papers published in this year or later (Scholar's own as_ylo filter).

## `yearTo` (type: `integer`):

Only papers published in this year or earlier (as_yhi).

## `sortBy` (type: `string`):

Relevance (Scholar's default), Date (Scholar's "Sort by date": articles added in the last year, newest first) or Date, everything (all results by date).

## `includePatents` (type: `boolean`):

Add patents to the results (Scholar's "include patents").

## `includeCitations` (type: `boolean`):

Keep Scholar's \[CITATION] entries (works Scholar knows only from references). Off = as_vis=1.

## `language` (type: `string`):

Scholar's interface language code (hl), e.g. en, de, es, fr, pt-BR, zh-CN.

## `languageRestrict` (type: `string`):

Scholar's lr filter, e.g. lang_en, or lang_de|lang_fr for several.

## `reviewArticlesOnly` (type: `boolean`):

Scholar's "Review articles" filter (as_rr=1).

## `similarResultsFilter` (type: `boolean`):

Scholar's default filter that folds similar and omitted results. Off = filter=0.

## `minCitationCount` (type: `integer`):

Deliver and charge only papers cited at least this many times. Reads at most 3 extra pages per search to fill the count.

## `includeCitationFormats` (type: `boolean`):

Adds MLA, APA, Chicago, Harvard and Vancouver text plus BibTeX, EndNote, RefMan and RefWorks links to every paper row (one citation-formats event per row that gets them).

## `authorProfilesFromResults` (type: `boolean`):

For each search, also deliver the full profile (author-profile row) of authors linked in the results and of Scholar's "User profiles for" box, up to the maximum below.

## `maxAuthorProfiles` (type: `integer`):

Used with the option above.

## `maxPublications` (type: `integer`):

Publications listed in each author row (0 = metrics only). Profiles hold up to thousands; 100 are read per page.

## `publicationSort` (type: `string`):

The order the profile lists publications in, which decides which ones are collected.

## `includeCoauthors` (type: `boolean`):

The co-authors shown on the profile (name, ID, affiliation, email domain). No extra request.

## `monitorMode` (type: `boolean`):

Deliver only papers not delivered by an earlier run with the same monitor name, and author rows whose citation count changed. Pair it with Sort by date for new-paper alerts.

## `monitorName` (type: `string`):

Runs with the same name share one memory (kept in a dataset named google-scholar-scraper-monitor-<name> in your account).

## `proxyConfiguration` (type: `object`):

Leave empty: the actor uses its own Apify datacenter connection. Set only to route requests through your own proxies.

## Actor input object example

```json
{
  "queries": [
    "large language models"
  ],
  "maxResults": 20,
  "sortBy": "relevance",
  "includePatents": false,
  "includeCitations": true,
  "language": "en",
  "reviewArticlesOnly": false,
  "similarResultsFilter": true,
  "includeCitationFormats": false,
  "authorProfilesFromResults": false,
  "maxAuthorProfiles": 10,
  "maxPublications": 20,
  "publicationSort": "citations",
  "includeCoauthors": true,
  "monitorMode": false
}
```

# Actor output Schema

## `papers` (type: `string`):

No description

## `authors` (type: `string`):

No description

## `all` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "large language models"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("topapi/google-scholar-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["large language models"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("topapi/google-scholar-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "large language models"
  ],
  "maxResults": 20
}' |
apify call topapi/google-scholar-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,topapi/google-scholar-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rhy7z7YUR6HLxUmV4/builds/tVGELdBF5OoOr0d3U/openapi.json
