# Europe PMC Literature Search: Articles & Preprints (`cliqtomedia/europe-pmc-literature-search`) Actor

Search Europe PMC articles and preprints with dates and open-access filters. Export identifiers, abstracts, licenses and full-text links, or compare snapshots to find new and updated publications.

- **URL**: https://apify.com/cliqtomedia/europe-pmc-literature-search.md
- **Developed by:** [Cliqto Media](https://apify.com/cliqtomedia) (community)
- **Categories:** Developer tools, Other
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.26 / 1,000 publications

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

Search Europe PMC for biomedical articles and preprints and get one Dataset row per publication: identifiers (PMID, PMCID, DOI), title, authors, journal, dates, abstract, license and full-text links. Pass a previous snapshot to find new or updated records. No Europe PMC API key or login is needed; a typical 25-record search takes a few seconds and costs $0.085 on the FREE tier.

![Europe PMC search, publication metadata and snapshot comparison](https://api.apify.com/v2/key-value-stores/3mFPhttce33b1iNIM/records/README-BANNER.png)

[What it does](#what-it-does) · [Quick start](#quick-start) · [Use cases](#use-cases) · [Input](#input) · [Output](#output) · [Monitoring](#monitoring) · [Pricing](#pricing) · [Limits and data rights](#limits-and-data-rights) · [API and AI agents](#api-and-ai-agents) · [Troubleshooting](#troubleshooting) · [FAQ](#faq) · [Support](#support)

### What it does

The Actor sends your query to the public Europe PMC REST search, adds your date, source and open-access filters, and returns matching publications newest first. Each row is one Europe PMC record (`source:id`), with source metadata kept as is. A key-value store record `SNAPSHOT` lists the known identities and content fingerprints, so the next run can mark rows as `new`, `updated` or `unchanged`.

#### Good fit

- Literature surveillance: new papers or preprints on a topic in the last N days.
- Building a citation list or spreadsheet with DOI, PMID, PMCID, license and links.
- Checking which records are open access and under which license before reuse.
- Recurring monitoring of one query with a saved snapshot.

#### Not a fit / limits

- Full text download: the Actor returns full-text links but does not fetch articles.
- More than 500 records per run, or a complete history of a topic.
- DOI-based deduplication: the same article in MED and PMC stays as two rows.
- Medical conclusions, ranking by quality or relevance scoring.

### Quick start

1. Open the **Input** tab. The form is prefilled with the CRISPR example below.
2. Click **Start**.
3. Open **Publications** in the Dataset. Check `title`, `pmcid`, `pubDate` and `license`. Full-text links (`fullTextUrls`) and the other fields are in the full JSON, CSV or Excel export.
4. Open **Run summary** to check counts, source matches and limits.

```json
{
  "query": "CRISPR",
  "lastDays": 30,
  "openAccessOnly": true,
  "source": "ALL",
  "maxResults": 25,
  "onlyNew": false
}
```

Expected result: 25 open-access publications first published in the last 30 UTC days, including today. The newest records are often fresh PubMed Central entries: they usually have `pmcid` and `license`, while `doi`, `pmid` and `abstractText` can still be `null` because the source has not added them yet.

### Use cases

| Buyer job | Input path | Output entity | Key fields | Next step |
| --- | --- | --- | --- | --- |
| New research on a topic | `query` + `lastDays` | Publication | `title`, `pubDate`, `doi`, `sourceUrl` | Export CSV or read via API |
| Open-access reuse check | `query` + `openAccessOnly: true` | Publication | `isOpenAccess`, `license`, `fullTextUrls` | Check license before reuse |
| Preprint tracking | `source: "PPR"` | Publication | `isPreprint`, `title`, `firstIndexDate` | Export or monitor |
| Fixed review period | `dateFrom` + `dateTo` | Publication | `pmid`, `doi`, `pubTypes`, `abstractText` | Screening spreadsheet |
| Repeat monitoring | `previousSnapshot` + `onlyNew` | Publication with change type | `changeType`, `fingerprint`, `citedByCount` | Save new `SNAPSHOT` |

### Input

| Field | Type | Required | Default / prefill | Allowed values | Effect |
| --- | --- | --- | --- | --- | --- |
| `query` | string | yes | prefill `CRISPR` | 1–2,000 characters, plain text or [Europe PMC search syntax](https://europepmc.org/RestfulWebService) | Search text, e.g. `CRISPR`, `TITLE:"base editing"`, `AUTH:"Doudna J"`. Blank text is rejected before source access. |
| `lastDays` | integer | no | none; prefill `30` | 1–3650 | Rolling window of first publication dates in UTC days, including today. Do not combine with `dateFrom`/`dateTo`. |
| `dateFrom` | string | no | none | `YYYY-MM-DD` | Inclusive start of first publication date. |
| `dateTo` | string | no | none | `YYYY-MM-DD`, on or after `dateFrom` | Inclusive end of first publication date. |
| `openAccessOnly` | boolean | no | `false`; prefill `true` | true / false | Adds `OPEN_ACCESS:Y`. Open access does not mean every reuse is allowed. |
| `source` | string | no | `ALL` | `ALL`, `MED` (PubMed), `PMC` (PubMed Central), `PPR` (preprints) | Limits the Europe PMC source. `ALL` also includes other Europe PMC source types. |
| `maxResults` | integer | no | `25` | 1–500 | Number of unique records to inspect. Pagination stops here even if `onlyNew` emits fewer rows. |
| `previousSnapshot` | object | no | none | The complete `SNAPSHOT` JSON (up to 5,000 records) from an earlier run with the same query and filters | Enables `new` / `updated` / `unchanged` classification. Do not paste Dataset rows. |
| `onlyNew` | boolean | no | `false` | true / false | With a baseline, emit only records that are new to it. Updated records are not emitted and keep their old fingerprint in `SNAPSHOT`. Without a baseline every record is new. |

The query and added filters are joined with AND. Results are sorted by first publication date, newest first. Invalid input (blank query, `lastDays` together with dates, `dateFrom` after `dateTo`, a malformed snapshot) fails as `INVALID_INPUT` with no charge.

More examples:

```json
{"query":"CRISPR","source":"PPR","maxResults":10}
```

Ten newest CRISPR preprints; `isPreprint` is true and `journal` may be `null`.

```json
{"query":"CRISPR","dateFrom":"2026-01-01","dateTo":"2026-06-30","maxResults":100}
```

Up to 100 records for a fixed review period. Explicit dates keep the window stable between runs.

### Output

Each Dataset item is one publication. The **Publications** view shows titles, source, dates, authors, identifiers, access, license and change type. The **Monitoring** view shows identity, change type, citation count, preprint flag and fetch time. JSON export includes all fields.

| Field | Type | Can be null? | Meaning |
| --- | --- | --- | --- |
| `key` | string | no | Stable `source:id` key, e.g. `PMC:PMC9467582`. |
| `id`, `source` | string | no | Original Europe PMC identifier and source (`MED`, `PMC`, `PPR`, …). |
| `pmid`, `pmcid`, `doi` | string | yes | PubMed, PubMed Central and DOI identifiers. `null` when the source has none yet. |
| `title` | string | no | Source title. |
| `authors` | array of strings | no (can be empty) | Author names. |
| `authorString` | string | yes | Author display text from the source. |
| `journal` | string | yes | Journal title. Preprints may have none. |
| `pubYear` | integer | yes | Source publication year. |
| `pubDate`, `firstIndexDate` | string (`YYYY-MM-DD`) | yes | First publication date and first indexing date. |
| `pubTypes` | array of strings | no (can be empty) | Publication type labels, e.g. `Journal Article`, `Preprint`. |
| `abstractText` | string | yes | Abstract when provided. Can contain HTML markup; not full text. |
| `isPreprint` | boolean | no | True for `PPR` or a `Preprint` publication type. |
| `isOpenAccess` | boolean | yes | Source open-access flag; `null` when the source does not say. |
| `license` | string | yes | Article license, e.g. `cc by`. `null` means unknown, not a default CC-BY grant. |
| `citedByCount` | integer | yes | Source citation count. `0` and `null` mean different things. |
| `fullTextUrls` | array of objects | no (can be empty) | Links with `url`, `site`, `availability`, `documentStyle`. Some require a subscription. Not fetched by the Actor. |
| `provider` | string | no | Always `Europe PMC`. |
| `sourceUrl` | string | no | Europe PMC record page. |
| `fetchedAt` | string (ISO time) | no | When this run read the record. |
| `sourceUpdatedAt` | string | yes | Source `dateOfRevision`; not the fetch or indexing time. |
| `changeType` | string | no | `new`, `updated` or `unchanged`. Citation count changes count as updates. |
| `fingerprint` | string | no | SHA-256 of normalized content, used for comparison. |

Example row from the Quick start input (`abstractText` was `null`; two of four links trimmed):

```json
{
  "key": "PMC:PMC9467582",
  "id": "PMC9467582",
  "source": "PMC",
  "pmid": null,
  "pmcid": "PMC9467582",
  "doi": null,
  "title": "Prion 2022 Conference abstracts: pushing the boundaries",
  "authors": ["Zerr I"],
  "authorString": "Zerr I.",
  "journal": "Prion",
  "pubYear": null,
  "pubDate": "2026-10-12",
  "firstIndexDate": "2026-10-12",
  "pubTypes": ["Abstract"],
  "abstractText": null,
  "isPreprint": false,
  "isOpenAccess": true,
  "license": "cc by",
  "citedByCount": 0,
  "fullTextUrls": [
    {"url": "https://europepmc.org/articles/PMC9467582", "site": "Europe_PMC", "availability": "Free", "documentStyle": "html"},
    {"url": "https://europepmc.org/articles/PMC9467582?pdf=render", "site": "Europe_PMC", "availability": "Free", "documentStyle": "pdf"}
  ],
  "provider": "Europe PMC",
  "sourceUrl": "https://europepmc.org/article/PMC/PMC9467582",
  "fetchedAt": "2026-10-13T08:53:26.062Z",
  "sourceUpdatedAt": "2026-10-12",
  "changeType": "new",
  "fingerprint": "246e0e5a9fd93eff41e313e76282f946e67484bb15b83a8a476cd981598af7cc"
}
```

Key-value store records:

- `RUN_SUMMARY`: status, inspected and emitted counts, source matches, requests, change counts and limits. `skippedMalformed` counts source records skipped because they lacked an ID, source or title or had unexpected field types; the other rows of that page are kept. A page with no usable record stops the run with `PROVIDER_SCHEMA_DRIFT`.
- `SNAPSHOT`: identity and fingerprint list for the next `previousSnapshot`: records seen in this run plus earlier baseline records not seen this time, up to 5,000. `incomplete` is `true` when the run stopped early; such a snapshot is still safe to reuse, because it holds only rows that were delivered (or already known).

| Situation | What you get | Run status |
| --- | --- | --- |
| Normal search | Rows in the Dataset, `RUN_SUMMARY` status `COMPLETE`; `limitReached: true` if more matches existed | SUCCEEDED |
| Valid search with no matches | Empty Dataset, status `NOT_FOUND` | SUCCEEDED |
| Monitoring with nothing new | Zero emitted rows with `onlyNew: true`; `RUN_SUMMARY` shows the unchanged count | SUCCEEDED |
| Your maximum cost per run was reached | Rows that fit the limit, status `PARTIAL`, `reason: "CHARGE_LIMIT"` | SUCCEEDED |
| Source stopped after some rows | Rows so far, status `PARTIAL` with the stop code in `reason` (see below) | FAILED |
| Source failure before any row | No rows, status `ERROR` with the stop code in `reason` | FAILED |
| Rejected input | No rows, status `INVALID_INPUT` | FAILED |

Stop codes: `PROVIDER_*` (Europe PMC answered with an error, timed out, was unavailable or returned unexpected data), `SOURCE_DEADLINE` (the 180-second source time budget ran out), `REQUEST_LIMIT` (25 source requests used), `RETRY_AFTER_EXCEEDS_BUDGET` (the source asked to wait more than 10 seconds), `TOTAL_RESPONSE_BYTES_LIMIT` / `RESPONSE_TOO_LARGE` (response size limits), `CANCELLED` (you aborted the run).

### Monitoring

1. Run your query and save the complete `SNAPSHOT` JSON.
2. Paste it into `previousSnapshot` for the next run. Keep the same query, source and date strategy.
3. Leave `onlyNew: false` to see new, updated and unchanged rows, or set it to true to emit new records only.
4. Save the new `SNAPSHOT` for the next comparison.

A rolling `lastDays` window may advance without changing snapshot scope. Changing the query, filters or explicit dates requires a fresh baseline. Changing `maxResults` is allowed, but records outside the prior selection count as new. A record absent from the next selection is **not** marked deleted: it stays in the new snapshot unchanged, so it is not reported again as `new` when it reappears. The snapshot keeps up to 5,000 records; when full, the records not seen for the longest time drop off first. A snapshot from a stopped run (`incomplete: true`) is safe to use: rows that were not delivered are not in it and will count as `new` next time. The Actor does not create schedules or webhooks; you choose when to run it.

### Pricing

Pay-per-event: one $0.04 run-start event after valid input, plus one publication event for each emitted row. Snapshot-only and skipped unchanged rows are not charged. Invalid input is rejected before the start event.

| Store tier | Per publication | 25 rows, including start |
| --- | ---: | ---: |
| FREE | $0.0018 | $0.0850 |
| BRONZE | $0.0017 | $0.0825 |
| SILVER | $0.0016 | $0.0800 |
| GOLD and above | $0.0015 | $0.0775 |

On FREE, 100 emitted rows cost $0.22 and 500 cost $0.94, including start. A valid empty or unchanged-only run costs $0.04. The start event is also charged when the source fails after valid input (`ERROR`); a `PARTIAL` run pays the start and the rows it emitted. Your maximum cost per run can stop work early: the run then ends SUCCEEDED with status `PARTIAL` and reason `CHARGE_LIMIT`, keeping the rows that fit. At the minimum of $0.04 no rows fit, so allow at least $0.04 plus the per-row price for the rows you need. Apify controls actual billing; see the Pricing tab for your tier.

### Limits and data rights

- Maximum 500 unique inspected records per run. A 500-record run usually takes under a minute (about 10 seconds in our tests); with slow source responses it can stop as `PARTIAL` at the internal deadline.
- Source requests are sequential, at least one second apart, each with a 15-second timeout. Source work has a 180-second deadline, a 25-request cap including retries, a 12 MiB limit per response and an 8 MiB total response limit. Two source timeouts stop the run. Memory is 256 MB.
- The source can add or update records later, and publication date is not index date. For [systematic reviews](https://europepmc.org/help), verify your search strategy and export criteria. This Actor returns data, not medical conclusions or recommendations.

[Europe PMC data access](https://europepmc.org/developers) covers metadata, abstracts and full text under different rights. Free or open access does not mean every use is allowed: check the record license and publisher terms before reusing abstracts or following full-text links. The `license` field is the article license, not an abstract-specific legal guarantee. This Actor is independent of Europe PMC.

### API and AI agents

Run the Actor with the same JSON input through the [Apify API](https://docs.apify.com/api/v2/actors-runs-post). Keep your Apify token private. Read the default Dataset items and the `RUN_SUMMARY` and `SNAPSHOT` records from the finished run. Apify exports JSON, CSV and Excel and can run the Actor on your own schedule.

#### Use with AI agents (MCP)

- MCP server with only this Actor: `https://mcp.apify.com?tools=cliqtomedia/europe-pmc-literature-search` (authenticate with Apify).
- Smallest useful input: `{"query":"CRISPR","lastDays":30,"maxResults":25}`.
- Key output fields: `title` (paper title), `doi` / `pmid` / `pmcid` (identifiers, may be `null`), `pubDate` (first publication date), `license` (article license or `null`), `changeType` (`new`, `updated`, `unchanged`).
- A 25-record call takes a few seconds and costs $0.085 on FREE; 500 records usually take under a minute and cost $0.94. Keep `maxResults` at 500 or less and the query under 2,000 characters.

### Troubleshooting

- **No rows, status `NOT_FOUND`.** The search is valid but nothing matched. Widen the dates, change `source` or simplify the query.
- **`PROVIDER_REJECTED_QUERY`.** Europe PMC did not accept the query syntax. Check quotes and field names such as `TITLE:` or `AUTH:`.
- **`PROVIDER_RATE_LIMIT`, `PROVIDER_TIMEOUT` or `PROVIDER_UNAVAILABLE`.** The source was slow or unavailable. Retry later, or lower `maxResults`.
- **`PARTIAL` with `CHARGE_LIMIT`.** Your maximum cost per run was reached. Raise it (start event plus per-row price) or lower `maxResults`.
- **`SOURCE_DEADLINE` or `REQUEST_LIMIT`.** The source was slow for a large run. Lower `maxResults` or split the date range.
- **Snapshot error.** Use the complete `SNAPSHOT` from a run with the same query and filters, with at most 5,000 records.
- **`sourceUrl` does not open from a script.** Europe PMC pages can block automated clients; open the link in a browser or use the identifiers.

### FAQ

#### Do I need a Europe PMC account or API key?

No. The Actor uses the public Europe PMC REST search without login.

#### Why are `doi` and `abstractText` empty for some rows?

The newest records are often added before the source has a DOI, PMID or abstract. The Actor keeps `null` instead of guessing. Records published some time ago more often have these fields filled.

#### Does open access mean I can reuse the text?

Not always. Check `license` and the publisher terms. A `null` license is unknown.

#### Can I get every article on a topic?

No. One run inspects up to 500 records, newest first. Use date windows to split larger reviews.

### Support

Use the Actor's **Issues** tab on Apify. Include the run ID, the expected result and a non-sensitive input example. Never share tokens or cookies.

# Changelog

This Actor's version history is a separate document: https://apify.com/cliqtomedia/europe-pmc-literature-search/changelog.md

# Actor input Schema

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

Required search text or Europe PMC syntax. Blank queries fail before source access.

## `lastDays` (type: `integer`):

Inclusive UTC first-publication window. Optional; do not combine with dateFrom/dateTo. Omit all date fields to search all years.

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

Optional inclusive first publication date, YYYY-MM-DD. Do not combine with lastDays.

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

Optional inclusive first publication date, YYYY-MM-DD, on or after dateFrom.

## `openAccessOnly` (type: `boolean`):

Add OPEN_ACCESS:Y. Open access does not grant reuse rights; check license.

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

ALL searches every Europe PMC source, including sources outside these three. MED is PubMed, PMC is PubMed Central, PPR is preprints. Records remain distinct by source:id.

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

Inspect at most this many unique records, up to 500. In onlyNew mode the emitted row count can be smaller.

## `previousSnapshot` (type: `object`):

Optional SNAPSHOT record from a prior run with the same query and filters (up to 5,000 records). Paste the entire JSON object; a snapshot from a stopped run is also fine. Do not use Dataset rows here.

## `onlyNew` (type: `boolean`):

With a previousSnapshot, emit new source:id records only. Unchanged rows stay in SNAPSHOT; updated rows stay there with their old fingerprint, because they were not delivered. Without a baseline every record is new.

## Actor input object example

```json
{
  "query": "CRISPR",
  "lastDays": 30,
  "openAccessOnly": true,
  "source": "ALL",
  "maxResults": 25,
  "onlyNew": false
}
```

# Actor output Schema

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

Literature metadata table.

## `monitoring` (type: `string`):

Change classification and citation counts.

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

Outcome, counts, source request stats and limits.

## `snapshot` (type: `string`):

Copy this complete JSON into previousSnapshot to compare runs.

# 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 = {
    "query": "CRISPR",
    "lastDays": 30,
    "openAccessOnly": true,
    "source": "ALL",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("cliqtomedia/europe-pmc-literature-search").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 = {
    "query": "CRISPR",
    "lastDays": 30,
    "openAccessOnly": True,
    "source": "ALL",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("cliqtomedia/europe-pmc-literature-search").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 '{
  "query": "CRISPR",
  "lastDays": 30,
  "openAccessOnly": true,
  "source": "ALL",
  "maxResults": 25
}' |
apify call cliqtomedia/europe-pmc-literature-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cliqtomedia/europe-pmc-literature-search"
        }
    }
}
```

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/r1Jh1RS6GLhCTme6W/builds/uyhhxrBsFbhrbFntX/openapi.json
