# Reactome Pathways Scraper (`parseforge/reactome-pathways-scraper`) Actor

Pull curated biology pathways, reactions, proteins, and complexes from the Reactome knowledgebase. List every top level pathway for a species, search by gene or process keyword, or resolve a stable ID. Returns names, species, schema class, disease flags, and direct browser links.

- **URL**: https://apify.com/parseforge/reactome-pathways-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, AI, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧬 Reactome Pathways Scraper

> 🚀 **Export curated biology pathways in seconds.** Pull the full set of top-level human pathways (29 entries), search 10+ result types per keyword, or look up any entity by stable ID with its summary and sub-event count.

> 🕒 **Last updated:** 2026-06-04 · **📊 Up to 13 fields** per record · 10 species supported · Reactome ContentService (open, keyless)

Reactome is a free, open-source, peer-reviewed knowledgebase of biological pathways. This Actor turns its public ContentService into clean, structured records you can drop straight into a notebook, a spreadsheet, or a downstream pipeline. Point it at a species to list every top-level pathway, search by a gene or process keyword, or resolve a single stable identifier such as R-HSA-109581.

Coverage spans curated pathways, reactions, proteins, complexes, and sets. Each record carries the Reactome stable identifier, display name, species, schema class, disease flag, diagram availability, and a direct Pathway Browser link, so you always know exactly which entity you are looking at and where to view it.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Bioinformaticians and computational biologists | Building pathway reference tables for enrichment analysis |
| Data scientists in life sciences and pharma | Mapping genes and proteins to curated pathways |
| Researchers and graduate students | Pulling pathway summaries and sub-event counts for review |
| Knowledge engineers and database builders | Seeding internal catalogs with stable Reactome identifiers |

### 📋 What the Reactome Pathways Scraper does

- Lists every top-level pathway for a chosen species (Homo sapiens returns 29 entries).
- Searches Reactome by keyword and returns matching pathways, reactions, proteins, complexes, and sets.
- Looks up a single entity by stable identifier and adds a plain-text summary plus a sub-event count.
- Strips embedded HTML from names and summaries so values are ready to use.
- Builds a direct Pathway Browser link for every record.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

Provide one of three modes. A stable identifier takes priority, then a search term, otherwise the Actor lists top-level pathways for the selected species.

| Field | Type | Description |
|---|---|---|
| `searchTerm` | string | Keyword to search across Reactome, for example apoptosis, glucose, or TP53. |
| `stId` | string | Reactome stable identifier to look up a single entity, for example R-HSA-109581. |
| `species` | select | Species for the top-level listing. Defaults to Homo sapiens (9606). Ten species supported. |
| `maxItems` | integer | Free users limited to 10 items. Paid users up to 1,000,000. |

Example 1, list top-level human pathways:

```json
{
  "species": "9606",
  "maxItems": 10
}
````

Example 2, search by keyword:

```json
{
  "searchTerm": "apoptosis",
  "maxItems": 25
}
```

> ⚠️ **Good to Know:** Reactome search names and summaries arrive wrapped in HTML highlight tags. This Actor removes those tags for you, so the values you receive are clean text. Stable identifiers are species-specific, for example R-HSA for human and R-MMU for mouse.

### 📊 Output

Each record is one pathway, reaction, or entity. Conditional fields appear only when the source provides them: `name` on listing and lookup records, `summary` when a description exists, `subEventCount` in lookup mode, and `searchType` in search mode.

| Field | Description |
|---|---|
| 🆔 `stId` | Reactome stable identifier |
| 🔢 `dbId` | Internal Reactome database identifier |
| 📌 `displayName` | Human readable name |
| 🏷 `name` | All known names, joined |
| 🧬 `speciesName` | Species the entity belongs to |
| 🗂 `schemaClass` | Reactome class, such as Pathway or TopLevelPathway |
| 🩺 `isInDisease` | Whether the entity is associated with disease |
| 🖼 `hasDiagram` | Whether a pathway diagram exists |
| ✨ `hasEHLD` | Whether an enhanced high level diagram exists |
| 🔗 `url` | Direct Pathway Browser link |
| 📝 `summary` | Plain text description, when available |
| 🔁 `subEventCount` | Number of contained sub-events, lookup mode |
| 🔎 `searchType` | Result type label, search mode |
| 🕒 `scrapedAt` | Timestamp of collection |
| ❌ `error` | Error message, null on success |

Three real records from a live run:

```json
{
  "stId": "R-HSA-9612973",
  "dbId": 9612973,
  "displayName": "Autophagy",
  "name": "Autophagy",
  "speciesName": "Homo sapiens",
  "schemaClass": "TopLevelPathway",
  "isInDisease": false,
  "hasDiagram": true,
  "hasEHLD": true,
  "url": "https://reactome.org/PathwayBrowser/#/R-HSA-9612973",
  "scrapedAt": "2026-06-04T19:42:28.000Z",
  "error": null
}
```

```json
{
  "stId": "R-HSA-1640170",
  "dbId": 1640170,
  "displayName": "Cell Cycle",
  "name": "Cell Cycle",
  "speciesName": "Homo sapiens",
  "schemaClass": "TopLevelPathway",
  "isInDisease": false,
  "hasDiagram": true,
  "hasEHLD": true,
  "url": "https://reactome.org/PathwayBrowser/#/R-HSA-1640170",
  "scrapedAt": "2026-06-04T19:42:28.000Z",
  "error": null
}
```

```json
{
  "stId": "R-HSA-1500931",
  "dbId": 1500931,
  "displayName": "Cell-Cell communication",
  "name": "Cell-Cell communication",
  "speciesName": "Homo sapiens",
  "schemaClass": "TopLevelPathway",
  "isInDisease": false,
  "hasDiagram": true,
  "hasEHLD": true,
  "url": "https://reactome.org/PathwayBrowser/#/R-HSA-1500931",
  "scrapedAt": "2026-06-04T19:42:28.000Z",
  "error": null
}
```

### ✨ Why choose this Actor

- Three modes in one tool, listing, search, and single lookup.
- Keyless and stable, built on the official Reactome ContentService.
- Clean values, HTML highlight tags removed before you receive them.
- Conditional fields only when real, so you never ship always-null columns.
- Direct Pathway Browser links on every record for instant context.

### 📈 How it compares to alternatives

| Approach | Setup | Clean output | Multi-mode | Maintenance |
|---|---|---|---|---|
| This Actor | None, run and go | Yes | Listing, search, lookup | Managed |
| Manual API calls | Write and host code | You parse HTML yourself | You build each call | Yours |
| Copy from the website | Slow and manual | No | No | High effort |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Reactome Pathways Scraper in the Apify Console.
3. Choose a mode, set a species, type a search term, or paste a stable identifier.
4. Set how many records you want with the items limit.
5. Run the Actor and collect your structured pathway records.

### 💼 Business use cases

#### Pharma and biotech research

| Need | How this helps |
|---|---|
| Target discovery context | Map proteins and genes to curated pathways |
| Disease association review | Filter records by the disease flag |

#### Bioinformatics pipelines

| Need | How this helps |
|---|---|
| Reference tables | Seed enrichment analysis with stable identifiers |
| Reproducibility | Pin records to versioned Reactome entries |

#### Academic and teaching

| Need | How this helps |
|---|---|
| Course materials | Pull pathway names and summaries for slides |
| Literature reviews | Resolve identifiers to readable descriptions |

#### Knowledge base and catalog building

| Need | How this helps |
|---|---|
| Internal catalogs | Populate tables with names, species, and links |
| Cross referencing | Use stable identifiers as join keys |

### 🔌 Automating Reactome Pathways Scraper

Connect the Actor to the tools your team already uses. Trigger runs and route results through Make, Zapier, Slack, Airbyte, GitHub Actions, or Google Drive using the Apify API and integrations. Schedule recurring runs to keep a local pathway catalog fresh, or post new lookups to a Slack channel for your research group.

### 🌟 Beyond business use cases

- **Research:** assemble pathway datasets for a thesis or a paper.
- **Personal:** explore the biology behind a gene or a condition you care about.
- **Non-profit:** build open educational resources around cell biology.
- **Experimentation:** prototype a pathway browser or a graph of biological events.

### 🤖 Ask an AI assistant

Pair the structured output with [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) to summarize pathway descriptions, group results by schema class, or draft an enrichment report from your collected records.

### ❓ Frequently Asked Questions

**Is this Actor affiliated with Reactome?**
No. It is an independent tool that reads the public Reactome ContentService. Only publicly available data is collected.

**Do I need an API key?**
No. The Reactome ContentService is open and keyless.

**Which species are supported?**
Ten, including Homo sapiens, Mus musculus, Rattus norvegicus, Danio rerio, Drosophila melanogaster, Caenorhabditis elegans, Saccharomyces cerevisiae, Arabidopsis thaliana, Bos taurus, and Gallus gallus.

**How many top-level pathways does human return?**
Twenty-nine at the time of writing. Mouse returns twenty-eight.

**What is a stable identifier?**
A persistent Reactome ID such as R-HSA-109581. The R-HSA prefix marks human entities, R-MMU marks mouse.

**What gets returned in search mode?**
Matching pathways, reactions, proteins, complexes, and sets, each with a result type label.

**Why are some fields missing on some records?**
Fields appear only when the source provides them. Search entries, for example, do not carry diagram flags, so those fields are omitted rather than shipped as null.

**Does it return pathway descriptions?**
Yes, when available. Lookup mode and search results include a plain text summary with HTML tags removed.

**How many records can I collect?**
Free users get up to 10 items per run. Paid users can collect up to 1,000,000.

**Can I see the pathway diagram?**
Each record includes a direct Pathway Browser link where you can open the diagram.

**How fresh is the data?**
Records reflect the live Reactome ContentService at the moment of the run.

**Can I automate recurring runs?**
Yes. Use Apify schedules and integrations to run the Actor on a cadence and route results to your tools.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and the integrations catalog to push records into your database, data warehouse, or workflow automation tool. Every run produces a structured dataset you can fetch programmatically.

### 🔗 Recommended Actors

- [KEGG Pathways Scraper](https://apify.com/parseforge/kegg-pathways-scraper)
- [UniProt Scraper](https://apify.com/parseforge/uniprot-scraper)
- [ChEMBL Molecules Scraper](https://apify.com/parseforge/chembl-molecules-scraper)
- [Ensembl Genomics Scraper](https://apify.com/parseforge/ensembl-genomics-scraper)
- [Open Targets Platform Scraper](https://apify.com/parseforge/open-targets-platform-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with Reactome. Only publicly available data collected.

# Actor input Schema

## `searchTerm` (type: `string`):

Keyword to search across Reactome (for example 'apoptosis', 'glucose', 'TP53'). Returns matching pathways, reactions, proteins, and complexes. Leave empty to list top-level pathways for the chosen species.

## `stId` (type: `string`):

Reactome stable identifier to look up a single entity, for example R-HSA-109581 (Apoptosis). When set, this takes priority over the search term.

## `species` (type: `string`):

Species for the top-level pathway listing. Used only when no search term and no stId are provided.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "species": "9606",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/reactome-pathways-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/reactome-pathways-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 '{
  "maxItems": 10
}' |
apify call parseforge/reactome-pathways-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reactome Pathways Scraper",
        "description": "Pull curated biology pathways, reactions, proteins, and complexes from the Reactome knowledgebase. List every top level pathway for a species, search by gene or process keyword, or resolve a stable ID. Returns names, species, schema class, disease flags, and direct browser links.",
        "version": "0.1",
        "x-build-id": "dYtRQN2cDRyYBgr80"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~reactome-pathways-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-reactome-pathways-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/parseforge~reactome-pathways-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-reactome-pathways-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/parseforge~reactome-pathways-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-reactome-pathways-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": {
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Keyword to search across Reactome (for example 'apoptosis', 'glucose', 'TP53'). Returns matching pathways, reactions, proteins, and complexes. Leave empty to list top-level pathways for the chosen species."
                    },
                    "stId": {
                        "title": "Stable Identifier (stId)",
                        "type": "string",
                        "description": "Reactome stable identifier to look up a single entity, for example R-HSA-109581 (Apoptosis). When set, this takes priority over the search term."
                    },
                    "species": {
                        "title": "Species",
                        "enum": [
                            "9606",
                            "10090",
                            "10116",
                            "7955",
                            "7227",
                            "6239",
                            "4932",
                            "3702",
                            "9913",
                            "9031"
                        ],
                        "type": "string",
                        "description": "Species for the top-level pathway listing. Used only when no search term and no stId are provided.",
                        "default": "9606"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```