# OpenCitations Scraper — Citations & References by DOI (`themineworks/opencitations-citation-graph`) Actor

Scrape the OpenCitations INDEX (1.6B links) by DOI. Get all citing papers, cited references, dates and self citation flags. No API key. Free tier. Works in Claude, ChatGPT and any MCP agent for citation graphs and literature reviews.

- **URL**: https://apify.com/themineworks/opencitations-citation-graph.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Other, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 citation scrapeds

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

## 📚 OpenCitations Scraper: Citation Graph & DOI References

### Overview

OpenCitations Scraper maps the citation network of any scientific paper. Give it one or more DOIs and get back every paper that cites the work (incoming citations), every paper the work cites (outgoing references), or both directions in a single run. Each record includes the citing DOI, the cited DOI, the citation date, and self-citation flags at both journal and author level. Powered by the OpenCitations INDEX (1.6 billion open citation links) with no API key required.

Until 2018, comprehensive citation data was locked behind Clarivate's Web of Science and Elsevier's Scopus at thousands of dollars per institutional seat. The OpenCitations INDEX changed that by assembling an open citation graph from Crossref reference deposits and other open sources, updated monthly. This actor wraps the OpenCitations INDEX API v2 into a clean, batch-capable scraper with automatic retry and rate-limit handling.

✅ No API key | ✅ 1.6B open citation links | ✅ Zero charge on empty runs | ✅ Pay only per citation link delivered | ✅ MCP-ready for AI agents

### Features

Look up citations, references, or both directions for any DOI in a single run.
Batch input: pass an array of DOIs and the actor processes each with polite rate limiting.
Self-citation detection: journal-level and author-level self-citation flags on every record.
Citation dates at month or year precision, so you can plot citation velocity over time.
Backward and forward reference chaining, the two classic snowballing methods for systematic reviews.

### How it works

The actor calls the OpenCitations INDEX API v2 (`api.opencitations.net/index/v2`) for each DOI you supply. For direction `citations`, it retrieves every paper that cites your DOI (incoming). For `references`, it retrieves every paper your DOI cites (outgoing). For `both`, it runs both queries and merges the output.

Requests are paced with a 400ms delay between calls to respect the OpenCitations rate limit. DOIs that return no matches or a 404 log a debug message and continue without failing the run. A final summary record reports total citation counts and the run timestamp.

Reliability posture: blocked, empty, or failed runs are never charged. You only pay for a citation link that was actually delivered to the dataset.

### 🧾 Input configuration

```json
{
  "dois": ["10.1038/nature12373", "10.1126/science.1231143"],
  "direction": "citations",
  "maxPerDoi": 200
}
```

### 📤 Output format

```json
{
  "source_doi": "10.1038/nature12373",
  "direction": "references",
  "citing_doi": "omid:br/06120344846 doi:10.1038/nature12373 openalex:W2159974629 pmid:23903748",
  "cited_doi": "omid:br/062102024238 doi:10.1103/physrevx.2.031001 openalex:W3101024234",
  "citation_date": "2013-07-31",
  "journal_sc": "no",
  "author_sc": "no",
  "scraped_at": "2026-07-15T04:18:57.149Z"
}
```

Every citation link contains these fields:

| Field | Description |
| --- | --- |
| 🧬 `source_doi` | The input DOI this citation link belongs to |
| ➡️ `direction` | `citations`, `references`, or `both` |
| 📥 `citing_doi` | Identifier of the citing paper. OpenCitations returns a composite string (OMID, DOI, OpenAlex ID, PMID where available), not a bare DOI |
| 📤 `cited_doi` | Identifier of the paper being cited, same composite format |
| 📅 `citation_date` | Citation date at month or year precision |
| 📰 `journal_sc` | `yes` if the citing and cited papers share a journal |
| 👤 `author_sc` | `yes` if there is author overlap between the papers |
| 🕒 `scraped_at` | ISO timestamp of capture |

### 💼 Common use cases

**Academic impact tracking**
Retrieve every paper that has cited your work or a seminal paper in your field without paying for Web of Science.
Plot citation velocity over months and years using `citation_date`.

**Systematic reviews**
Run backward reference chaining (what does this paper cite) and forward citation chaining (who has cited this paper since).
Feed a seed set of DOIs and expand it into a snowball corpus in one run.

**Scientometrics and bibliometrics**
Compute h-indexes, co-citation clusters, and citation velocity for funding bodies, universities, and publishers.
Filter out self-citations using `journal_sc` and `author_sc` for cleaner impact metrics.

**AI knowledge graphs**
Build structured citation edges between DOI nodes for graph neural networks or recommendation systems.
Combine with OpenAlex for enriched node metadata (title, authors, venue, concepts).

### 🚀 Getting started

1. Open the actor and paste a list of DOIs in the DOIs field (e.g. `["10.1038/nature12373"]`).
2. Pick a Citation direction: `citations`, `references`, or `both`.
3. Set Max results per DOI (1 to 2,000) to cap the fan-out for highly cited papers.
4. Click Save & Start.
5. Download as JSON, CSV, or Excel, or pull via API or MCP.

### FAQ

**Do I need an API key for OpenCitations?**
No. The OpenCitations INDEX API is fully open and requires no authentication. This actor works out of the box.

**How complete is the citation coverage?**
OpenCitations INDEX is built from Crossref reference deposits and other open sources. Coverage is excellent for journals that participate in Crossref's reference deposit program (most major publishers since ~2010) and incomplete for older literature and some regional publishers.

**What if a DOI has zero results?**
OpenCitations returns a 404 for DOIs not in its index. The actor logs a debug message and moves on to the next DOI without failing. Empty runs are never charged.

**Can I look up multiple DOIs in one run?**
Yes. Provide an array of DOIs in the `dois` input. The actor processes each sequentially with a 400ms delay. For very large batches (100+ DOIs), consider splitting across multiple runs.

**How am I charged?**
Pay per citation link at $0.003 per link. You pay only for citation links actually delivered to the dataset. There is no free tier. Runs that return zero citations are never charged.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/opencitations-citation-graph
```

Or call it programmatically with the Apify client:

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/opencitations-citation-graph').call({
  dois: ['10.1038/nature12373'],
  direction: 'citations',
  maxPerDoi: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your scholarly research pipeline

Citations are one edge type. Add the nodes and cross-references:

- **[OpenAlex Scraper](https://apify.com/themineworks/openalex-scholarly-works)**: 250M+ papers with authors, venues, abstracts, and concepts.
- **[Crossref Scraper](https://apify.com/themineworks/crossref)**: DOI metadata for any published work from Crossref.
- **[ClinicalTrials.gov Scraper](https://apify.com/themineworks/clinicaltrials-scraper)**: cross-check biomedical citations with the underlying trial registry.

Typical flow: search OpenAlex for a topic, feed the top-cited DOIs into this actor for backward and forward chaining, then enrich the resulting node set with Crossref metadata.

Found a bug or have a feature request? Open an issue on the actor's Apify Console page or reach out through the Apify profile.

# Actor input Schema

## `dois` (type: `array`):

List of DOIs to retrieve citations for. E.g. \["10.1038/nature12373"]

## `direction` (type: `string`):

citations = papers that CITE this DOI. references = papers this DOI CITES. both = retrieve both.

## `maxPerDoi` (type: `integer`):

Maximum citation records to retrieve per DOI.

## Actor input object example

```json
{
  "dois": [
    "10.1038/nature12373"
  ],
  "direction": "citations",
  "maxPerDoi": 50
}
```

# 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 = {
    "dois": [
        "10.1038/nature12373"
    ],
    "maxPerDoi": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/opencitations-citation-graph").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 = {
    "dois": ["10.1038/nature12373"],
    "maxPerDoi": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/opencitations-citation-graph").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 '{
  "dois": [
    "10.1038/nature12373"
  ],
  "maxPerDoi": 50
}' |
apify call themineworks/opencitations-citation-graph --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=themineworks/opencitations-citation-graph",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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