# Google Academic Scraper — Scholar + Patents (`brilliant_gum/google-academic-scraper`) Actor

One actor for Google Scholar (search, author profiles with h-index/i10/citations-by-year, cite formats) and Google Patents (search, full details, family, N-hop citation network). Pure HTTP, no login.

- **URL**: https://apify.com/brilliant\_gum/google-academic-scraper.md
- **Developed by:** [Yuliia Kulakova](https://apify.com/brilliant_gum) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.007 / result record

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Academic Scraper — Scholar + Patents

![Google Academic Scraper](https://api.apify.com/v2/key-value-stores/IuFu0Cw6PpOkNkDV7/records/google-academic-scraper-banner.png)

One actor for **Google Scholar** and **Google Patents**. No login, no cookies, no API keys — pure HTTP.

### What it does

**Google Scholar**

- **Search publications** — title, authors, venue, year, snippet, citation count, cited-by URL, "all versions" URL, related-articles URL, PDF link + type, cluster & result ids.
- **Author profiles** (by Scholar user id) — name, affiliation, verified email, interests, **h-index, i10-index, total citations (all / recent)**, **citations-per-year histogram**, **co-authors**, and the full **publication list** (title, venue, year, citations). Optional derived **analytics**: citation velocity, recent-2-year citations, h-index cross-check, top venues.
- **Cite formats** — MLA, APA, Chicago, Harvard, Vancouver + BibTeX / EndNote / RefMan / RefWorks export links.

**Google Patents**

- **Search** — free text + filters (assignee, inventor, country, date range by priority/filing/publication, status, type, language, sort). Returns patent number, title, snippet, inventor, assignee, all key dates, PDF, figures, total results available.
- **Details** — abstract, **full claims + count**, **CPC classifications** (with the full scheme/leaf tree), discrete **status** (GRANT/APPLICATION) and **type** (PATENT/DESIGN), **familyId**, **forward & backward citations** (with totals, assignee, dates, examiner-cited flag), **non-patent literature**, **patent family / worldwide applications**, **legal status & legal-events timeline**, PDF.
- **Family** and **N-hop citation network** — each node carries **citationHop** (graph distance from the seed) and **citationSeed** (origin patent), with global de-duplication across hops.

> Google Patents renders **CPC only** (no IPC codes exist in its markup for any patent), so this actor ships CPC and does not claim IPC.

Set `source` to `scholar`, `patents`, or `both`.

### Quick start

Scholar search:

```json
{ "source": "scholar", "scholarMode": "search", "queries": ["deep learning"], "maxResults": 20 }
```

Author profile:

```json
{ "source": "scholar", "scholarMode": "authorProfile", "authorIds": ["WLN3QrAAAAAJ"] }
```

Patents search:

```json
{ "source": "patents", "patentsMode": "search", "searchQuery": "neural network", "maxResults": 50 }
```

Patent details (deep):

```json
{ "source": "patents", "patentsMode": "details", "patentIds": ["US10000000B2"], "includeClaims": true }
```

### Output

One dataset item per result, tagged with `source` (`scholar`/`patents`) and `type`
(`scholar_search_result`, `scholar_author_profile`, `scholar_cite_formats`,
`patents_search_result`, `patents_details`). Blocked/failed requests are emitted as
`type:"error"` (with a `blockReason` when identifiable) — never silently dropped.

### Proxy

Proxies are configured **automatically** for reliable results — just make sure your Apify plan
includes proxy access. Google Scholar throttles heavily, so the actor retries automatically;
under very heavy throttling a run may occasionally return fewer results (failed requests are
emitted as `type:"error"`, never silently dropped — simply re-run to fill any gaps).

### Pricing

Pay-per-event:

| Event | Price |
|---|---|
| Actor start | $0.01 per run |
| Result | $0.007 per record delivered (Scholar or Patents) |

You're charged **only for successful records** — failed / blocked requests (`type:"error"`) are
never billed. Apify platform usage is billed to your own Apify account on top of these events.

### Support & feedback

Found a bug, or want another Scholar/Patents field or mode? **Open an issue** on the actor's Issues
tab, or leave a **rating and review** on the actor page — it genuinely helps and I read every one.

### Legal / ToS

This actor scrapes only publicly available Google Scholar and Google Patents pages.
It does not bypass any login or paywall and stores no personal data beyond what
Google publicly renders. You are responsible for compliance with Google's Terms of
Service and applicable law in your jurisdiction.

# Actor input Schema

## `source` (type: `string`):

Which Google service to scrape: Google Scholar, Google Patents, or both in one run.

## `scholarMode` (type: `string`):

Scholar task: 'search' (publications), 'authorProfile' (metrics by Scholar user id), or 'citeFormats' (MLA/APA/Chicago/BibTeX for results).

## `patentsMode` (type: `string`):

Patents task: 'search' (free-text + filters), 'details' (full record by patent id), 'family', 'citationNetwork' (N-hop), or by assignee / by inventor.

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

Search terms for Scholar search (one item per query). When source='both', each term is also searched on Google Patents.

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

Google Scholar user IDs for authorProfile mode (the 'user=' value in a profile URL, e.g. WLN3QrAAAAAJ).

## `citeResultIds` (type: `array`):

Result data-cid / cluster ids for citeFormats mode. Leave empty to derive them automatically from 'queries'.

## `includeCiteFormats` (type: `boolean`):

When citeFormats mode derives ids from queries, also emit the citation-format record for each result.

## `includeAnalytics` (type: `boolean`):

Add computed analytics to author profiles (citation velocity, recent-2y citations, h-index cross-check, top venues).

## `scholarYearFrom` (type: `integer`):

Lower bound publication year for Scholar search (Google as\_ylo).

## `scholarYearTo` (type: `integer`):

Upper bound publication year for Scholar search (Google as\_yhi).

## `scholarSortByDate` (type: `boolean`):

Sort Scholar search results by date instead of relevance (Google scisbd=1).

## `scholarPatentsCourts` (type: `string`):

Scholar result scope (Google as\_sdt): articles only, or include patents & case law.

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

Include Scholar entries that are citations only (no full record). Uncheck to hide them (as\_vis=1).

## `includeUnfilteredResults` (type: `boolean`):

Append filter=0 to include near-duplicate/omitted Scholar results.

## `noAutocorrect` (type: `boolean`):

Disable Scholar spelling auto-correction (Google nfpr=1).

## `languageResults` (type: `string`):

Restrict Scholar results to a language, e.g. lang\_en (Google lr).

## `countryResults` (type: `string`):

Restrict Scholar results to a country, e.g. countryUS (Google cr).

## `searchQuery` (type: `string`):

Free-text query for Google Patents search (e.g. 'neural network'). Alias of queries\[0] when source='patents'.

## `patentIds` (type: `array`):

Patent numbers for details / family / citationNetwork modes, e.g. US10000000B2.

## `assignee` (type: `string`):

Filter Google Patents by assignee / owner name (e.g. 'Apple Inc.'). Drives byAssignee mode.

## `inventor` (type: `string`):

Filter Google Patents by inventor name (e.g. 'Geoffrey Hinton'). Drives byInventor mode.

## `countryCodes` (type: `array`):

Restrict Google Patents results to these country/office codes, e.g. US, EP, WO, CN.

## `status` (type: `string`):

Filter by grant status.

## `patentType` (type: `string`):

Filter by patent type.

## `dateFrom` (type: `string`):

Lower date bound for Google Patents search (applies to the date type below).

## `dateTo` (type: `string`):

Upper date bound for Google Patents search (applies to the date type below).

## `dateType` (type: `string`):

Which date the dateFrom/dateTo range filters on.

## `patentSort` (type: `string`):

Sort order for Google Patents search results.

## `patentLanguage` (type: `string`):

Restrict Google Patents results to a language (e.g. ENGLISH).

## `enrichmentDepth` (type: `string`):

'basic' returns search fields only; 'deep' additionally fetches each patent's detail page for claims, CPC/IPC, citations and family.

## `includeFamily` (type: `boolean`):

Include worldwide application / family members in patent detail records.

## `includeClaims` (type: `boolean`):

Include full claim text in patent detail records (large). Claims count is always included.

## `citationDirection` (type: `string`):

Which citations to expand in citationNetwork mode.

## `citationDepth` (type: `integer`):

How many hops to expand in citationNetwork mode (1-3). Nodes are globally de-duplicated across hops.

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

Maximum results per query (Scholar) / per search query (Patents) / node cap (citation network).

## `maxPages` (type: `integer`):

Explicit page cap. If empty, derived from Max results (Scholar: 10/page, Patents: 100/page).

## `countryCode` (type: `string`):

Country of search for Scholar and proxy geolocation (Google gl, e.g. us).

## `languageCode` (type: `string`):

Interface language for Scholar/Patents (Google hl, e.g. en).

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

Proxy configuration. Leave as-is — proxies are tuned automatically for reliable results. Requires an Apify plan with proxy access.

## Actor input object example

```json
{
  "source": "scholar",
  "scholarMode": "search",
  "patentsMode": "search",
  "queries": [
    "deep learning"
  ],
  "authorIds": [
    "WLN3QrAAAAAJ"
  ],
  "includeCiteFormats": true,
  "includeAnalytics": true,
  "scholarSortByDate": false,
  "scholarPatentsCourts": "0,5",
  "includeCitations": true,
  "includeUnfilteredResults": false,
  "noAutocorrect": false,
  "searchQuery": "neural network",
  "patentIds": [
    "US10000000B2"
  ],
  "status": "ANY",
  "patentType": "ANY",
  "dateType": "priority",
  "patentSort": "relevance",
  "enrichmentDepth": "basic",
  "includeFamily": true,
  "includeClaims": true,
  "citationDirection": "both",
  "citationDepth": 1,
  "maxResults": 20,
  "countryCode": "us",
  "languageCode": "en",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "source": "scholar",
    "scholarMode": "search",
    "patentsMode": "search",
    "queries": [
        "deep learning"
    ],
    "authorIds": [
        "WLN3QrAAAAAJ"
    ],
    "searchQuery": "neural network",
    "patentIds": [
        "US10000000B2"
    ],
    "countryCode": "us",
    "languageCode": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("brilliant_gum/google-academic-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 = {
    "source": "scholar",
    "scholarMode": "search",
    "patentsMode": "search",
    "queries": ["deep learning"],
    "authorIds": ["WLN3QrAAAAAJ"],
    "searchQuery": "neural network",
    "patentIds": ["US10000000B2"],
    "countryCode": "us",
    "languageCode": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("brilliant_gum/google-academic-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 '{
  "source": "scholar",
  "scholarMode": "search",
  "patentsMode": "search",
  "queries": [
    "deep learning"
  ],
  "authorIds": [
    "WLN3QrAAAAAJ"
  ],
  "searchQuery": "neural network",
  "patentIds": [
    "US10000000B2"
  ],
  "countryCode": "us",
  "languageCode": "en"
}' |
apify call brilliant_gum/google-academic-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,brilliant_gum/google-academic-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/5MeneucC7DguPfteR/builds/id2HWaUyLwXayJjM8/openapi.json