# ORCID Researcher Search Scraper (`automation-lab/orcid-researcher-search-scraper`) Actor

Search ORCID public researcher profiles by name, affiliation, keyword, country, or raw ORCID query. Export researcher lead lists from ORCID.

- **URL**: https://apify.com/automation-lab/orcid-researcher-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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

## ORCID Researcher Search Scraper

Search ORCID public researcher profiles by name, affiliation, keyword, country, or advanced ORCID query syntax. Export clean researcher discovery lists with ORCID iDs, profile URLs, public emails, institutions, affiliations, keywords, researcher URLs, and recent works when enrichment is enabled.

Use this actor when you need a repeatable way to build academic recruiting lists, pharma KOL discovery tables, grant intelligence exports, university partnership maps, or outreach lists from the public ORCID registry.

---

### What does ORCID Researcher Search Scraper do?

ORCID Researcher Search Scraper queries the official ORCID public API and saves matching researcher records to an Apify dataset.

It supports two workflows:

- 🔎 **Fast search lists** from ORCID expanded-search results.
- 🧬 **Enriched researcher profiles** by optionally fetching each ORCID `/record` endpoint.

The actor can search by:

- Raw ORCID query syntax
- Full name
- Given name
- Family name
- Affiliation organization
- Research keyword
- Affiliation country code

---

### Who is it for?

This scraper is useful for teams that need structured researcher discovery data without manually searching ORCID.

- 🎓 **University recruiting teams** can find researchers by institution or topic.
- 💊 **Pharma and biotech teams** can build KOL discovery lists by disease, method, or institution.
- 🤝 **Partnership teams** can map researchers at universities, hospitals, labs, and companies.
- 💸 **Grant and funding analysts** can identify researchers active in specific domains.
- 📬 **Outreach teams** can export ORCID IDs, public emails, and profile links for compliant outreach workflows.
- 🧑‍💻 **Data teams** can feed ORCID records into CRMs, enrichment pipelines, or internal research graphs.

---

### Why use this actor?

ORCID is a public registry, but building repeatable search exports manually is time consuming. This actor turns ORCID search into a simple Apify job.

Benefits:

- Uses the official public ORCID API.
- No login or API key required for public records.
- Supports advanced ORCID query syntax.
- Includes friendly filters for non-technical users.
- Saves normalized JSON records.
- Can optionally enrich each result with affiliations and works.
- Includes result position and total-result counts for auditability.
- Runs as an Apify actor, so it can be scheduled, integrated, and called by API.

---

### What data can you extract?

| Field | Description |
| --- | --- |
| `orcidId` | Researcher's ORCID iD. |
| `orcidUrl` | Public ORCID profile URL. |
| `fullName` | Combined display name. |
| `givenNames` | Given names from ORCID. |
| `familyName` | Family name from ORCID. |
| `creditName` | Public credit name when available. |
| `emails` | Public emails exposed by ORCID. |
| `institutions` | Institutions from expanded search results. |
| `otherNames` | Other public names. |
| `query` | Query used for the run. |
| `resultPosition` | Position in the exported result list. |
| `totalResults` | ORCID total matches for the query. |
| `profileLastModified` | Profile modification timestamp, when enriched. |
| `biography` | Public biography, when enriched. |
| `keywords` | Public ORCID keywords, when enriched. |
| `researcherUrls` | Public profile/researcher URLs, when enriched. |
| `countries` | Countries found in public address or affiliation data. |
| `employments` | Public employment summaries, when enriched. |
| `educations` | Public education summaries, when enriched. |
| `otherAffiliations` | Memberships, services, distinctions, qualifications, and invited positions. |
| `worksCount` | Count of public works groups found in the ORCID record. |
| `recentWorks` | Up to 10 work summaries with title, type, date, journal, and DOI. |
| `scrapedAt` | Timestamp when the record was saved. |

---

### How much does it cost to search ORCID researchers?

This actor uses pay-per-event pricing.

- A $0.005 start fee is charged once per run.
- A per-result event is charged for every ORCID researcher saved to the dataset.
- BRONZE per-result price: $0.0000304 per saved researcher, with tiered discounts for higher Apify plans.
- Enrichment may make runs slower because it performs one additional public ORCID API request per researcher, but billing is still based on saved records.

You can control spend with `maxItems`.

For a low-cost first run, keep the default `maxItems` value or run a narrow query such as one affiliation organization plus one keyword.

---

### Input options

The actor accepts either a raw ORCID query or friendly filters.

| Input | Type | Description |
| --- | --- | --- |
| `query` | string | Raw ORCID query. Overrides friendly filters. |
| `name` | string | Full-name text search. |
| `givenName` | string | ORCID given-name filter. |
| `familyName` | string | ORCID family-name filter. |
| `affiliationOrgName` | string | Organization name in affiliations. |
| `keyword` | string | Research keyword. |
| `country` | string | Two-letter affiliation country code. |
| `maxItems` | integer | Maximum researcher records to save. |
| `rowsPerPage` | integer | ORCID API page size. |
| `includeDetails` | boolean | Fetch per-record enrichment from `/record`. |
| `requestDelayMs` | integer | Polite delay between ORCID requests. |

---

### Example input: affiliation search

```json
{
  "query": "affiliation-org-name:\"Harvard University\"",
  "maxItems": 100,
  "rowsPerPage": 100,
  "includeDetails": false,
  "requestDelayMs": 500
}
````

***

### Example input: friendly filters

```json
{
  "affiliationOrgName": "Stanford University",
  "keyword": "machine learning",
  "maxItems": 50,
  "includeDetails": false
}
```

***

### Example input: enriched named researcher search

```json
{
  "givenName": "Jennifer",
  "familyName": "Doudna",
  "maxItems": 5,
  "includeDetails": true,
  "requestDelayMs": 500
}
```

***

### Output example

```json
{
  "orcidId": "0000-0001-9161-999X",
  "orcidUrl": "https://orcid.org/0000-0001-9161-999X",
  "givenNames": "Jennifer",
  "familyName": "Doudna",
  "fullName": "Jennifer Doudna",
  "emails": [],
  "institutions": [],
  "otherNames": [],
  "query": "given-names:\"Jennifer\" AND family-name:\"Doudna\"",
  "resultPosition": 1,
  "totalResults": 1,
  "source": "orcid-expanded-search",
  "worksCount": 524,
  "scrapedAt": "2026-07-02T02:14:39.788Z"
}
```

***

### How to run it

1. Open the actor on Apify.
2. Enter a raw ORCID query or fill friendly filters.
3. Set `maxItems` to control the size of your export.
4. Decide whether you need `includeDetails`.
5. Click **Start**.
6. Download results from the default dataset as JSON, CSV, Excel, XML, or RSS.

***

### ORCID query tips

ORCID search supports fielded query syntax.

Useful examples:

- `affiliation-org-name:"Harvard University"`
- `given-names:"Jennifer" AND family-name:"Doudna"`
- `keyword:"cancer" AND affiliation-org-country:US`
- `affiliation-org-name:"University of Oxford" AND keyword:"genomics"`

When using friendly filters, the actor builds a query with `AND` between provided fields.

***

### Enrichment mode

Set `includeDetails` to `true` when you need deeper public profile information.

Enrichment can add:

- Public biography
- Public keywords
- Researcher URLs
- Employment summaries
- Education summaries
- Other affiliation summaries
- Country values
- Recent works
- Work count

For large discovery jobs, start without enrichment. Then re-run narrower searches with enrichment for high-value subsets.

***

### Integrations

You can connect ORCID Researcher Search Scraper to many workflows:

- 📊 Export CSV to Google Sheets for recruiting review.
- 🧩 Send JSON to a CRM enrichment workflow.
- 🧠 Feed researcher profiles into an LLM research assistant.
- 🗂️ Store ORCID IDs in a knowledge graph.
- 📬 Build compliant outreach lists using public emails only.
- ⏰ Schedule weekly monitoring for new researchers matching a query.

***

### API usage: Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/orcid-researcher-search-scraper').call({
  affiliationOrgName: 'Harvard University',
  keyword: 'oncology',
  maxItems: 100,
});

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

***

### API usage: Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/orcid-researcher-search-scraper').call(run_input={
    'affiliationOrgName': 'Harvard University',
    'keyword': 'oncology',
    'maxItems': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

***

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~orcid-researcher-search-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"affiliationOrgName":"Harvard University","keyword":"oncology","maxItems":100}'
```

***

### MCP usage

Use this actor through Apify MCP from Claude Code, Claude Desktop, or other MCP-compatible tools.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/orcid-researcher-search-scraper
```

Claude Code setup:

```bash
claude mcp add apify-orcid-researchers https://mcp.apify.com/?tools=automation-lab/orcid-researcher-search-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-orcid-researchers": {
      "url": "https://mcp.apify.com/?tools=automation-lab/orcid-researcher-search-scraper"
    }
  }
}
```

Example prompts:

- "Search ORCID for researchers at Harvard University working on oncology and summarize the top 20."
- "Find public ORCID profiles for Stanford machine learning researchers and export a CSV-ready table."
- "Build a shortlist of ORCID researchers in Germany with CRISPR-related keywords."

***

### Best practices

- Start with a narrow query and low `maxItems`.
- Use raw `query` for advanced ORCID syntax.
- Use `includeDetails` only when you need affiliations, keywords, URLs, and works.
- Increase `requestDelayMs` for very large enriched jobs.
- Review public email availability; many ORCID profiles do not expose emails.
- Treat ORCID data as public profile metadata, not a verified contact database.

***

### Troubleshooting

#### I get zero results. What should I try?

Check the query syntax and try a broader filter. For example, use only `affiliationOrgName` first, then add `keyword` after you confirm ORCID has matches.

#### Why are emails missing?

ORCID profiles only expose emails when the researcher made them public. Missing emails are normal and should not be treated as an extraction error.

#### Why is enrichment slower?

Enrichment fetches one extra ORCID `/record` endpoint per researcher. For large lists, this naturally adds more requests and time.

***

### Data quality notes

ORCID records are user-managed and institution-linked public metadata can vary by profile.

Expect variation in:

- Name completeness
- Public email availability
- Affiliation detail
- Keyword detail
- Works metadata
- Profile update freshness

The actor preserves available public values and leaves unavailable optional fields empty.

***

### Legality and responsible use

This actor uses public ORCID API endpoints and exports public profile metadata. You are responsible for using the data in accordance with applicable laws, ORCID terms, privacy rules, and outreach regulations.

Do not use exported data for spam, harassment, or discriminatory profiling. Respect opt-outs and only contact researchers through appropriate, compliant channels.

***

### Related scrapers

Other automation-lab actors that may complement this workflow:

- https://apify.com/automation-lab/orcid-researcher-profile-scraper
- https://apify.com/automation-lab/openfda-drug-ndc-directory-scraper

Use the profile scraper when you already have ORCID IDs and need profile-by-record extraction. Use this search scraper when you need discovery by query, organization, country, or keyword.

***

### FAQ

#### Does this actor require an ORCID API key?

No. It uses public ORCID API endpoints that worked without login or API key during feasibility testing.

#### Can I search by organization?

Yes. Use `affiliationOrgName`, for example `Harvard University`, or raw query syntax such as `affiliation-org-name:"Harvard University"`.

#### Can I search by country?

Yes. Use a two-letter country code in `country`, or raw query syntax such as `affiliation-org-country:US`.

#### Can I export publications?

The actor returns up to 10 recent work summaries when `includeDetails` is enabled, plus `worksCount`. It is optimized for researcher discovery, not full publication harvesting.

#### Can I schedule recurring searches?

Yes. Apify tasks can schedule this actor to run daily, weekly, or monthly for the same ORCID query.

***

### Changelog

- `0.1` Initial version with ORCID expanded search, friendly filters, optional detail enrichment, dataset schema, and PPE-ready charge events.

# Actor input Schema

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

Advanced ORCID/Lucene query. Example: affiliation-org-name:"Harvard University" AND keyword:"cancer". If provided, friendly filters are ignored.

## `name` (type: `string`):

Optional full-name text search, useful for finding a researcher by name.

## `givenName` (type: `string`):

Search ORCID given names when you want a more precise name query.

## `familyName` (type: `string`):

Search ORCID family names when you want a more precise name query.

## `affiliationOrgName` (type: `string`):

University, company, hospital, or other organization name to search in ORCID affiliations.

## `keyword` (type: `string`):

Research topic or keyword to search in ORCID public profiles.

## `country` (type: `string`):

Optional two-letter country code for affiliation organization country, for example US, GB, DE, or JP.

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

Maximum ORCID researcher records to save to the dataset.

## `rowsPerPage` (type: `integer`):

Number of search results requested per ORCID API page. Higher values reduce requests; 100 is a polite default.

## `includeDetails` (type: `boolean`):

Fetch each ORCID /record endpoint to add public employments, educations, keywords, URLs, countries, and recent works. This is slower and uses one extra request per researcher.

## `requestDelayMs` (type: `integer`):

Polite delay between paginated and enrichment requests. Increase if ORCID rate limits large jobs.

## Actor input object example

```json
{
  "query": "affiliation-org-name:\"Harvard University\"",
  "affiliationOrgName": "Harvard University",
  "maxItems": 20,
  "rowsPerPage": 100,
  "includeDetails": false,
  "requestDelayMs": 500
}
```

# 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 = {
    "query": "affiliation-org-name:\"Harvard University\"",
    "affiliationOrgName": "Harvard University",
    "maxItems": 20,
    "rowsPerPage": 100,
    "includeDetails": false,
    "requestDelayMs": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/orcid-researcher-search-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": "affiliation-org-name:\"Harvard University\"",
    "affiliationOrgName": "Harvard University",
    "maxItems": 20,
    "rowsPerPage": 100,
    "includeDetails": False,
    "requestDelayMs": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/orcid-researcher-search-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 '{
  "query": "affiliation-org-name:\\"Harvard University\\"",
  "affiliationOrgName": "Harvard University",
  "maxItems": 20,
  "rowsPerPage": 100,
  "includeDetails": false,
  "requestDelayMs": 500
}' |
apify call automation-lab/orcid-researcher-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ORCID Researcher Search Scraper",
        "description": "Search ORCID public researcher profiles by name, affiliation, keyword, country, or raw ORCID query. Export researcher lead lists from ORCID.",
        "version": "0.1",
        "x-build-id": "vfzNJQJyeSEugVMRa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~orcid-researcher-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-orcid-researcher-search-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~orcid-researcher-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-orcid-researcher-search-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~orcid-researcher-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-orcid-researcher-search-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",
                "properties": {
                    "query": {
                        "title": "Raw ORCID query",
                        "type": "string",
                        "description": "Advanced ORCID/Lucene query. Example: affiliation-org-name:\"Harvard University\" AND keyword:\"cancer\". If provided, friendly filters are ignored."
                    },
                    "name": {
                        "title": "Full name",
                        "type": "string",
                        "description": "Optional full-name text search, useful for finding a researcher by name."
                    },
                    "givenName": {
                        "title": "Given name",
                        "type": "string",
                        "description": "Search ORCID given names when you want a more precise name query."
                    },
                    "familyName": {
                        "title": "Family name",
                        "type": "string",
                        "description": "Search ORCID family names when you want a more precise name query."
                    },
                    "affiliationOrgName": {
                        "title": "Affiliation organization",
                        "type": "string",
                        "description": "University, company, hospital, or other organization name to search in ORCID affiliations."
                    },
                    "keyword": {
                        "title": "Research keyword",
                        "type": "string",
                        "description": "Research topic or keyword to search in ORCID public profiles."
                    },
                    "country": {
                        "title": "Affiliation country code",
                        "type": "string",
                        "description": "Optional two-letter country code for affiliation organization country, for example US, GB, DE, or JP."
                    },
                    "maxItems": {
                        "title": "Maximum researchers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum ORCID researcher records to save to the dataset.",
                        "default": 20
                    },
                    "rowsPerPage": {
                        "title": "Rows per ORCID page",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Number of search results requested per ORCID API page. Higher values reduce requests; 100 is a polite default.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Enrich each ORCID record",
                        "type": "boolean",
                        "description": "Fetch each ORCID /record endpoint to add public employments, educations, keywords, URLs, countries, and recent works. This is slower and uses one extra request per researcher.",
                        "default": false
                    },
                    "requestDelayMs": {
                        "title": "Delay between ORCID requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between paginated and enrichment requests. Increase if ORCID rate limits large jobs.",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
