# InterPro Protein Families Scraper (`parseforge/interpro-protein-families-scraper`) Actor

Pull protein family and domain entries from the EBI InterPro database by accession or by browsing every entry. Each record carries the accession, type, name, member database signatures from Pfam, SMART and CDD, GO terms, and protein counts. Built for bioinformatics annotation work.

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

## Pricing

from $7.69 / 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)

## 🧬 InterPro Protein Families Scraper

> 🚀 **Export protein family and domain entries from InterPro in one run.** Pull from a catalog of more than 51,000 entries across the EBI InterPro database.

> 🕒 **Last updated:** 2026-06-08 · **📊 20 fields** per record · 8 entry types · live EBI InterPro API

Turn the EBI InterPro classification database into clean, structured records you can drop into a bioinformatics pipeline, a functional annotation table, or a protein research notebook. Fetch specific accessions like `IPR000001`, or browse the full catalog and narrow it to a single entry type such as family or domain.

Coverage is the complete public InterPro entry set as the EMBL-EBI InterPro API publishes it: every entry with its accession, type, name, integrated member database signatures from Pfam, SMART, CDD, PANTHER and more, Gene Ontology terms, overlapping superfamilies, and live counts of matching proteins, structures, taxa, and pathways.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Bioinformaticians and computational biologists | Annotate proteins with family and domain assignments |
| Database and tool builders | Seed a local copy of the InterPro classification |
| Protein and structural biology researchers | Map signatures, GO terms, and overlapping superfamilies |
| Data scientists in life sciences | Build feature tables from family membership and counts |

### 📋 What the InterPro Protein Families Scraper does

This Actor calls the public EBI InterPro REST API and returns one clean record per entry:

- **By accession** — provide a list of InterPro accessions and get exactly those entries with full detail.
- **Browse all** — leave the accession list empty to walk the whole catalog, optionally filtered to one entry type.

Each record carries the entry accession, type, name, short name, member database signatures, GO terms, overlapping superfamilies, a cleaned text description, live counters, and a `scrapedAt` timestamp.

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

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `accessions` | array | Optional list of InterPro accessions to fetch, for example `IPR000001`. When non-empty, the Actor fetches exactly these entries and ignores the type filter. |
| `type` | select | Used only when no accessions are given. Restricts browsing to one entry type. One of family, domain, homologous_superfamily, repeat, conserved_site, active_site, binding_site, ptm, or any. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — fetch specific accessions**
```json
{
    "accessions": ["IPR000001", "IPR000003", "IPR000006"],
    "maxItems": 10
}
````

**Example 2 — browse all families**

```json
{
    "type": "family",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** The InterPro catalog holds more than 51,000 entries. When browsing, set `maxItems` to the slice you actually need. Browsing fetches each entry's full detail page, so larger runs take longer than a flat list.

### 📊 Output

Each record looks like this:

| Field | Description |
|---|---|
| 🧬 `accession` | InterPro accession (stable ID) |
| 📌 `name` | Entry name |
| 🏷 `type` | Entry type (family, domain, etc.) |
| 🔗 `url` | InterPro entry page URL |
| ✂️ `shortName` | Short machine-friendly name |
| 🗄 `sourceDatabase` | Source database (interpro) |
| 📝 `description` | Cleaned text description |
| 🗂 `memberDatabaseList` | Member databases that contribute signatures |
| 🔢 `memberDatabaseCount` | Number of member databases |
| 🧩 `signaturesCount` | Number of integrated signatures |
| 🧩 `signatures` | Array of signatures (database, accession, name) |
| 🔬 `goTermsCount` | Number of GO terms |
| 🔬 `goTerms` | Array of GO terms (identifier, name, category) |
| 🔁 `overlapsWith` | Overlapping entries (accession, name, type) |
| 👥 `proteinCount` | Matching proteins |
| 🧱 `structureCount` | Matching structures |
| 🌳 `taxaCount` | Matching taxa |
| 🛤 `pathwayCount` | Linked pathways |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — domain**

```json
{
    "accession": "IPR000001",
    "name": "Kringle",
    "type": "domain",
    "url": "https://www.ebi.ac.uk/interpro/entry/InterPro/IPR000001/",
    "shortName": "Kringle",
    "sourceDatabase": "interpro",
    "description": "Kringles are autonomous structural domains, found throughout the blood clotting and fibrinolytic proteins...",
    "memberDatabaseList": ["cdd", "profile", "pfam", "smart"],
    "memberDatabaseCount": 4,
    "signaturesCount": 4,
    "signatures": [
        { "database": "cdd", "accession": "cd00108", "name": "KR" },
        { "database": "pfam", "accession": "PF00051", "name": "Kringle domain" },
        { "database": "smart", "accession": "SM00130", "name": "Kringle domain" }
    ],
    "goTermsCount": 0,
    "goTerms": [],
    "overlapsWith": [
        { "accession": "IPR038178", "name": "Kringle superfamily", "type": "homologous_superfamily" },
        { "accession": "IPR013806", "name": "Kringle-like fold", "type": "homologous_superfamily" }
    ],
    "proteinCount": 21741,
    "structureCount": 134,
    "taxaCount": 4840,
    "pathwayCount": 131,
    "scrapedAt": "2026-06-08T18:39:40.638Z",
    "error": null
}
```

**Real sample — family with GO terms**

```json
{
    "accession": "IPR000003",
    "name": "Retinoid X receptor/HNF4",
    "type": "family",
    "url": "https://www.ebi.ac.uk/interpro/entry/InterPro/IPR000003/",
    "shortName": "Retinoid-X_rcpt/HNF4",
    "sourceDatabase": "interpro",
    "description": "Steroid or nuclear hormone receptors (NRs) constitute an important superfamily of transcription regulators...",
    "memberDatabaseList": ["prints"],
    "memberDatabaseCount": 1,
    "signaturesCount": 1,
    "signatures": [
        { "database": "prints", "accession": "PR00545", "name": "Retinoid X receptor" }
    ],
    "goTermsCount": 5,
    "goTerms": [
        { "identifier": "GO:0003677", "name": "DNA binding", "category": "molecular_function" },
        { "identifier": "GO:0005634", "name": "nucleus", "category": "cellular_component" }
    ],
    "overlapsWith": [
        { "accession": "IPR013088", "name": "Zinc finger, NHR/GATA-type", "type": "homologous_superfamily" }
    ],
    "proteinCount": 8170,
    "structureCount": 127,
    "taxaCount": 4458,
    "pathwayCount": 85,
    "scrapedAt": "2026-06-08T18:39:40.810Z",
    "error": null
}
```

**Real sample — family**

```json
{
    "accession": "IPR000006",
    "name": "Metallothionein, vertebrate",
    "type": "family",
    "url": "https://www.ebi.ac.uk/interpro/entry/InterPro/IPR000006/",
    "shortName": "Metalthion_vert",
    "sourceDatabase": "interpro",
    "description": "Metallothioneins (MT) are small proteins that bind heavy metals, such as zinc, copper, cadmium, nickel...",
    "memberDatabaseList": ["panther", "pfam", "prints"],
    "memberDatabaseCount": 3,
    "signaturesCount": 3,
    "signatures": [
        { "database": "panther", "accession": "PTHR23299", "name": "METALLOTHIONEIN" },
        { "database": "pfam", "accession": "PF00131", "name": "Metallothionein" }
    ],
    "goTermsCount": 1,
    "goTerms": [
        { "identifier": "GO:0046872", "name": "metal ion binding", "category": "molecular_function" }
    ],
    "overlapsWith": [
        { "accession": "IPR017854", "name": "Metallothionein domain superfamily", "type": "homologous_superfamily" }
    ],
    "proteinCount": 2444,
    "structureCount": 14,
    "taxaCount": 2186,
    "pathwayCount": 9,
    "scrapedAt": "2026-06-08T18:39:40.939Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per entry, with the stable accession placed first for instant lookup.
- Two modes in one Actor, so accession lookups and full browsing share a consistent shape.
- Member database signatures and GO terms come fully expanded, not as bare nested blobs.
- No account, no key, and no login required.
- Stable field names that map cleanly onto a database schema.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Counts included | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Yes | None on your side |
| Hand-copying from the InterPro site | Hours | Inconsistent | Manual | Constant |
| Writing your own API client | Days | Depends | Manual | You own the upkeep |

### 🚀 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 InterPro Protein Families Scraper.
3. Either paste a list of `accessions`, or leave it empty and pick a `type` to browse.
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Bioinformatics and annotation

| Goal | How this helps |
|---|---|
| Annotate proteins with families | Pull entries with signatures and GO terms |
| Map domains across a proteome | Browse by type and join on accession |

#### Database and tool building

| Goal | How this helps |
|---|---|
| Seed a local InterPro mirror | Walk the catalog with paging built in |
| Power a domain lookup service | Feed it accession, name, and signatures |

#### Research and analysis

| Goal | How this helps |
|---|---|
| Study family coverage | Use protein, structure, and taxa counts |
| Trace related superfamilies | Follow the overlapsWith links |

#### Teaching and reference

| Goal | How this helps |
|---|---|
| Build course datasets | Export a curated set of accessions |
| Create reference sheets | Use the cleaned descriptions and short names |

### 🔌 Automating InterPro Protein Families Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route records into sheets or databases.
- **Slack** to post a summary when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study how protein family classifications are organized.
- **Personal:** build your own domain reference for a favorite protein.
- **Non-profit:** power an open educational resource on protein biology.
- **Experimentation:** prototype an annotation tool without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize a family, group entries by member database, or explain the GO terms attached to a domain.

### ❓ Frequently Asked Questions

**Do I need an InterPro or EBI account?**
No. The Actor reads the public InterPro REST API, which needs no login.

**Do I need an API key?**
No key is required.

**How do I fetch specific entries?**
Put their accessions in the `accessions` list, for example `IPR000001`. When that list is filled, the type filter is ignored.

**How do I browse the whole catalog?**
Leave `accessions` empty and set `maxItems`. Optionally pick a `type` to narrow the browse.

**Which entry types are supported?**
Family, domain, homologous\_superfamily, repeat, conserved\_site, active\_site, binding\_site, and ptm, plus an any option.

**How many entries are there?**
At the time of writing, the InterPro API reports more than 51,000 entries.

**Are member database signatures included?**
Yes. Each record lists the contributing databases and an expanded array of signatures with database, accession, and name.

**Are GO terms included?**
Yes, when InterPro has assigned them. Each GO term carries its identifier, name, and category.

**Why is the description cleaned up?**
InterPro descriptions contain HTML and citation markers. The Actor strips those so you get plain readable text.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the catalog on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- [Have I Been Pwned Breaches Catalog Scraper](https://apify.com/parseforge)
- More reference and scientific data Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **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 InterPro, EMBL-EBI, or the European Bioinformatics Institute. Only publicly available data is collected.

# Actor input Schema

## `accessions` (type: `array`):

Optional list of specific InterPro accessions to fetch, for example 'IPR000001' or 'IPR000003'. When this list is non-empty the Actor fetches exactly these entries and ignores the type filter. Leave empty to browse all entries instead.

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

Only used when no accessions are provided. Restricts the browse to a single InterPro entry type. Choose 'Any type' to include every entry.

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

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

## Actor input object example

```json
{
  "accessions": [
    "IPR000001",
    "IPR000003",
    "IPR000006"
  ],
  "type": "",
  "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 = {
    "accessions": [
        "IPR000001",
        "IPR000003",
        "IPR000006"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/interpro-protein-families-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 = {
    "accessions": [
        "IPR000001",
        "IPR000003",
        "IPR000006",
    ],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/interpro-protein-families-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 '{
  "accessions": [
    "IPR000001",
    "IPR000003",
    "IPR000006"
  ],
  "maxItems": 10
}' |
apify call parseforge/interpro-protein-families-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "InterPro Protein Families Scraper",
        "description": "Pull protein family and domain entries from the EBI InterPro database by accession or by browsing every entry. Each record carries the accession, type, name, member database signatures from Pfam, SMART and CDD, GO terms, and protein counts. Built for bioinformatics annotation work.",
        "version": "0.1",
        "x-build-id": "S1mj0yKgelktwUfjR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~interpro-protein-families-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-interpro-protein-families-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~interpro-protein-families-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-interpro-protein-families-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~interpro-protein-families-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-interpro-protein-families-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": {
                    "accessions": {
                        "title": "InterPro accessions",
                        "type": "array",
                        "description": "Optional list of specific InterPro accessions to fetch, for example 'IPR000001' or 'IPR000003'. When this list is non-empty the Actor fetches exactly these entries and ignores the type filter. Leave empty to browse all entries instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "type": {
                        "title": "Entry type filter",
                        "enum": [
                            "",
                            "family",
                            "domain",
                            "homologous_superfamily",
                            "repeat",
                            "conserved_site",
                            "active_site",
                            "binding_site",
                            "ptm"
                        ],
                        "type": "string",
                        "description": "Only used when no accessions are provided. Restricts the browse to a single InterPro entry type. Choose 'Any type' to include every entry.",
                        "default": ""
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
