# ROR Research Organization Registry Scraper (`automation-lab/ror-research-organization-registry-scraper`) Actor

🔎 Export normalized Research Organization Registry records with ROR IDs, locations, websites, domains, relationships, and external IDs.

- **URL**: https://apify.com/automation-lab/ror-research-organization-registry-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, 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

## ROR Research Organization Registry Scraper

Find and export clean organization records from the public Research Organization Registry (ROR). This actor helps you turn ROR search results into a spreadsheet-ready dataset with ROR IDs, names, websites, countries, cities, domains, aliases, relationships, and external identifiers.

### What does ROR Research Organization Registry Scraper do?

ROR Research Organization Registry Scraper queries the official ROR organizations API and saves normalized organization rows to an Apify dataset.

It is useful when you need reliable organization identifiers for universities, hospitals, research institutes, companies, funders, nonprofits, archives, facilities, and government research organizations.

The actor uses HTTP requests to the public JSON API. It does not need a login, browser automation, or a private API key.

### Who is it for?

#### 🧪 Research intelligence and bibliometrics teams

Use the actor to normalize author affiliations, map institutions to stable ROR IDs, enrich publication datasets, and keep research organization directories consistent across dashboards.

Typical workflows:

- Match messy affiliation strings to persistent organization identifiers.
- Export universities, hospitals, funders, and institutes by country or type.
- Join ROR records with OpenAlex, Crossref, Wikidata, GRID, ISNI, or FundRef data.

#### 🏫 Universities, healthcare systems, and public-sector analysts

Use the actor when you need a clean reference list of schools, medical centers, laboratories, facilities, agencies, archives, or nonprofit research organizations.

Typical workflows:

- Build or refresh institutional master data for analytics teams.
- Find active healthcare research organizations in a target geography.
- Audit domains, aliases, acronyms, and related organizations before loading a CRM or warehouse.

#### 💼 Sales, partnerships, grant, and data operations teams

Use the actor to turn ROR search into repeatable prospecting, enrichment, and deduplication workflows without hand-copying registry pages.

Typical workflows:

- Prospect universities, funders, hospitals, and labs for B2B or partnership outreach.
- Deduplicate organization names before account matching or vendor research.
- Schedule recurring exports so downstream systems get current public registry data.

### Why use this actor?

ROR is a trusted open registry, but analysts often need data in repeatable CSV, JSON, Excel, or API workflows. This actor handles search, filters, pagination, normalization, and output formatting for you.

You can run it on a schedule, connect it to webhooks, or use it from the Apify API when you need fresh organization intelligence.

### Typical use cases

- Build a directory of active US education institutions.
- Export healthcare research organizations in a target country.
- Normalize company, hospital, or university names with ROR IDs.
- Collect domains for institutional email matching.
- Map organizations to Wikidata, GRID, ISNI, or FundRef identifiers.
- Feed CRM, enrichment, bibliometrics, and lead research pipelines.

### Data you can extract

| Field | Description |
|---|---|
| `rorId` | Compact ROR identifier. |
| `rorUrl` | Full ROR URL. |
| `name` | Primary organization name. |
| `status` | ROR status such as active. |
| `types` | Organization types such as education or healthcare. |
| `established` | Established year when available. |
| `countryCode` | ISO country code. |
| `countryName` | Country name. |
| `city` | City or location name. |
| `state` | Region or subdivision. |
| `domains` | Known web domains. |
| `websiteUrl` | Website link. |
| `aliases` | Alternative names. |
| `acronyms` | Acronyms. |
| `relationships` | Related organizations. |
| `wikidataIds` | Wikidata IDs. |
| `fundrefIds` | FundRef IDs. |

### How much does it cost to scrape ROR organizations?

This actor uses pay-per-event pricing. You pay a small run start fee and then a per-organization fee for each dataset row saved. There is no proxy surcharge because the actor calls the public ROR API directly.

The default run is intentionally small and inexpensive. Increase `maxItems` when you are ready to export larger ROR result sets.

| Example run | Input idea | Rows saved | Estimated actor charge* | Best for |
|---|---:|---:|---:|---|
| Quick lookup | `queries=["stanford"]` | 10 | about $0.0052 | Testing the fields and output format. |
| Focused country/type export | `university` + `US` + `education` | 100 | about $0.0073 | A small institutional list or QA sample. |
| Larger reference pull | `hospital` or `research institute` | 1,000 | about $0.0283 | CRM, data warehouse, or analytics refreshes. |

\*Estimates use the current BRONZE tier: a $0.005 start event plus roughly $0.000023 per saved organization. Exact charges can vary by your Apify plan tier and future pricing updates. The Apify Free plan can usually cover many small tests; at this price, a $5 free monthly credit is roughly enough for hundreds of quick 10-row lookups or about 170,000 saved organization rows after start fees.

### Input options

Provide one or more search queries and optional filters.

```json
{
  "queries": ["university"],
  "countryCodes": ["US"],
  "organizationTypes": ["education"],
  "statuses": ["active"],
  "maxItems": 100,
  "requestDelayMs": 250,
  "includeRawData": false
}
````

### Search queries

Use organization names, keywords, or category-like terms.

Good examples:

- `university`
- `hospital`
- `cancer center`
- `max planck`
- `stanford`
- `research institute`

### Country filters

Use ISO 3166-1 alpha-2 country codes.

Examples:

- `US`
- `GB`
- `DE`
- `CA`
- `AU`
- `FR`

### Organization type filters

ROR commonly uses these types:

- `education`
- `healthcare`
- `company`
- `funder`
- `nonprofit`
- `government`
- `facility`
- `archive`
- `other`

### Status filters

Most production workflows should use:

- `active`

You can also omit the status filter if you want the API's broader default matching behavior.

### Output example

```json
{
  "rorId": "00f54p054",
  "rorUrl": "https://ror.org/00f54p054",
  "name": "Stanford University",
  "status": "active",
  "types": ["education", "funder"],
  "countryCode": "US",
  "countryName": "United States",
  "city": "Stanford",
  "domains": ["stanford.edu"],
  "websiteUrl": "https://www.stanford.edu",
  "wikidataIds": ["Q41506"],
  "query": "stanford"
}
```

### How to run the actor

1. Open the actor on Apify.
2. Enter one or more search queries.
3. Add country, type, or status filters if needed.
4. Set `maxItems` to the maximum number of organizations to export.
5. Start the run.
6. Download the dataset as CSV, JSON, Excel, XML, or RSS.

### Tips for better results

- Start broad with `university`, `hospital`, or `research institute`.
- Add `countryCodes` to keep output focused.
- Add `organizationTypes` when you need only universities, hospitals, companies, or funders.
- Use `includeRawData` when you need every original ROR source field.
- Run several smaller filtered searches instead of one huge unfocused query.

### Integrations

Use this actor with:

- CRM enrichment workflows for organization identity resolution.
- Grant prospecting pipelines that need funder and research institution metadata.
- Bibliometrics dashboards that normalize affiliation strings.
- University partnership databases.
- Data warehouse jobs that periodically refresh ROR IDs and domains.
- Vendor discovery systems that target public research organizations.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ror-research-organization-registry-scraper').call({
  queries: ['university'],
  countryCodes: ['US'],
  organizationTypes: ['education'],
  statuses: ['active'],
  maxItems: 100,
});

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

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/ror-research-organization-registry-scraper').call(run_input={
    'queries': ['hospital'],
    'countryCodes': ['GB'],
    'organizationTypes': ['healthcare'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~ror-research-organization-registry-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["university"],"countryCodes":["US"],"organizationTypes":["education"],"maxItems":100}'
```

### MCP usage

You can use this actor from Apify MCP in Claude Desktop, Claude Code, and other MCP-compatible tools.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper
```

Claude Code setup:

```bash
claude mcp add --transport http apify-ror "https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper"
```

Claude Desktop, Cursor, or VS Code MCP JSON config:

```json
{
  "mcpServers": {
    "apify-ror": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/ror-research-organization-registry-scraper"
    }
  }
}
```

Where to paste it:

- **Claude Desktop:** Settings → Developer → Edit Config, then restart Claude Desktop.
- **Cursor:** Settings → MCP → Add server, or paste the JSON into your Cursor MCP config file.
- **VS Code:** Add the same server object to your MCP extension/server configuration.

Example prompts:

- "Find active ROR education organizations in the United States and summarize the top domains."
- "Export healthcare research organizations in the United Kingdom from ROR."
- "Normalize this list of university names using ROR IDs."

### Scheduling

Schedule the actor weekly or monthly to refresh your organization reference table. ROR records can change as names, relationships, and external identifiers are updated.

### Webhooks

Attach an Apify webhook to send completed datasets into your own system, warehouse, or automation platform.

### Data quality notes

The actor returns data from the public ROR API. Some fields are optional because the source registry does not have every domain, coordinate, relationship, or external identifier for every organization.

### Legality

This actor uses a public registry API and exports factual organization metadata. Always use the data according to your local laws, ROR terms, and your organization's data governance policies.

### FAQ

#### Why did I get fewer rows than expected?

ROR search is relevance based and filters can narrow results. Try a broader query, remove a country or type filter, or increase `maxItems`.

#### Why are some fields empty?

Not every ROR organization has every optional field. Empty arrays or missing URLs usually mean the source record does not provide that data.

### Related scrapers

Other automation-lab actors can complement this workflow:

- https://apify.com/automation-lab/openalex-scraper
- https://apify.com/automation-lab/crossref-scraper
- https://apify.com/automation-lab/google-scholar-scraper
- https://apify.com/automation-lab/website-contact-finder

### Changelog

Initial version exports normalized ROR organization rows from the public API.

### Support

If you need a new field, a different filter, or a larger enrichment workflow, open an issue on the actor page.

### Field reference

`rorId` is the stable compact ID.

`rorUrl` is the canonical ROR URL.

`name` is the display name.

`types` contains all source organization types.

`domains` contains known domains.

`relationships` contains related organization summaries.

`gridIds`, `isniIds`, `fundrefIds`, and `wikidataIds` help match records across external systems.

### Performance

The ROR API returns up to 20 organizations per page. The actor paginates until it reaches `maxItems` or the result set ends.

### Reliability

The actor retries temporary API failures and uses a polite configurable delay between requests.

# Actor input Schema

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

Organization names or discovery keywords to search in ROR, such as university, hospital, stanford, max planck, or cancer center.

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

Maximum number of ROR organization records to save across all queries.

## `countryCodes` (type: `array`):

Optional ISO 3166-1 alpha-2 country filters. Examples: US, GB, DE, CA, AU.

## `organizationTypes` (type: `array`):

Optional ROR type filters. Common values: education, healthcare, company, funder, nonprofit, government, facility, archive, other.

## `statuses` (type: `array`):

Optional status filters. Most workflows use active.

## `startPage` (type: `integer`):

ROR API page to start from. Leave as 1 for normal runs.

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

Polite delay between ROR API pages. Increase if you run very large jobs.

## `includeRawData` (type: `boolean`):

Adds the full source organization JSON to each dataset item for auditing or custom post-processing.

## Actor input object example

```json
{
  "queries": [
    "university"
  ],
  "maxItems": 20,
  "countryCodes": [
    "US"
  ],
  "organizationTypes": [
    "education"
  ],
  "statuses": [
    "active"
  ],
  "startPage": 1,
  "requestDelayMs": 250,
  "includeRawData": false
}
```

# 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": [
        "university"
    ],
    "maxItems": 20,
    "countryCodes": [
        "US"
    ],
    "organizationTypes": [
        "education"
    ],
    "statuses": [
        "active"
    ],
    "startPage": 1,
    "requestDelayMs": 250,
    "includeRawData": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ror-research-organization-registry-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": ["university"],
    "maxItems": 20,
    "countryCodes": ["US"],
    "organizationTypes": ["education"],
    "statuses": ["active"],
    "startPage": 1,
    "requestDelayMs": 250,
    "includeRawData": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ror-research-organization-registry-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": [
    "university"
  ],
  "maxItems": 20,
  "countryCodes": [
    "US"
  ],
  "organizationTypes": [
    "education"
  ],
  "statuses": [
    "active"
  ],
  "startPage": 1,
  "requestDelayMs": 250,
  "includeRawData": false
}' |
apify call automation-lab/ror-research-organization-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ROR Research Organization Registry Scraper",
        "description": "🔎 Export normalized Research Organization Registry records with ROR IDs, locations, websites, domains, relationships, and external IDs.",
        "version": "0.1",
        "x-build-id": "NtQKPjdft8BlMOxNh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ror-research-organization-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ror-research-organization-registry-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~ror-research-organization-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ror-research-organization-registry-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~ror-research-organization-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ror-research-organization-registry-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",
                    "maxItems"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Organization names or discovery keywords to search in ROR, such as university, hospital, stanford, max planck, or cancer center.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum organizations",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of ROR organization records to save across all queries.",
                        "default": 20
                    },
                    "countryCodes": {
                        "title": "Country codes",
                        "type": "array",
                        "description": "Optional ISO 3166-1 alpha-2 country filters. Examples: US, GB, DE, CA, AU.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizationTypes": {
                        "title": "Organization types",
                        "type": "array",
                        "description": "Optional ROR type filters. Common values: education, healthcare, company, funder, nonprofit, government, facility, archive, other.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "statuses": {
                        "title": "Statuses",
                        "type": "array",
                        "description": "Optional status filters. Most workflows use active.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startPage": {
                        "title": "Start page",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "ROR API page to start from. Leave as 1 for normal runs.",
                        "default": 1
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Polite delay between ROR API pages. Increase if you run very large jobs.",
                        "default": 250
                    },
                    "includeRawData": {
                        "title": "Include raw ROR JSON",
                        "type": "boolean",
                        "description": "Adds the full source organization JSON to each dataset item for auditing or custom post-processing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
