# ORCID Researcher Profile Search (`maximedupre/orcid-researcher-profile-search`) Actor

ORCID Researcher Profile Search finds public researcher profiles by query, institution, or ORCID iD. Export names, affiliations, works, identifiers, profile quality signals, and analysis rows.

- **URL**: https://apify.com/maximedupre/orcid-researcher-profile-search.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.80 / 1,000 scraped profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 and profile export

ORCID Researcher Profile Search collects public ORCID researcher profiles by search query, institution, discovery topic, or exact ORCID iD. Use it to turn ORCID public data into clean Apify dataset rows with names, affiliations, works, public links, identifiers, profile quality signals, and optional cohort analysis.

- [ORCID researcher search](https://apify.com/maximedupre/orcid-researcher-profile-search/examples/orcid-researcher-search) for names, topics, affiliations, keywords, and ORCID Lucene queries.
- [ORCID profile search](https://apify.com/maximedupre/orcid-researcher-profile-search/examples/orcid-profile-search) when you already know exact ORCID iDs and want structured profile rows.
- [ORCID scraper workflows](https://apify.com/maximedupre/orcid-researcher-profile-search/examples/orcid-scraper-workflows) for public names, biographies, emails, websites, keywords, external IDs, affiliations, and works.
- [Institution research mapping](https://apify.com/maximedupre/orcid-researcher-profile-search/examples/institution-research-mapping) for one institution or comparison runs across up to six institutions.
- [Reviewer, expert, collaborator, and field-radar shortlists](https://apify.com/maximedupre/orcid-researcher-profile-search/examples/researcher-discovery-shortlists) with deterministic ranking signals from returned ORCID profiles.

#### 📦 Data you can export

Each charged dataset row is one successful public ORCID researcher profile. Fields can be `null` or empty when ORCID does not publish that fact for a profile.

- `orcidId` and `matchedInputs` for traceability back to your submitted targets
- `names` with given, family, credit, and alternate public names
- `biography`, `country`, public `emails`, `websites`, `keywords`, and `externalIds`
- `currentAffiliation` and `affiliations` for employment, education, membership, service, qualification, distinction, and invited-position facts when public
- `works` with source work count, optional work items, DOI, title, year, journal, URL, put code, and metadata coverage
- `activity` with source last-modified time, profile freshness, years active, career stage, funding count, and peer-review count
- `quality` with deterministic profile health, profile completeness, identity confidence, badges, recommended action, and data gaps
- Optional `discovery`, `institutionAnalysis`, `fieldRadar`, and `relationshipMap` data when those inputs request analysis rows

The Actor uses public ORCID data. It does not guess private emails, add citation impact, calculate h-index, use ORCID member-only data, or generate LLM summaries.

#### ▶️ How to run it

1. Open the Actor input.
2. Fill one target section:
   - **Search queries** for names, topics, affiliations, keywords, or ORCID Lucene syntax.
   - **ORCID iDs** for exact public profile lookup.
   - **Institutions** to map one institution or compare 2-6 institutions.
   - **Discovery topic or query** to build expert, reviewer, collaborator, or field-radar shortlists.
3. Choose **Publication detail** and set **Maximum works per profile**.
4. Set **Maximum profiles per search target** to control output size and cost.
5. Optional: turn on **Include relationship map** when you want a cohort similarity row.
6. Start the Actor and open the dataset.

You can export the dataset as JSON, CSV, Excel, XML, RSS, or HTML. You can also run the Actor through the Apify API, rerun saved inputs, or send finished runs to webhooks and integrations.

#### ⚙️ Input example

```json
{
  "searchQueries": ["machine learning MIT"],
  "publicationDetail": "recentWorks",
  "maxWorksPerProfile": 3,
  "profileFormat": "standard",
  "includeRelationshipMap": true,
  "maxResultsPerTarget": 125
}
````

For exact lookup, use ORCID iDs instead:

```json
{
  "orcidIds": ["0000-0002-9510-6777"],
  "publicationDetail": "fullWorks",
  "maxWorksPerProfile": 25
}
```

#### 🧾 Output example

```json
{
  "recordType": "researcher",
  "orcidId": "0000-0002-9510-6777",
  "names": {
    "given": "Goutam",
    "family": "Sarker",
    "credit": "G. Sarker",
    "other": ["Dr. Goutam Sarker"]
  },
  "biography": "Researcher focused on machine learning and data mining.",
  "country": "IN",
  "emails": ["researcher@example.edu"],
  "websites": [
    {
      "name": "Lab profile",
      "url": "https://example.edu/researcher"
    }
  ],
  "keywords": ["Machine Learning", "Data Mining"],
  "externalIds": [
    {
      "system": "Scopus Author ID",
      "value": "6603684030",
      "url": "https://www.scopus.com/authid/detail.uri?authorId=6603684030"
    }
  ],
  "currentAffiliation": {
    "organization": "National Institute of Technology Durgapur",
    "role": "Associate Professor",
    "department": "Computer Science and Engineering",
    "country": "IN",
    "startDate": "1998-07-13",
    "endDate": null
  },
  "affiliations": [
    {
      "kind": "employment",
      "organization": "National Institute of Technology Durgapur",
      "role": "Associate Professor",
      "department": "Computer Science and Engineering",
      "country": "IN",
      "startDate": "1998-07-13",
      "endDate": null
    }
  ],
  "works": {
    "totalCount": 102,
    "items": [
      {
        "title": "A Machine Learning Method for Pattern Recognition",
        "type": "journal-article",
        "year": 2025,
        "journal": "Applied Sciences",
        "doi": "10.3390/app152412967",
        "url": "https://doi.org/10.3390/app152412967",
        "putCode": 199169611
      }
    ],
    "quality": {
      "doiCoveragePct": 42.5,
      "journalCoveragePct": 70.2,
      "yearCoveragePct": 94.1,
      "recentWorksCount": 7
    }
  },
  "activity": {
    "recordLastModified": "2026-04-30T07:01:18.578Z",
    "profileFreshness": "active",
    "yearsActive": 28,
    "careerStage": "senior",
    "fundingCount": 2,
    "peerReviewCount": 1
  },
  "quality": {
    "researcherHealth": {
      "score": 84,
      "level": "good"
    },
    "profileCompleteness": {
      "score": 80,
      "level": "rich"
    },
    "identityConfidence": {
      "score": 94,
      "level": "high",
      "warnings": []
    },
    "badges": ["has-current-affiliation", "high-completeness"],
    "recommendedAction": "use-profile",
    "dataGaps": []
  },
  "discovery": null,
  "matchedInputs": ["machine learning MIT"],
  "institutionAnalysis": null,
  "fieldRadar": null,
  "relationshipMap": null
}
```

Analysis rows use `recordType: "analysis"` and keep profile fields as `null`. They are added only for requested institution analysis, field radar, or relationship maps.

#### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged `$0.0018` for each public researcher profile saved to the dataset. Empty searches, invalid inputs, skipped profiles, failed lookups, and analysis rows are not charged as researcher profiles.

#### 🔌 Integrations

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

- Call the Actor through the Apify API from scripts, apps, dashboards, or internal research tools.
- Rerun saved ORCID inputs when you want a fresh export for your own comparison workflow.
- Export datasets as CSV, JSON, Excel, XML, RSS, or HTML.
- Send finished runs to webhooks or other Apify integrations.
- Load ORCID profile rows into spreadsheets, CRMs, data warehouses, reviewer queues, or research intelligence workflows.

#### ❓ FAQ

**Can I search ORCID by name, institution, topic, or keyword?**

Yes. Use **Search queries** for names, topics, affiliations, keywords, or ORCID Lucene syntax. Use **Institutions** when your target is an institution map or comparison.

**Can I fetch exact profiles by ORCID iD?**

Yes. Add exact ORCID iDs in the **ORCID iDs** section. The Actor validates the ORCID iD format and saves one row for each public profile it can extract.

**Does this include publications or works?**

Yes, when public ORCID data provides them. Choose counts only, recent works, or full works up to your configured per-profile limit. Work items can include title, type, year, journal, DOI, URL, and ORCID put code.

**Does this find private emails or member-only ORCID data?**

No. The Actor exports public ORCID profile data only. It does not guess private contact details, use ORCID member-only data, or require user-supplied ORCID credentials.

**Can I use this for reviewer or expert discovery?**

Yes. Add a discovery query and choose expert shortlist, reviewer shortlist, collaborator matches, or field radar. Ranking and conflict signals are deterministic and based on the returned public profile facts.

**Why not use the ORCID API directly?**

You can use the ORCID public API directly if you want to build and maintain your own query handling, pagination, normalization, exports, and charging. This Actor packages those steps into an Apify run with dataset exports, API access, schedules, webhooks, and a stable output schema.

**What are ORCID alternatives?**

For broader academic metadata, users often combine ORCID with sources such as OpenAlex, Crossref, Zenodo, Semantic Scholar, institutional directories, or grant databases. ORCID is strongest when you need researcher-controlled public profile facts, ORCID iDs, affiliations, works, and external identifiers.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~orcid-researcher-profile-search/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [OpenAlex Scraper ↗](https://apify.com/gio21/openalex-scraper) - Export OpenAlex scholarly works, authors, institutions, concepts, and journals for research datasets.
- [Semantic Scholar Author Profiles Scraper ↗](https://apify.com/parseforge/semantic-scholar-author-profiles-scraper) - Collect author profiles, citations, h-index, publication history, affiliations, and external IDs from Semantic Scholar.
- [Zenodo Scraper ↗](https://apify.com/openclawmara/zenodo-scraper) - Export Zenodo research records, datasets, software, authors, DOIs, files, and repository metadata.
- [Crossref DOI Metadata Scraper ↗](https://apify.com/parseforge/crossref-scraper) - Collect citation metadata for DOI-backed papers, books, proceedings, and datasets from Crossref.
- [EU Funding & Tenders Scraper ↗](https://apify.com/maximedupre/eu-funding-tenders-scraper) - Export EU grants and tenders with deadlines, budgets, programme details, and official source URLs.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `searchQueries` (type: `array`):

Find researchers by name, topic, affiliation, keyword, or ORCID Lucene query.

## `orcidIds` (type: `array`):

Fetch known researchers by ORCID iD.

## `institutions` (type: `array`):

Enter one institution to map, or 2-6 institutions to compare.

## `discoveryQuery` (type: `string`):

Build a shortlist from a research field, topic, name, affiliation, or Lucene query.

## `discoveryGoal` (type: `string`):

Choose the shortlist or radar view you want from the discovery target.

## `seedOrcidId` (type: `string`):

Use with collaborator matches to compare candidates against one known researcher.

## `conflictAffiliations` (type: `array`):

Use with reviewer shortlists to flag candidates from these organizations.

## `publicationDetail` (type: `string`):

Choose how much works data to include for each researcher.

## `maxWorksPerProfile` (type: `integer`):

Used when publication detail collects recent or full works.

## `profileFormat` (type: `string`):

Choose the profile depth for exports and API reads.

## `includeRelationshipMap` (type: `boolean`):

Add cohort similarity and graph records when a run returns multiple researchers.

## `maxResultsPerTarget` (type: `integer`):

Applies to search, institution, and discovery targets.

## Actor input object example

```json
{
  "searchQueries": [
    "machine learning MIT",
    "CRISPR Stanford"
  ],
  "discoveryGoal": "experts",
  "publicationDetail": "recentWorks",
  "maxWorksPerProfile": 25,
  "profileFormat": "standard",
  "includeRelationshipMap": false,
  "maxResultsPerTarget": 125
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with one row per successful researcher profile plus any requested institution, field, or relationship analysis 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 = {
    "searchQueries": [
        "machine learning MIT",
        "CRISPR Stanford"
    ],
    "discoveryQuery": "",
    "seedOrcidId": "",
    "maxWorksPerProfile": 25,
    "maxResultsPerTarget": 125
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/orcid-researcher-profile-search").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": [
        "machine learning MIT",
        "CRISPR Stanford",
    ],
    "discoveryQuery": "",
    "seedOrcidId": "",
    "maxWorksPerProfile": 25,
    "maxResultsPerTarget": 125,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/orcid-researcher-profile-search").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 '{
  "searchQueries": [
    "machine learning MIT",
    "CRISPR Stanford"
  ],
  "discoveryQuery": "",
  "seedOrcidId": "",
  "maxWorksPerProfile": 25,
  "maxResultsPerTarget": 125
}' |
apify call maximedupre/orcid-researcher-profile-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ORCID Researcher Profile Search",
        "description": "ORCID Researcher Profile Search finds public researcher profiles by query, institution, or ORCID iD. Export names, affiliations, works, identifiers, profile quality signals, and analysis rows.",
        "version": "0.1",
        "x-build-id": "BFDKMooaJavKAeFL0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~orcid-researcher-profile-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-orcid-researcher-profile-search",
                "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/maximedupre~orcid-researcher-profile-search/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-orcid-researcher-profile-search",
                "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/maximedupre~orcid-researcher-profile-search/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-orcid-researcher-profile-search",
                "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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Find researchers by name, topic, affiliation, keyword, or ORCID Lucene query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "orcidIds": {
                        "title": "ORCID iDs",
                        "maxItems": 100,
                        "type": "array",
                        "description": "Fetch known researchers by ORCID iD.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{4}-\\d{4}-\\d{4}-\\d{3}[\\dX]$"
                        }
                    },
                    "institutions": {
                        "title": "Institutions",
                        "maxItems": 6,
                        "type": "array",
                        "description": "Enter one institution to map, or 2-6 institutions to compare.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "discoveryQuery": {
                        "title": "Discovery topic or query",
                        "type": "string",
                        "description": "Build a shortlist from a research field, topic, name, affiliation, or Lucene query."
                    },
                    "discoveryGoal": {
                        "title": "Discovery goal",
                        "enum": [
                            "experts",
                            "reviewers",
                            "collaborators",
                            "fieldRadar"
                        ],
                        "type": "string",
                        "description": "Choose the shortlist or radar view you want from the discovery target.",
                        "default": "experts"
                    },
                    "seedOrcidId": {
                        "title": "Seed ORCID iD",
                        "type": "string",
                        "description": "Use with collaborator matches to compare candidates against one known researcher."
                    },
                    "conflictAffiliations": {
                        "title": "Conflict affiliations",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Use with reviewer shortlists to flag candidates from these organizations.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "publicationDetail": {
                        "title": "Publication detail",
                        "enum": [
                            "countsOnly",
                            "recentWorks",
                            "fullWorks"
                        ],
                        "type": "string",
                        "description": "Choose how much works data to include for each researcher.",
                        "default": "recentWorks"
                    },
                    "maxWorksPerProfile": {
                        "title": "Maximum works per profile",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Used when publication detail collects recent or full works.",
                        "default": 25
                    },
                    "profileFormat": {
                        "title": "Profile format",
                        "enum": [
                            "standard",
                            "full",
                            "spreadsheet"
                        ],
                        "type": "string",
                        "description": "Choose the profile depth for exports and API reads.",
                        "default": "standard"
                    },
                    "includeRelationshipMap": {
                        "title": "Include relationship map",
                        "type": "boolean",
                        "description": "Add cohort similarity and graph records when a run returns multiple researchers.",
                        "default": false
                    },
                    "maxResultsPerTarget": {
                        "title": "Maximum profiles per search target",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Applies to search, institution, and discovery targets.",
                        "default": 125
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```