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

Extract Google Scholar author profiles, citation metrics, h-index, i10-index, publications, coauthors, and citation history in bulk.

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

## Pricing

$2.00 / 1,000 profile extracteds

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 Profiles Scraper

Turn public Google Scholar author profiles into clean, structured data: citation counts, h-index, i10-index, citation history, publications and coauthors, for one researcher or a long list.

Built for research offices, bibliometric analysts and anyone maintaining a researcher directory. Paste profile links or author IDs, then export to CSV, Excel or JSON, or pull the results through the API.

💰 **Pricing:** $2.00 per 1,000 profiles. No start fee, and you only pay for profiles that are delivered.

**Data source:** [Google Scholar](https://scholar.google.com/)

### What can you do with this Actor?

- **Academic research analytics:** compare citation impact across a group of researchers.
- **University research intelligence:** build a current view of a department's output and collaborators.
- **Scholar profile monitoring:** schedule regular snapshots and track how metrics change.
- **Citation analysis:** chart year-by-year citations for an author or a single paper.
- **Research collaboration mapping:** use coauthor lists to see who works with whom.
- **Bibliometric analysis:** feed publication lists into your own models and dashboards.
- **Researcher directory enrichment:** add affiliation, interests and metrics to the records you already keep.

### How to use this Actor

- 👉 **Register for a free Apify account** — no credit card required.
- 🎉 Just click [**Sign up free on Apify →**](https://console.apify.com/sign-up?fpr=1h3gvi) and complete a quick signup.
- 💰 A free Apify account includes $5 in monthly credits — enough to test this Actor.
- ⏳ Start on Apify's free plan, with no commitment or upfront payment required.
- 🎓 Open the Actor and paste Google Scholar profile URLs or author IDs.
- ▶️ Click **Start** and export the results to JSON, CSV, Excel, or use them through the API.

### Features

- **Flexible input:** profile URLs from any Scholar country domain, bare author IDs, or a dataset from an earlier run. Duplicates are removed automatically.
- **Lifetime and recent metrics:** citations, h-index and i10-index, with the exact recent window Scholar displays.
- **Citation history:** citations per year, with zero-citation years kept in place.
- **Your choice of depth:** metrics only, or up to 100 publications per profile, sorted by citations, year or title.
- **Publication details:** optionally open each paper for full author names, date, publisher, abstract, links and citations per year.
- **Coauthors:** the coauthors shown on the profile, with an option for the full list.
- **Clear outcomes:** every target gets a status, and failed, blocked or missing profiles are never charged.
- **Safe batches:** one bad profile never stops a run, and runs stop cleanly before their time limit.
- **Easy recovery:** every run saves a ready-to-paste input for the profiles worth retrying.
- **Three ready-made views:** Profiles, Publications and Coauthors, each as a clean table.

### Data fields

Each profile is one record. These are the fields most people use, and the All fields view shows the rest.

| Field | Description |
|---|---|
| `status` | Outcome for this target (see below) |
| `scholarId` | Google Scholar author ID |
| `name` | Author name |
| `affiliation` | Affiliation as written on the profile |
| `emailDomain` | Domain of the verified email, for example `mit.edu` |
| `verifiedEmail` | Whether Scholar shows a verified email domain |
| `homepage` | Homepage link |
| `interests` | Research interest labels |
| `profileImageUrl` | Profile photo, or null if the default avatar is shown |
| `citationsAll` | Lifetime citations |
| `citationsRecent` | Citations in the recent window |
| `hIndexAll` | Lifetime h-index |
| `hIndexRecent` | Recent h-index |
| `i10IndexAll` | Lifetime i10-index |
| `i10IndexRecent` | Recent i10-index |
| `recentPeriodLabel` | The window as shown by Scholar, for example `Since 2021` |
| `citationHistory` | Citations per year, as far back as Scholar's graph shows |
| `publicAccessAvailable` | Articles available under funding mandates, when shown. `publicAccessNotAvailable` holds the rest |
| `publications` | Publications with title, authors, year, venue, citation count and links |
| `publicationsTruncated` | True when your limit stopped collection and more publications exist |
| `coauthors` | Coauthors with name, ID, profile link, affiliation and email domain |
| `warnings` | Anything that reduced completeness for this record |
| `errorMessage` | Plain-English reason when a target did not succeed |
| `scrapedAt` | When the record was produced |

The `status` field tells you what happened:

| Status | Meaning | Charged |
|---|---|---|
| `success` | The profile and everything requested were delivered | Yes |
| `partial` | The profile was delivered, but an optional part failed. See `warnings` | Yes |
| `empty_profile` | The profile exists but has no metrics or articles | No |
| `not_found` | No public profile exists for this ID | No |
| `blocked` | Google refused the request. Run this ID again | No |
| `failed` | The profile could not be read after retries | No |
| `invalid_input` | The value was not a valid profile URL or author ID | No |
| `not_processed` | The run ended before reaching this profile | No |

Missing values are always `null` or an empty list. Nothing is guessed, and personal email addresses are never inferred from a domain.

### Input

Only one of `profileUrls`, `authorIds` or `inputDatasetId` is needed. Everything else has a sensible default.

| Input | Type | Description |
|---|---|---|
| `profileUrls` | array | Profile URLs. Bare author IDs also work here |
| `authorIds` | array | 12-character author IDs |
| `inputDatasetId` | string | ID of an Apify dataset holding URLs or IDs |
| `inputDatasetField` | string | Dataset field to read, if it is not detected automatically |
| `maxProfiles` | integer | Maximum profiles per run. Default 100, up to 10,000 |
| `maxPublicationsPerProfile` | integer | Publications per profile, from 0 (metrics only) to 100. Default 20 |
| `includePublications` | boolean | Collect publications. Default `true` |
| `publicationSort` | string | `citations`, `year`, `title` or `source`. Default citations |
| `includeCitationHistory` | boolean | Add citations per year. Default `true` |
| `includeCoauthors` | boolean | Add the coauthors shown on the profile. Default `true` |
| `includeAllCoauthors` | boolean | Fetch the full list when a profile shows its limit of 20. Default `false` |
| `includePublicationDetails` | boolean | Open each publication's page. Default `false` |
| `maxPublicationDetailsPerProfile` | integer | Detail pages per profile. Default 20, up to 100 |
| `maxConcurrency` | integer | Profiles processed at once. Default 2, up to 5 |
| `minRequestDelayMs` | integer | Minimum delay between requests. Default 1,000 |
| `maxRequestRetries` | integer | Retries after temporary errors. Default 2 |
| `requestTimeoutSecs` | integer | Timeout for one response. Default 30 |
| `proxyConfiguration` | object | Connection settings. Apify Proxy is required, and the default works for most runs |

Example input:

```json
{
  "profileUrls": ["https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en"],
  "authorIds": ["JicYPdAAAAAJ"],
  "maxPublicationsPerProfile": 20,
  "publicationSort": "citations",
  "includeCoauthors": true
}
```

### Output

Results go to the run's dataset, with one record per author. Open the **Profiles**, **Publications** or **Coauthors** view for a clean table, and export any of them as JSON, CSV, Excel or through the API. Nested data in the All fields view expands into many columns in a spreadsheet, so the three views are usually easier to work with. With publication details on, a Publications CSV also includes per-paper citation history columns.

#### Retrying unfinished profiles

If any profiles end as `blocked`, `failed` or `not_processed`, choose **Retry input** in the selector on the run's Output tab. It holds a ready-made input with each ID listed once and your settings kept. Paste it into a new run. You are only charged for the profiles delivered this time.

```json
{
  "authorIds": ["qc6CJjYAAAAJ", "JicYPdAAAAAJ"],
  "maxPublicationsPerProfile": 50
}
```

Profiles marked `not_found` or `invalid_input` are left out, because a retry would not change the result. The **Run summary** record holds the same IDs grouped by status, along with the run's totals.

#### Example record

Real output, shortened to one publication and one coauthor:

```json
{
  "status": "success",
  "errorCode": null,
  "errorMessage": null,
  "scholarId": "DhtAFkwAAAAJ",
  "name": "Kaiming He",
  "affiliation": "Associate Professor, EECS, MIT",
  "affiliationOrgId": "16345133980181568013",
  "emailDomain": "mit.edu",
  "verifiedEmail": true,
  "homepage": "https://people.csail.mit.edu/kaiming/",
  "interests": [
    "Computer Vision",
    "Machine Learning"
  ],
  "profileImageUrl": "https://scholar.googleusercontent.com/citations?view_op=view_photo&user=DhtAFkwAAAAJ&citpid=8",
  "profileUrl": "https://scholar.google.com/citations?user=DhtAFkwAAAAJ&hl=en",
  "sourceUrl": "https://scholar.google.com/citations?user=DhtAFkwAAAAJ&hl=en",
  "citationsAll": 894296,
  "citationsRecent": 707039,
  "hIndexAll": 78,
  "hIndexRecent": 74,
  "i10IndexAll": 95,
  "i10IndexRecent": 94,
  "recentPeriodLabel": "Since 2021",
  "recentPeriodStartYear": 2021,
  "citationHistory": [
    {
      "year": 2024,
      "citations": 130865
    },
    {
      "year": 2025,
      "citations": 132240
    },
    {
      "year": 2026,
      "citations": 105965
    }
  ],
  "publicAccessAvailable": 11,
  "publicAccessNotAvailable": 0,
  "publications": [
    {
      "ownerScholarId": "DhtAFkwAAAAJ",
      "ownerName": "Kaiming He",
      "title": "Deep Residual Learning for Image Recognition",
      "authors": "K He, X Zhang, S Ren, J Sun",
      "publicationYear": 2016,
      "publicationDate": null,
      "venue": "Computer Vision and Pattern Recognition (CVPR), 2016",
      "publisher": null,
      "volume": null,
      "issue": null,
      "pages": "2016",
      "description": null,
      "citationCount": 354124,
      "citationsMerged": false,
      "scholarPublicationId": "DhtAFkwAAAAJ:ALROH1vI_8AC",
      "scholarPublicationUrl": "https://scholar.google.com/citations?user=DhtAFkwAAAAJ&hl=en&view_op=view_citation&citation_for_view=DhtAFkwAAAAJ:ALROH1vI_8AC",
      "externalPublicationUrl": null,
      "pdfUrl": null,
      "citedByUrl": "https://scholar.google.com/scholar?oi=bibs&hl=en&cites=9281510746729853742,7487146795671115667,2689236077899720732,5801613056663068940,9229762417497317300,17634140231156417900,7546803073980351828,10835837808483619908,14586216232957520117,9942392906694851393,18372721534470382083,47763651013056423,17937211382055683225,2028843693838236151,5605570888801956403,16013406159877531928,7329882628777945228,9499035182050352470,15594360731912031688,7454386611891521023,2049745923102830674,2336648171815687686,3318125700009504314,15462043844848318371,17590291061863551079,4974310621250679772,1902020056034411164",
      "citationHistory": [],
      "detailsFetched": false
    }
  ],
  "publicationCountExtracted": 1,
  "publicationsTruncated": true,
  "coauthors": [
    {
      "ownerScholarId": "DhtAFkwAAAAJ",
      "ownerName": "Kaiming He",
      "name": "Jian Sun",
      "scholarId": "ALVSZAYAAAAJ",
      "profileUrl": "https://scholar.google.com/citations?user=ALVSZAYAAAAJ&hl=en",
      "affiliation": "Chief Scientist of Megvii, Managing Director of Megvii Research",
      "emailDomain": "megvii.com"
    }
  ],
  "coauthorCount": 1,
  "warnings": [],
  "scrapedAt": "2026-11-05T15:33:29.338Z"
}
```

### Pricing

| Event | Price | Per 1,000 |
|---|---|---|
| Profile extracted | $0.002 | $2.00 |

- You pay only for `success` and `partial` records. See the status table above.
- There is no start fee, and platform usage is included in the price.
- Publications, coauthors, citation history and publication details are included. A profile costs the same whichever options you choose.
- Example: 500 delivered profiles cost $1.00.
- Set a maximum charge on your run if you want a hard ceiling. The Actor stops cleanly when it is reached.

### Examples / Ready-to-use Tasks

#### Department citation snapshot

Metrics only, for a fast and low-cost overview of a group.

```json
{
  "authorIds": ["JicYPdAAAAAJ", "kukA0LcAAAAJ", "WLN3QrAAAAAJ"],
  "includePublications": false,
  "includeCoauthors": false
}
```

#### Recent output review

An author's 100 newest publications.

```json
{
  "authorIds": ["kukA0LcAAAAJ"],
  "maxPublicationsPerProfile": 100,
  "publicationSort": "year"
}
```

#### Collaboration map

Metrics plus every listed coauthor. Feed the coauthor IDs into your next run to grow the network one step at a time.

```json
{
  "authorIds": ["gLnCTgIAAAAJ"],
  "maxPublicationsPerProfile": 0,
  "includeAllCoauthors": true
}
```

#### Literature review with abstracts

The most cited papers of an author, with full metadata and abstracts.

```json
{
  "authorIds": ["JicYPdAAAAAJ"],
  "maxPublicationsPerProfile": 10,
  "includePublicationDetails": true,
  "maxPublicationDetailsPerProfile": 10
}
```

### API & Integrations

Run the Actor from the Apify API, a schedule, or tools such as Make, Zapier and n8n. Use a webhook to send finished runs to Google Sheets, a database or a dashboard.

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("zapticx/google-scholar-profiles-scraper").call(
    run_input={"authorIds": ["qc6CJjYAAAAJ"], "maxPublicationsPerProfile": 5}
)
for profile in client.dataset(run.default_dataset_id).iterate_items():
    print(profile["status"], profile["name"], profile["citationsAll"])
```

JavaScript:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('zapticx/google-scholar-profiles-scraper').call({
    authorIds: ['qc6CJjYAAAAJ'],
    maxPublicationsPerProfile: 5,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/zapticx~google-scholar-profiles-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"authorIds": ["qc6CJjYAAAAJ"], "maxPublicationsPerProfile": 5}'
```

### Limitations

- **Google may refuse some requests.** Expect some profiles to end as `blocked`. They are not charged, and running them again usually works. Full delivery cannot be promised, and the Actor does not solve CAPTCHAs. If many profiles in a row are refused, the run stops early.
- **Apify Proxy is required.** Scholar refuses direct requests from Apify's servers.
- **Public profiles only.** Private or removed profiles return `not_found`.
- **Up to 100 publications per profile.** `publicationsTruncated` shows when an author has more.
- **List data can be shortened.** Scholar's list can abbreviate authors and venues, and volume, issue and pages are filled only when they are clear. Publication details give the full text but take longer.
- **Large lists take time.** Raise the run timeout or split long lists. A run that reaches its limit stops cleanly and lists what it did not reach.

Built by **Zapticx** — AI automation and data solutions. [zapticx.com](https://zapticx.com)

### Search keywords

google scholar scraper, google scholar profiles scraper, google scholar api, apify google scholar, scholar author profile data, h-index extractor, i10-index data, citation metrics scraper, citation history data, academic publications scraper, coauthor network data, bibliometric data extraction, researcher directory data, university research analytics, google scholar data extraction

**Disclaimer**: This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by **Google LLC**.

# Actor input Schema

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

Google Scholar author profile URLs, for example https://scholar.google.com/citations?user=qc6CJjYAAAAJ\&hl=en. Country domains and extra URL parameters are fine. You can also paste bare author IDs here.

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

12-character Google Scholar author IDs: the value of user= in a profile URL, for example qc6CJjYAAAAJ. Duplicates across both lists are removed.

## `inputDatasetId` (type: `string`):

Optional. The ID of an Apify dataset holding profile URLs or author IDs, such as the output of an earlier run. Fields tried in order: profileUrl, scholarId, authorId, userId, url, id.

## `inputDatasetField` (type: `string`):

Optional. The field that holds the URL or ID, when it is not one of the names tried automatically.

## `maxProfiles` (type: `integer`):

Cost control. Only the first unique profiles up to this number are processed.

## `maxPublicationsPerProfile` (type: `integer`):

How many publications to collect for each author, from 0 (metrics only) to 100. Each profile uses one request, whatever the number. publicationsTruncated tells you when an author has more than your limit.

## `includePublications` (type: `boolean`):

Turn off for the fastest profile and metrics export.

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

The order Scholar lists publications in, which decides which ones are collected when a limit applies. Sorting is done by Scholar. Source order is the page's default order, which currently is the same as citation order.

## `includeCitationHistory` (type: `boolean`):

Adds citations per year from the profile's graph. Uses no extra requests.

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

Adds the coauthors shown on the profile. Uses no extra requests.

## `includeAllCoauthors` (type: `boolean`):

The profile shows at most 20 coauthors. This adds one request for each profile that reaches that limit, to collect the full list.

## `includePublicationDetails` (type: `boolean`):

Opens each publication's page for full author names, publication date, publisher, abstract, external link, PDF link and citations per year. Adds one request per publication, so runs take much longer.

## `maxPublicationDetailsPerProfile` (type: `integer`):

Limits the option above. The first publications in the chosen order are opened.

## `maxConcurrency` (type: `integer`):

Raising this does not raise the request rate, which is set by the delay below.

## `minRequestDelayMs` (type: `integer`):

The spacing between requests across the whole run. Lower values are faster and more likely to be rate limited.

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

Extra attempts after a timeout, a network error or a server error. A block is retried at most once, after a pause.

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

How long to wait for one response.

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

The connection used to reach Google Scholar. Apify Proxy is required, because Scholar refuses direct requests from Apify's servers. The default datacenter proxy is the cheapest option. You can switch to residential, or use your own proxies.

## Actor input object example

```json
{
  "profileUrls": [
    "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
    "https://scholar.google.com/citations?user=JicYPdAAAAAJ&hl=en",
    "https://scholar.google.com/citations?user=kukA0LcAAAAJ&hl=en"
  ],
  "maxProfiles": 100,
  "maxPublicationsPerProfile": 20,
  "includePublications": true,
  "publicationSort": "citations",
  "includeCitationHistory": true,
  "includeCoauthors": true,
  "includeAllCoauthors": false,
  "includePublicationDetails": false,
  "maxPublicationDetailsPerProfile": 20,
  "maxConcurrency": 2,
  "minRequestDelayMs": 1000,
  "maxRequestRetries": 2,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

No description

## `publications` (type: `string`):

No description

## `coauthors` (type: `string`):

No description

## `allFields` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

## `retryInput` (type: `string`):

Ready-to-paste input for the profiles worth running again.

# 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": [
        "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
        "https://scholar.google.com/citations?user=JicYPdAAAAAJ&hl=en",
        "https://scholar.google.com/citations?user=kukA0LcAAAAJ&hl=en"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("zapticx/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": [
        "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
        "https://scholar.google.com/citations?user=JicYPdAAAAAJ&hl=en",
        "https://scholar.google.com/citations?user=kukA0LcAAAAJ&hl=en",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("zapticx/google-scholar-profiles-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 '{
  "profileUrls": [
    "https://scholar.google.com/citations?user=qc6CJjYAAAAJ&hl=en",
    "https://scholar.google.com/citations?user=JicYPdAAAAAJ&hl=en",
    "https://scholar.google.com/citations?user=kukA0LcAAAAJ&hl=en"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call zapticx/google-scholar-profiles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zapticx/google-scholar-profiles-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/rtfgj8b93Afh7gSi8/builds/SmAJcqg1jhS4nqOch/openapi.json