# Plos Articles Scraper (`real-estate-api/plos-articles-scraper`) Actor

PLOS Articles Scraper is a Python script designed to search and extract open-access scientific papers, abstracts, author details, publication dates, and DOIs from Public Library of Science (PLOS) journals into structured formats for scientific analysis.

- **URL**: https://apify.com/real-estate-api/plos-articles-scraper.md
- **Developed by:** [real-estate-api](https://apify.com/real-estate-api) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 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/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

## PLOS Articles Scraper: Journal Article Search

<p align="center">
  <img src="https://imgur.com/4F5tWU4.png" alt="PLOS Articles Scraper" width="800" />
</p>

PLOS Articles Scraper collects journal article records matching a search query. Each dataset row includes the article title, journal, publication date, authors, abstract, article type, and identifier.

Export results to JSON, CSV, or Excel for literature reviews, research lists, journal monitoring, and academic workflows. The scraper supports paginated searches and duplicate detection, making it useful for collecting structured article metadata across multiple result pages.

### Use Cases

- **Literature searches:** Find articles using title or abstract keywords.
- **Journal filtering:** Organize results by journal, article type, and publication date.
- **Author research:** Export author names without opening every article page.
- **Research monitoring:** Repeat searches and compare article IDs to identify new records.
- **Academic workflows:** Export structured results to spreadsheets or research tools.

### Input Parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `query` | String | `title:python` | Search expression used to find matching articles. |
| `maxItems` | Integer | `100` | Maximum number of article rows to save per run. Hard limit: `1000`. |
| `timeoutSecs` | Integer | `300` | Overall run time limit in seconds. |
| `requestTimeoutSecs` | Integer | `30` | Timeout for an individual request in seconds. |

### Example Input

```json
{
  "query": "title:python",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30
}
```

### What Data Does This Actor Extract?

Each successful result represents one article record. Titles and abstracts are converted to plain text by removing HTML tags. Author names are preserved as returned, including non-Latin characters.

#### Example Output

```json
{
  "id": "10.1371/journal.pone.0190633",
  "journal": "PLOS ONE",
  "publication_date": "2018-01-17T00:00:00Z",
  "article_type": "Research Article",
  "author_display": [
    "Lawrence E. Reeves",
    "Kenneth L. Krysko"
  ],
  "abstract": [
    "A study of the invasive Burmese python and its interactions with the local mosquito community in Florida."
  ],
  "title_display": "Interactions between the invasive Burmese python and the local mosquito community in Florida, USA",
  "scrapedAt": "2026-10-12T00:00:00Z"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `id` | String | Article identifier, usually a DOI. Also used for deduplication. |
| `journal` | String | Journal name. |
| `publication_date` | String | Publication date supplied by the source. |
| `article_type` | String | Article classification, such as Research Article. |
| `author_display` | Array | Author names. |
| `abstract` | Array | Abstract text with HTML tags removed. |
| `title_display` | String | Article title with HTML tags removed. |
| `scrapedAt` | String | UTC timestamp when the row was saved. |
| `error` | String | Error description when a request or input fails. |
| `input` | String | Query or short description associated with an error. |

### How It Works

1. Reads the search query, item limit, and timeout settings.
2. Requests matching article records in batches of up to 100.
3. Processes result pages sequentially, advancing through available records.
4. Removes HTML tags from titles and abstracts.
5. Skips duplicate article IDs.
6. Stops when the item limit is reached, available results are exhausted, or the run timeout is reached.
7. Saves successful article records and error details to the dataset.

### Pagination and Rate Limits

- **Pagination:** The scraper continues through available result pages until it reaches the requested item limit or the source has no more results.
- **Batch size:** Each request retrieves only the number of records still needed, up to 100 per batch.
- **Request spacing:** Requests run one at a time, with a six-second delay between pages.
- **Source limits:** The source specifies request limits of 10 requests per minute, 300 per hour, and 7,200 per day. Respect these limits when scheduling runs.
- **Maximum output:** The default is 100 records, with a hard maximum of 1000.

Do not use proxies or other methods to circumvent source rate limits.

### Error Handling

- HTTP 429 responses, server errors (5xx), and timeouts are retried up to three times, with delays of 2, 4, and 8 seconds.
- A suitable `Retry-After` value is respected when provided.
- Other HTTP errors and responses that cannot be parsed as JSON produce error rows.
- An empty search produces no article records and a note indicating that no results matched.
- Empty or rejected queries produce an error record without necessarily failing the entire run.

### Licensing and Attribution

Article records originate from PLOS. Attribute PLOS when reusing the collected data and review the applicable source terms before redistributing records.

PLOS articles are published under Creative Commons Attribution (CC BY) licenses, subject to the license applicable to each article. Check the individual article's license before reusing its full text, figures, or other content.

**Pricing:** The actor is free to run. Normal Apify platform usage charges may apply.

### FAQ

#### Can I export results to CSV, JSON, or Excel?

Yes. Dataset results can be downloaded in JSON, CSV, or Excel format.

#### How many articles can one run collect?

The default is `100`, and the maximum is `1000` articles per run.

#### What happens if the search query is invalid?

The actor records an error row with the relevant input and finishes the run where possible. An empty query does not initiate a search.

#### Why is the title field named `title_display`?

That is the field name used in the source's article records. The actor removes HTML tags and preserves the title as plain text.

#### How can I avoid duplicate articles?

Use the `id` field, which is usually a DOI, to compare records across runs.

#### Does the actor collect full article text?

The output focuses on article metadata and abstracts. It does not collect complete article bodies.

### Trademark Notice

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

### Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, sponsored by, or officially associated with PLOS or its owners. Users are responsible for complying with applicable source terms, rate limits, attribution requirements, and licensing restrictions.

### Is Web Scraping Legal?

Collecting information that is already public is generally legal. Scraping is not the same thing as hacking, and there is no single law that bans it. The limits are the usual ones: do not break into accounts, do not take private or confidential data, and be careful with personal data and copyrighted works. A site's terms can also restrict how you access it. Facts such as a public name, price, or rating are not the same thing as republishing someone's article or photo.

This actor collects information from public pages. It does not log in and it does not bypass access controls.

For a longer explanation, see Apify's article [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

# Actor input Schema

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

Solr query sent as q to the public PLOS search API. Examples: title:python or abstract:climate.

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

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

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

Stop starting new search requests after this many seconds, even if max items is not reached.

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

How long to wait for a single PLOS search response before treating it as a timeout.

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

Optional proxy for search requests. Leave Apify Proxy off. The public PLOS search API does not need a proxy, and a proxy must not be used to get around the published rate limits.

## Actor input object example

```json
{
  "query": "title:python",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Default dataset for this run.

## `itemsUrl` (type: `string`):

JSON items from the default dataset.

## `overviewUrl` (type: `string`):

Table view of PLOS article rows.

# 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": "title:python",
    "maxItems": 100,
    "timeoutSecs": 300,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("real-estate-api/plos-articles-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 = {
    "query": "title:python",
    "maxItems": 100,
    "timeoutSecs": 300,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("real-estate-api/plos-articles-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 '{
  "query": "title:python",
  "maxItems": 100,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call real-estate-api/plos-articles-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,real-estate-api/plos-articles-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/Y9DiADzQDYqAMfc4s/builds/mpm058VaJJ9FfHCpe/openapi.json