# PubMed Article Search (`automation-lab/pubmed-scraper`) Actor

Search PubMed's 35M+ biomedical articles and extract structured data: titles, authors, abstracts, DOIs, MeSH keywords, and publication types. Free NCBI API, no key required.

- **URL**: https://apify.com/automation-lab/pubmed-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## PubMed Article Search

Search PubMed -- NCBI's free biomedical literature database with 35M+ peer-reviewed articles -- and extract structured data including titles, authors, abstracts, DOIs, MeSH keywords, and publication types. No API key required. Uses the official NCBI E-utilities API for reliable, high-volume data extraction.

### What Does PubMed Scraper Do?

This actor searches PubMed using the official NCBI E-utilities API and extracts structured article metadata. Enter one or more search queries using PubMed's full search syntax (Boolean operators, MeSH terms, field tags, date ranges), and get back clean, structured JSON data for every matching article.

- Searches PubMed's 35M+ article database with full query syntax support
- Extracts title, authors with affiliations, abstract, journal, DOI, MeSH keywords, and publication types
- Handles multiple queries with automatic deduplication across results
- Processes up to 10,000 articles per query with batch fetching
- Respects NCBI rate limits (3 requests/second) for reliable operation
- No API key or proxy required -- NCBI E-utilities is a free public API

### Who Is PubMed Scraper For?

- **Pharmaceutical researchers** tracking clinical trials, drug efficacy studies, and safety reports for specific compounds or therapeutic areas
- **Academic researchers** conducting systematic reviews or meta-analyses who need bulk article metadata for literature mapping
- **Biotech and life sciences companies** monitoring competitor research output and publication trends in target disease areas
- **Healthcare analytics teams** analyzing publication patterns, emerging treatments, and research funding trends
- **Grant writers** gathering supporting references and citation data for proposals
- **Science journalists** finding primary sources for medical reporting and fact-checking
- **Data scientists** building datasets of scientific literature for NLP training, citation analysis, or knowledge graphs
- **Medical librarians** curating research collections and tracking institutional publication output

### Why Use PubMed Scraper Instead of Manual Search?

- **Bulk extraction** -- export hundreds or thousands of articles in minutes, not hours of manual copying
- **Structured data** -- get clean JSON with consistent field names, ready for analysis or database import
- **Multiple queries** -- run several searches in one go with automatic deduplication
- **Automation-ready** -- schedule recurring searches to monitor new publications on any topic
- **API integration** -- pipe results directly into your data pipeline, spreadsheet, or database

### What Data Is Extracted?

Each article record includes these fields:

| Field | Type | Description |
|---|---|---|
| `pmid` | string | PubMed ID -- unique identifier for the article |
| `title` | string | Full article title |
| `authors` | array | Author objects with `name` and `affiliation` |
| `abstract` | string | Full abstract text (structured abstracts preserved with section labels) |
| `journal` | string | Journal name |
| `publicationDate` | string | Publication date (YYYY-MM-DD, YYYY-MM, or YYYY) |
| `doi` | string | Digital Object Identifier for cross-referencing |
| `keywords` | array | MeSH terms and author-assigned keywords |
| `publicationTypes` | array | Types: Journal Article, Review, Clinical Trial, Meta-Analysis, etc. |
| `url` | string | Direct link to the article on PubMed |
| `scrapedAt` | string | ISO timestamp when the article was scraped |

### How Much Does It Cost to Scrape PubMed Articles?

This actor uses pay-per-event (PPE) pricing. You only pay for what you use:

| Event | FREE tier | GOLD tier | DIAMOND tier |
|---|---|---|---|
| Run started (one-time) | $0.001 | $0.001 | $0.001 |
| Per article scraped | $0.002 | $0.001 | $0.0005 |

**Example costs at FREE tier:**
- 50 articles: ~$0.10
- 200 articles: ~$0.40
- 1,000 articles: ~$2.00
- 5,000 articles: ~$10.00

Higher subscription tiers get progressively lower per-article rates. The Apify Free plan includes $5/month of platform credits -- enough to scrape ~2,500 articles per month at no cost.

### How to Scrape PubMed Articles

1. Go to the [PubMed Scraper](https://apify.com/automation-lab/pubmed-scraper) actor page on Apify Store
2. Click **Try for free** to open the actor in Apify Console
3. Enter your search queries in the **Search Queries** field (one per line)
4. Set **Max results per query** (default: 50, max: 10,000)
5. Optionally set date filters to limit results to a specific time range
6. Click **Start** and wait for the run to complete
7. Download your results as JSON, CSV, or Excel from the **Dataset** tab

### Input Parameters

#### Search Queries (required)

Enter one or more PubMed search queries. Each query runs as a separate search, and results are deduplicated across queries. Supports full PubMed search syntax including Boolean operators, field tags, and MeSH terms.

**Example queries:**
````

CRISPR cancer therapy
COVID-19\[Title] AND vaccine efficacy
diabetes AND insulin resistance\[MeSH Terms]
"breast cancer"\[Title/Abstract] AND 2020:2024\[pdat]
Smith J\[Author] AND Nature\[Journal]

````

#### Max Results Per Query

Default: 50. Maximum: 10,000. PubMed indexes 35M+ articles -- use date filters to narrow results for broad topics.

#### Sort By

- **Relevance** (default) -- best match articles appear first
- **Date** -- most recently published articles appear first

#### Date Filters

Filter articles by publication date range. Format: `YYYY/MM/DD`.

- `dateFrom: 2020/01/01` -- articles published since January 2020
- `dateTo: 2024/12/31` -- articles published before end of 2024

### Output Example

```json
{
  "pmid": "38123456",
  "title": "CRISPR-Cas9-mediated gene editing in primary T cells for cancer immunotherapy",
  "authors": [
    {
      "name": "Zhang Wei",
      "affiliation": "Department of Immunology, Harvard Medical School, Boston, MA"
    },
    {
      "name": "Johnson Sarah K",
      "affiliation": "Dana-Farber Cancer Institute, Boston, MA"
    }
  ],
  "abstract": "BACKGROUND: Gene editing of T cells has emerged as a promising approach...\n\nMETHODS: We performed CRISPR-Cas9 editing of primary human T cells...\n\nRESULTS: Edited T cells showed enhanced tumor infiltration...",
  "journal": "Nature Medicine",
  "publicationDate": "2023-11-15",
  "doi": "10.1038/s41591-023-02345-6",
  "keywords": ["CRISPR-Cas9 Protein Systems", "T-Lymphocytes", "Neoplasms", "Immunotherapy"],
  "publicationTypes": ["Journal Article", "Research Support, N.I.H., Extramural"],
  "url": "https://pubmed.ncbi.nlm.nih.gov/38123456/",
  "scrapedAt": "2024-03-15T10:23:45.123Z"
}
````

### Tips for Better Results

- **Use MeSH terms** for precise results -- `Neoplasms[MeSH Terms]` captures all cancer types regardless of terminology
- **Combine Boolean operators** -- `(diabetes OR "metabolic syndrome") AND treatment[Title]`
- **Use field tags** to narrow scope -- `[Title]`, `[Author]`, `[Journal]`, `[Affiliation]`, `[MeSH Terms]`
- **Quote exact phrases** -- `"randomized controlled trial"` matches the exact phrase
- **Date ranges in query** -- append `AND 2020:2024[pdat]` to limit publication dates
- **Start small** -- test with 10-20 results first, then scale up once you confirm the query returns relevant articles
- **Multiple focused queries** beat one broad query -- run 3 specific queries of 100 articles rather than 1 generic query of 300

### PubMed Search Syntax Guide

#### Boolean Operators

```
diabetes AND insulin          -- both terms required
cancer OR tumor               -- either term
COVID-19 NOT influenza        -- exclude term
```

#### Field Tags

```
[Title]                       -- title only
[Author]                      -- author name
[Journal]                     -- specific journal
[MeSH Terms]                  -- Medical Subject Headings
[Title/Abstract]              -- title or abstract
[Affiliation]                 -- institution
```

#### MeSH Terms

MeSH (Medical Subject Headings) is NLM's controlled vocabulary. Using MeSH gives more precise results:

```
Neoplasms[MeSH Terms]         -- all cancer types
Diabetes Mellitus[MeSH Terms]
COVID-19[MeSH Terms]
```

#### Combined Example

```
("breast cancer"[Title] OR "mammary tumor"[Title]) AND treatment[MeSH Terms] AND 2022:2024[pdat]
```

### Integrations

PubMed Scraper connects to 1,500+ apps through the Apify platform:

- **Google Sheets** -- automatically export new articles to a shared spreadsheet for team literature tracking
- **Slack / Microsoft Teams** -- get notified when new articles match your monitoring queries via scheduled runs
- **Airtable** -- build a searchable research database with article metadata, tags, and review status
- **Zapier / Make** -- trigger workflows when new publications appear (e.g., email digest to research team)
- **PostgreSQL / BigQuery** -- pipe article data into your data warehouse for bibliometric analysis
- **n8n** -- build automated literature monitoring pipelines with custom filtering and alerting

Set up integrations in the Apify Console under **Settings > Integrations** for any actor run.

### API Usage

#### Node.js

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

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

const run = await client.actor('automation-lab/pubmed-scraper').call({
    queries: ['CRISPR cancer therapy', 'CAR-T cell therapy'],
    maxResultsPerQuery: 100,
    sortBy: 'date',
    dateFrom: '2023/01/01',
});

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

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_API_TOKEN")

run = client.actor("automation-lab/pubmed-scraper").call(run_input={
    "queries": ["CRISPR cancer therapy"],
    "maxResultsPerQuery": 200,
    "sortBy": "date",
    "dateFrom": "2022/01/01",
    "dateTo": "2024/12/31",
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Scraped {len(items)} articles")
```

#### cURL

```bash
## Start the actor run
curl -X POST "https://api.apify.com/v2/acts/automation-lab~pubmed-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["CRISPR cancer therapy"],
    "maxResultsPerQuery": 50,
    "sortBy": "relevance"
  }'

## Fetch results (replace DATASET_ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"
```

### MCP Integration (AI Assistants)

Use PubMed Scraper directly from AI assistants like Claude, ChatGPT, or Cursor through the Model Context Protocol (MCP).

#### Claude Desktop / Claude Code

Add to your MCP config (`claude_desktop_config.json` or `.mcp.json`):

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@anthropic/apify-mcp-server"],
      "env": {
        "APIFY_TOKEN": "your-apify-token"
      }
    }
  }
}
```

#### Example Prompts

- "Search PubMed for recent CRISPR cancer therapy papers from 2024 and summarize the top 20"
- "Find all clinical trials on mRNA vaccines published this year and create a comparison table"
- "Get the latest 50 papers on Alzheimer's disease biomarkers and extract key findings"

### Is It Legal to Scrape PubMed?

Yes. This actor uses the official NCBI E-utilities API, which is a free public API provided by the National Library of Medicine specifically for programmatic access to PubMed data. The API is designed for bulk data retrieval and does not require authentication. Article metadata (titles, abstracts, authors, DOIs) is public information. This actor respects NCBI's rate limits (3 requests/second). For NCBI's usage policies, see the [E-utilities documentation](https://www.ncbi.nlm.nih.gov/books/NBK25497/).

### Frequently Asked Questions

#### Do I need an API key to use this actor?

No. The NCBI E-utilities API is free and public. No registration or API key is required. This actor handles all API communication automatically.

#### How many articles can I retrieve in one run?

PubMed's API supports up to 10,000 results per query. For broader topics, use multiple focused queries with date range filters. There is no limit on the number of queries per run.

#### What if my search returns 0 results?

Check your query syntax -- PubMed search is case-insensitive but sensitive to field tag formatting. Make sure brackets are correct (e.g., `[MeSH Terms]` not `[mesh terms]`). Try broadening your search by removing field tags or date filters. The actor handles 0-result queries gracefully without errors.

#### Why are some articles missing abstracts?

Not all PubMed articles have abstracts. Letters, editorials, and some older articles may lack abstract text. The `abstract` field will be `null` for these articles.

#### Does this actor retrieve full article text?

No -- PubMed abstracts are freely available, but full article text is behind publisher paywalls for most journals. Use the DOI to access the publisher site or check PubMed Central (PMC) for open-access articles.

#### How current is the data?

PubMed is updated daily. Newly accepted articles typically appear within a few weeks of online publication.

### Related Scrapers

- [Semantic Scholar Scraper](https://apify.com/automation-lab/semantic-scholar-scraper) -- search and extract data from Semantic Scholar's academic paper database
- [OpenAlex Scraper](https://apify.com/automation-lab/openalex-scraper) -- extract scholarly article data from the OpenAlex open research database
- [CrossRef Scraper](https://apify.com/automation-lab/crossref-scraper) -- search CrossRef for DOI metadata, citations, and publication details

# Actor input Schema

## `queries` (type: `array`):

Enter one or more PubMed search queries. Each query runs as a separate search. Supports full PubMed syntax: Boolean operators (AND, OR, NOT), field tags (\[Title], \[Author], \[MeSH Terms]), and date ranges. Examples: 'CRISPR cancer therapy', 'COVID-19\[Title] AND vaccine\[Title]', 'diabetes AND insulin resistance\[MeSH Terms]'.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of articles to retrieve per query. PubMed returns up to 10,000 results per query. Default: 50. Increase for bulk research.

## `sortBy` (type: `string`):

How to sort the search results. 'relevance' returns the most relevant articles first. 'date' returns the most recently published articles first.

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

Filter articles published on or after this date. Format: YYYY/MM/DD (e.g. 2020/01/01). Leave blank for no start date filter.

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

Filter articles published on or before this date. Format: YYYY/MM/DD (e.g. 2024/12/31). Leave blank for no end date filter.

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

Number of times to retry failed HTTP requests before skipping. Higher values improve reliability on slow connections.

## Actor input object example

```json
{
  "queries": [
    "CRISPR cancer therapy",
    "mRNA vaccine efficacy"
  ],
  "maxResultsPerQuery": 20,
  "sortBy": "relevance",
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "CRISPR cancer therapy",
        "mRNA vaccine efficacy"
    ],
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/pubmed-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 = {
    "queries": [
        "CRISPR cancer therapy",
        "mRNA vaccine efficacy",
    ],
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/pubmed-scraper").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 '{
  "queries": [
    "CRISPR cancer therapy",
    "mRNA vaccine efficacy"
  ],
  "maxResultsPerQuery": 20
}' |
apify call automation-lab/pubmed-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/pubmed-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "PubMed Article Search",
        "description": "Search PubMed's 35M+ biomedical articles and extract structured data: titles, authors, abstracts, DOIs, MeSH keywords, and publication types. Free NCBI API, no key required.",
        "version": "0.1",
        "x-build-id": "jNMAeCCffcSrCMA1b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~pubmed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-pubmed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~pubmed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-pubmed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~pubmed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-pubmed-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔍 Search Queries",
                        "type": "array",
                        "description": "Enter one or more PubMed search queries. Each query runs as a separate search. Supports full PubMed syntax: Boolean operators (AND, OR, NOT), field tags ([Title], [Author], [MeSH Terms]), and date ranges. Examples: 'CRISPR cancer therapy', 'COVID-19[Title] AND vaccine[Title]', 'diabetes AND insulin resistance[MeSH Terms]'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of articles to retrieve per query. PubMed returns up to 10,000 results per query. Default: 50. Increase for bulk research.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "How to sort the search results. 'relevance' returns the most relevant articles first. 'date' returns the most recently published articles first.",
                        "default": "relevance"
                    },
                    "dateFrom": {
                        "title": "Date from",
                        "type": "string",
                        "description": "Filter articles published on or after this date. Format: YYYY/MM/DD (e.g. 2020/01/01). Leave blank for no start date filter."
                    },
                    "dateTo": {
                        "title": "Date to",
                        "type": "string",
                        "description": "Filter articles published on or before this date. Format: YYYY/MM/DD (e.g. 2024/12/31). Leave blank for no end date filter."
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of times to retry failed HTTP requests before skipping. Higher values improve reliability on slow connections.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
