# Google Scholar Profiles Scraper (`fetch_cat/google-scholar-profiles-scraper`) Actor

Export public Google Scholar profiles, current citation metrics, citation history, interests, coauthors, homepage and up to 100 publications by URL or user ID.

- **URL**: https://apify.com/fetch\_cat/google-scholar-profiles-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Education, Developer tools, AI
- **Stats:** 3 total users, 3 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.21 / 1,000 profile results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Google Scholar Profiles Scraper

Google Scholar Profiles Scraper exports public Google Scholar author profile data, citation metrics, interests, coauthors, and visible publication rows from profile URLs or user IDs.

Use it for researcher discovery, academic profile monitoring, citation snapshots, grant or hiring research, and structured profile datasets for analysis.

### At a glance

- **Extracts:** profile URL, user ID, name, affiliation, verified email domain, interests, citations, h-index, i10-index, publication rows, optional coauthors, and scrape timestamp.
- **Inputs:** Google Scholar profile URLs, Google Scholar user IDs, maximum publications per profile, coauthor toggle, and proxy configuration.
- **Best for:** academic researcher datasets, citation metric snapshots, coauthor exploration, institutional research, and talent or grant-review workflows.
- **Exports:** Apify dataset rows downloadable as CSV, JSON, Excel, or available through the API.
- **Login:** no Google account, cookies, or Google Scholar API key are required.

### Ready-to-run examples

Use these saved Store examples as starting points. Open any example to prefill the Actor input, then adjust URLs, keywords, limits, or filters for your own run.

- **[Extract Scholar Research Interest Tags](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/extract-scholar-interest-tags)**
- **[Compare Scholar h-index Metrics](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/compare-scholar-h-index-metrics)**
- **[Create an Academic RAG Dataset](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/create-academic-rag-dataset)**
- **[Export Scholar Profiles to Sheets](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/export-scholar-profiles-to-sheets)**
- **[Monitor Scholar Profile Metrics](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/monitor-scholar-profile-metrics)**
- **[Research Subject-Matter Experts](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples/research-subject-matter-experts)**
- **[View all ready-to-run examples](https://apify.com/fetch_cat/google-scholar-profiles-scraper/examples)** (12 examples)

### What can it do?

- **Export public Scholar profiles:** save author identity, affiliation, verified email domain, research interests, and public profile URLs.
- **Track citation metrics:** collect total and since-2019 citations, h-index, and i10-index values visible on the profile.
- **Capture publication rows:** include visible publication titles, authors, venues, years, citation counts, and publication links up to your configured limit.
- **Collect coauthor context:** optionally save visible coauthor cards for lightweight research-network mapping.

### Common workflows

- **Build researcher shortlists:** export profile metadata, citation metrics, interests, and affiliation text for candidate review.
- **Monitor profile metrics:** schedule repeat runs for known user IDs and compare citation or h-index changes downstream.
- **Capture publication samples:** limit `maxPublications` to the number of visible rows you need for ranking or review.
- **Explore coauthor networks:** enable `includeCoauthors` to collect visible coauthor cards from public profiles.

### Input configuration

| Setting | JSON key | Description |
| --- | --- | --- |
| Google Scholar profile URLs | `profileUrls` | Public Google Scholar profile URLs. You can also paste bare user IDs. |
| Google Scholar user IDs | `userIds` | User IDs from the `user=` URL parameter when you have IDs instead of full URLs. |
| Maximum publications per profile | `maxPublications` | Maximum visible publication rows to include for each author profile. The Actor caps this at 100. |
| Include visible coauthors | `includeCoauthors` | Extract visible coauthor cards shown on the public profile when available. |
| Request retries | `maxRequestRetries` | Retry temporary errors and Scholar challenges with fresh proxy sessions, up to five additional attempts. |
| Request timeout | `requestTimeoutSecs` | Bound each Scholar request from 5 to 120 seconds. |
| Processing safety limit | `runTimeSecs` | Stop admitting new profiles before the run timeout and preserve remaining profile URLs in `PENDING_PROFILES`. |
| Proxy configuration | `proxyConfiguration` | Optional proxy settings. Google Scholar often blocks cloud datacenter traffic, so residential proxy can improve reliability. |

If both `profileUrls` and `userIds` are omitted, the Actor runs the example profile from the input form. An interrupted run can be resurrected on the same storage: it restores `PENDING_PROFILES`, skips profile IDs already in the dataset, and does not add a second start fee.

### Example input

```json
{
  "userIds": ["qc6CJjYAAAAJ"],
  "maxPublications": 10,
  "includeCoauthors": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output fields

| Field | Description |
| --- | --- |
| `profileUrl`, `userId` | Public Google Scholar profile URL and user ID when available. |
| `name`, `affiliation`, `verifiedEmailDomain` | Visible profile identity and affiliation fields. |
| `interests` | Public research interest labels shown on the profile. |
| `citations`, `citationsSince2019` | Total and since-2019 citation counts when visible. |
| `hIndex`, `hIndexSince2019` | Total and since-2019 h-index values when visible. |
| `i10Index`, `i10IndexSince2019` | Total and since-2019 i10-index values when visible. |
| `publications` | Visible publication rows with title, authors, venue, year, citation count, and URL when available. |
| `publicationCount` | Number of publication rows saved for the profile. |
| `coauthors` | Visible coauthor cards when `includeCoauthors` is enabled. |
| `scrapedAt` | Timestamp when the profile was scraped. |

### Example output

```json
{
  "profileUrl": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
  "userId": "qc6CJjYAAAAJ",
  "name": "Example Scholar",
  "affiliation": "Example University",
  "verifiedEmailDomain": "example.edu",
  "interests": ["machine learning", "data mining"],
  "citations": 12345,
  "hIndex": 42,
  "i10Index": 100,
  "publications": [
    {
      "title": "Example publication title",
      "authors": "A. Scholar, B. Coauthor",
      "venue": "Example Journal",
      "year": 2024,
      "citations": 25,
      "url": "https://scholar.google.com/citations?view_op=view_citation&citation_for_view=example"
    }
  ],
  "publicationCount": 1,
  "scrapedAt": "2026-07-03T09:00:00.000Z"
}
```

### Pricing

This Actor uses Apify pay-per-event pricing. The prices below come from the current Actor pricing configuration. Apify public plans map to Store discount tiers, so the table shows both the user-facing plan context and the pricing tier name. The final price shown in Apify depends on the user account plan and any custom agreement.

| Event | What is charged | Price |
| --- | --- | ---: |
| `start` | One-time fee per run | $0.005 |

| Event | What is charged | Free / no discount | Starter / Bronze | Scale / Silver | Business / Gold | Custom / Platinum | Custom / Diamond |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |
| `result` | Per Google Scholar profile saved to the dataset | $2.326 / 1,000 | $2.0226 / 1,000 | $1.5776 / 1,000 | $1.2135 / 1,000 | $0.80903 / 1,000 | $0.56632 / 1,000 |

Apify may also charge platform usage for compute, storage, proxies, or data transfer outside this Actor pricing. Check the Actor run and the Apify Pricing tab for the exact cost shown to your account.

### Tips for best results

- **Use user IDs for stable inputs:** the `user=` value is the cleanest identifier for repeat runs.
- **Keep publication limits realistic:** capture only the rows you need; larger profile pages take longer.
- **Enable residential proxy if challenged:** Google Scholar often blocks cloud datacenter traffic.
- **Schedule gently:** repeated high-volume runs can increase the chance of challenge pages.

### Limits and caveats

- **Only public profile data is collected:** private data, login-only data, PDFs, and full paper text are not scraped.
- **Google Scholar can block requests:** the Actor stops with a clear challenge/rate-limit error when Scholar returns a block page.
- **Metrics are page snapshots:** citation counts and indexes reflect what was visible at scrape time.
- **Publication rows are limited:** the Actor captures visible rows from the profile up to `maxPublications`.

### API usage

Run from the Apify API or SDK with the same input keys shown above.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/google-scholar-profiles-scraper').call({
  userIds: ['qc6CJjYAAAAJ'],
  maxPublications: 10,
  includeCoauthors: true
});
console.log(run.defaultDatasetId);
```

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/google-scholar-profiles-scraper').call(run_input={
    'userIds': ['qc6CJjYAAAAJ'], 'maxPublications': 10, 'includeCoauthors': True
})
print(run['defaultDatasetId'])
```

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~google-scholar-profiles-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"userIds":["qc6CJjYAAAAJ"],"maxPublications":10,"includeCoauthors":true}'
```

### MCP and AI agents

For AI agents, use the official Apify MCP server. The focused single-Actor URL is:

```text
https://mcp.apify.com?tools=fetch_cat/google-scholar-profiles-scraper
```

The default MCP server can search and run Actors. The focused URL exposes this Actor directly to clients that support tool-scoped MCP connections.

Claude Code setup:

```bash
claude mcp add apify-google-scholar-profiles "https://mcp.apify.com?tools=fetch_cat/google-scholar-profiles-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-google-scholar-profiles": {
      "url": "https://mcp.apify.com?tools=fetch_cat/google-scholar-profiles-scraper"
    }
  }
}
```

Example prompts:

- “Compare citation metrics for these public Google Scholar user IDs.”
- “Extract publication rows for this Scholar profile and return the dataset link.”

### FAQ

**Can I export Scholar profile data to CSV, Excel, JSON, or API?** Yes. Apify datasets support all of those access paths.

**Does this require a Google account?** No. It reads public Google Scholar profile pages.

**Why did my run stop with a challenge message?** Google Scholar returned a rate-limit or challenge page. Try a smaller run, slower schedule, or residential proxy.

**Can this scrape Google Scholar search results?** No. This Actor focuses on public author profile URLs and user IDs.

**Why are some publication fields empty?** Google Scholar does not expose every field for every visible publication row.

### Related actors

- [Google News Scraper](https://apify.com/fetch_cat/google-news-scraper)
- [Google Play Apps Scraper](https://apify.com/fetch_cat/google-play-apps-scraper)
- [Google Play Reviews Scraper](https://apify.com/fetch_cat/google-play-reviews-scraper)
- [Google Ads Transparency Center Scraper](https://apify.com/fetch_cat/google-ads-transparency-scraper)

### Support

If a run fails, returns no data, or a field looks wrong, open an issue from the Actor page.

Please include the Apify run ID or run URL, input JSON, one example public URL, query, or input item, what you expected, and what the dataset returned. Small reproducible inputs make parsing or site-layout issues much faster to fix.

### Privacy and data handling

This Actor runs with Apify limited permissions and only processes data needed for the documented run. It uses search/query inputs and public search, trend, app, patent, news, or profile results to produce the output dataset and sends requests to public Google Scholar Profiles pages/endpoints; results are stored in Apify run storage for your account. FetchCat does not use your inputs or outputs for advertising, does not use them for model training, and does not retain them outside the Apify run except for transient support debugging when you explicitly share run details. You are responsible for using the Actor lawfully, respecting the target site's terms, and avoiding unnecessary personal or sensitive data in inputs.

# Actor input Schema

## `profileUrls` (type: `array`):

Public Google Scholar author profile URLs, for example https://scholar.google.com/citations?user=qc6CJjYAAAAJ\&hl=en. You can also paste bare user IDs.

## `userIds` (type: `array`):

Optional Google Scholar user IDs from the `user=` URL parameter. Use this when you have IDs instead of full URLs.

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

Maximum number of visible publication rows to include for each author profile.

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

Extract the visible coauthor cards shown on the public profile when available.

## `maxRequestRetries` (type: `integer`):

Additional attempts for each profile after a temporary error or Scholar challenge. Each attempt uses a fresh proxy session.

## `requestTimeoutSecs` (type: `integer`):

Maximum time to wait for one Scholar response before retrying.

## `runTimeSecs` (type: `integer`):

Stop starting new profiles after this time and return any profiles already saved. The platform timeout and a cleanup reserve are also enforced.

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

Proxy settings. Google Scholar often blocks cloud datacenter traffic, so the working prefill uses Apify residential proxy. Fresh sessions are used for retries.

## Actor input object example

```json
{
  "profileUrls": [
    {
      "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
    }
  ],
  "userIds": [],
  "maxPublications": 10,
  "includeCoauthors": true,
  "maxRequestRetries": 2,
  "requestTimeoutSecs": 30,
  "runTimeSecs": 270,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "profileUrls": [
        {
            "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
        }
    ],
    "userIds": [],
    "maxPublications": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/google-scholar-profiles-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 = {
    "profileUrls": [{ "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en" }],
    "userIds": [],
    "maxPublications": 10,
}

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

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

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

```

## CLI example

```bash
echo '{
  "profileUrls": [
    {
      "url": "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"
    }
  ],
  "userIds": [],
  "maxPublications": 10
}' |
apify call fetch_cat/google-scholar-profiles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/google-scholar-profiles-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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