# Europe Pmc Literature Scraper (`bigibyte/europe-pmc-literature-scraper`) Actor

Search biomedical literature instantly in Europe PMC by subject or keyword. Extract article titles, authors, journals, DOIs, and citation flags into CSV, JSON, or Excel.

- **URL**: https://apify.com/bigibyte/europe-pmc-literature-scraper.md
- **Developed by:** [BigiByte](https://apify.com/bigibyte) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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

![Europe PMC Scraper for Biomedical Literature and PubMed Articles](https://images.bigibyte.com/cdn-cgi/image/width=800,quality=80,format=auto/apify-actors-covers/europe-pmc-scraper-cover.png)

### Europe PMC Scraper for Biomedical Literature and PubMed Articles

Search and extract peer-reviewed biomedical literature, preprints, and PubMed records directly from Europe PMC. **BigiByte**'s Europe PMC Scraper pulls article titles, author strings, journal details, open access flags, and citation counts into clean, structured datasets—saving you from manual database queries and pagination.

***

### What Does This Scraper Do?

Europe PMC provides comprehensive access to life sciences literature, combining published journal articles and preprint archives into a single index. This tool helps researchers, clinical teams, and academic librarians quickly gather targeted literature lists into clean tabular formats.

#### Key Use Cases

- **Literature Reviews:** Pull articles for specific research topics (e.g., malaria, oncology, immunology) with complete author strings and journal metadata in a single dataset.
- **Open Access Auditing:** Track open access status (`isOpenAccess`), PubMed Central flags (`inPMC`), and full-text availability alongside document DOIs.
- **Citation Tracking:** Extract citation counts (`citedByCount`) when available to measure impact and prioritize reading lists.
- **Research Operations:** Export capped batches of structured records straight into your data notebooks or local storage.
- **Scheduled Refreshes:** Automate periodic data collection runs to keep your reference lists current without manual intervention.

***

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | String | `search` | Defines the operation mode. |
| `query` | String | `malaria` | The search term or query string to match against records (e.g., `malaria`, `AUTH:Smith`). |
| `resultType` | String | `lite` | Detail level of results: `lite` or `core`. |
| `maxItems` | Integer | `100` | Maximum number of successful rows to collect (capped at 1,000). |
| `timeoutSecs` | Integer | `300` | Overall execution timeout in seconds. |
| `requestTimeoutSecs` | Integer | `30` | Timeout per network request in seconds. |
| `proxyConfiguration` | Object | *(off)* | Optional proxy. Leave off by default; enable Apify Proxy only if requests are blocked. |

#### Example Input

```json
{
  "mode": "search",
  "query": "malaria",
  "resultType": "lite",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

***

### Extracted Output Data

Each saved dataset row contains complete article metadata and open access indicators:

```json
{
  "id": "42575118",
  "source": "MED",
  "pmid": "42575118",
  "doi": "10.1016/j.langlo.2026.103984",
  "articleTitle": "Long-term mortality and risk of chronic kidney disease in children following severe malaria complicated by acute kidney injury...",
  "authorString": "Mellencamp KA, Namazzi R, Batte A, Kazinga C, Liepmann CD, Goings MJ, Opoka RO, Datta D, Ren J, Kalyesubula R, Bangirana P, Goldstein SL, Jo...",
  "journalTitle": "Lancet Glob Health",
  "pubYear": "2027",
  "journalIssn": "2214-109x",
  "pageInfo": "103984",
  "pubType": "journal article",
  "isOpenAccess": "N",
  "inEPMC": "N",
  "inPMC": "N",
  "scrapedAt": "2026-10-12T00:00:00Z"
}
```

#### Output Field Reference

| Field | Type | Description |
| --- | --- | --- |
| `id` | String | Unique Europe PMC record ID (duplicate IDs are automatically filtered out). |
| `source` | String | Source database code (e.g., `MED` for PubMed). |
| `pmid` | String | PubMed ID associated with the article. |
| `doi` | String | Digital Object Identifier for the publication. |
| `articleTitle` | String | Title of the research article. |
| `authorString` | String | Formatted string containing the list of authors. |
| `journalTitle` | String | Name of the publishing journal. |
| `pubYear` | String | Year of publication. |
| `journalIssn` | String | ISSN of the publishing journal. |
| `pageInfo` | String | Page numbers or article identifier numbers. |
| `pubType` | String | Publication classification type. |
| `isOpenAccess` | String | Flag indicating open access status (`Y` or `N`). |
| `inEPMC` / `inPMC` | String | Availability flags for Europe PMC and PubMed Central full text. |
| `citedByCount` | Integer | Citation count (included when returned by the record). |
| `scrapedAt` | String | UTC timestamp indicating when the item was collected. |
| `error` | String | Populated only if a specific request encounters an issue, ensuring the task continues running smoothly. |

***

### How Data Collection Works

- **Optimized Cursor Pagination:** Pages through results sequentially using robust cursor tracking to retrieve complete result sets up to your item cap.
- **Automatic Deduplication:** Duplicate record IDs are automatically filtered out to keep your dataset clean and unique.
- **Resilient Retries:** Built-in network error handling manages transient rate limits or server timeouts smoothly without crashing the entire run.
- **Flexible Export:** Download your collected research datasets anytime in JSON, CSV, or Excel formats.

***

### Related Tools & Custom Development

If you plan to map, cross-reference, or join biomedical literature records with external institutional datasets, quick CSV cleanups or metadata enrichment passes are standard next steps. **BigiByte** builds custom data scrapers, research feeds, and automated monitoring pipelines for academic institutions, medical libraries, and scientific publishers worldwide.

Need custom scheduled monitoring, specialized database integration, or tailored data pipelines? **BigiByte** builds custom scrapers tailored to your project: <https://bigibyte.com>

***

### Frequently Asked Questions

**How many articles can I extract per run?**

`maxItems` defaults to 100 records and can be adjusted up to a hard cap of 1,000 successful items per run.

**Can I export my data directly to CSV or Excel?**

Yes! Once a task completes, you can export the full dataset directly to JSON, CSV, or Excel format.

**Why are some fields like citation counts missing on certain records?**

Lite search results omit certain extended metadata fields unless specifically populated by the record. Switching to core results or checking specific records ensures maximum metadata coverage.

***

### Trademark Notice & Disclaimer

**Trademark Notice:** Europe PMC and related names, logos, and trademarks belong to their respective owners. Their use in this documentation is solely to identify the source of data and does not imply affiliation, sponsorship, endorsement, or partnership.

**Disclaimer:** This tool is an independent solution developed by BigiByte and is not officially affiliated with, endorsed by, or sponsored by Europe PMC. All data is collected from publicly accessible records. Users are responsible for adhering to the source's terms of service, rate limits, and licensing requirements.

***

### Is Web Scraping Legal?

This tool collects publicly available biomedical literature metadata. While extracting public records is standard practice, consider the following best practices:

- **Personal Data:** Author names and professional profiles constitute public research data. Ensure compliance with applicable privacy regulations (such as GDPR or CCPA) if storing or processing personal information.
- **Copyright & Reuse:** Abstract texts and publication records remain subject to copyright. Respect attribution requirements and reuse limitations specified by publishers and authors.
- **Legal Context:** This information provides general context and does not constitute legal advice.

To learn more, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

## `mode` (type: `string`):

search returns one row per Europe PMC article from the public search endpoint.

## `query` (type: `string`):

Europe PMC query string, such as malaria or AUTH:Smith. Sent as the query parameter.

## `resultType` (type: `string`):

lite returns the short record. core asks Europe PMC for the fuller record. Only lite and core are accepted.

## `maxItems` (type: `integer`):

Maximum successful article rows to save in one run. Values above 1000 are clamped to 1000.

## `timeoutSecs` (type: `integer`):

Stop scheduling new search requests after this many seconds. Rows already saved are kept.

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

Per-request timeout in seconds for each call to the Europe PMC search endpoint.

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

Optional proxy. Default is no proxy. The public search endpoint does not need a proxy, and proxies are not used to get around stated limits.

## Actor input object example

```json
{
  "mode": "search",
  "query": "malaria",
  "resultType": "lite",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetUrl` (type: `string`):

Default dataset for this run.

## `overview` (type: `string`):

Table of Europe PMC articles saved in this run.

# 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 = {
    "mode": "search",
    "query": "malaria",
    "resultType": "lite",
    "maxItems": 100,
    "timeoutSecs": 300,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigibyte/europe-pmc-literature-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 = {
    "mode": "search",
    "query": "malaria",
    "resultType": "lite",
    "maxItems": 100,
    "timeoutSecs": 300,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("bigibyte/europe-pmc-literature-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 '{
  "mode": "search",
  "query": "malaria",
  "resultType": "lite",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call bigibyte/europe-pmc-literature-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bigibyte/europe-pmc-literature-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/ZVtuYgwK42yDtZX6y/builds/VoMJpO8DLLFH7sHWf/openapi.json