# EBI Ontology Lookup (OLS) Scraper (`crawlerbros/ebi-ontology-scraper`) Actor

Scrape the EMBL-EBI Ontology Lookup Service (OLS4) - 280+ biomedical and scientific ontologies. List ontologies, browse terms, or search across concepts by keyword. Returns labels, definitions, IRIs, synonyms and identifiers as clean JSON.

- **URL**: https://apify.com/crawlerbros/ebi-ontology-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## EBI Ontology Lookup (OLS) Scraper

Extract biomedical and scientific **ontologies and terms** from the **[EMBL-EBI Ontology Lookup Service (OLS4)](https://www.ebi.ac.uk/ols4/)** as clean JSON. OLS aggregates **280+ ontologies** — GO, EFO, MONDO, HP, CHEBI, UBERON, NCIT and many more — into one searchable index. No account, no API key, no login.

Ideal for bioinformatics pipelines, knowledge graphs, data annotation, term normalization, medical NLP dictionaries, and research tooling that needs authoritative controlled-vocabulary data.

### What this actor does

- **List ontologies** — get metadata for every ontology hosted on OLS (title, description, term counts, homepage, version).
- **Browse terms** — page through all terms of a chosen ontology, optionally skipping obsolete ones.
- **Search terms** — full-text search concepts across all ontologies (or a chosen subset) by keyword.
- Every record comes with a live `sourceUrl` linking straight to the OLS4 page for that ontology or term.
- Empty fields are always omitted — you never get `null`s.

### Modes

| Mode | What it returns | Required input |
|---|---|---|
| `listOntologies` | Metadata for all 280+ ontologies | — |
| `ontologyTerms` | Terms belonging to one ontology | `ontologyId` (e.g. `efo`) |
| `searchTerms` | Concepts matching a keyword across ontologies | `query` (e.g. `diabetes`) |

### Output

Every record carries `recordType`, `sourceUrl`, and `scrapedAt` (UTC).

**Ontology records** (`mode=listOntologies`):
`ontologyId`, `title`, `description`, `namespace`, `preferredPrefix`, `homepage`, `version`, `versionIri`, `status`, `numberOfTerms`, `numberOfProperties`, `numberOfIndividuals`, `baseUris`, `languages`, `mailingList`, `tracker`, `loaded`, `updated`.

**Term records** (`mode=ontologyTerms`):
`iri`, `label`, `description`, `ontologyName`, `ontologyPrefix`, `ontologyIri`, `shortForm`, `oboId`, `isObsolete`, `hasChildren`, `isRoot`, `isDefiningOntology`, `synonyms`, `subsets`, `crossReferences` (each `{database, id, url, description}`).

**Search records** (`mode=searchTerms`):
`iri`, `label`, `description`, `ontologyName`, `ontologyPrefix`, `ontologyIri`, `shortForm`, `oboId`, `entityType`, `isDefiningOntology`, `synonyms`, `exactSynonyms`, `relatedSynonyms`, `subsets`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `listOntologies` | `listOntologies`, `ontologyTerms`, or `searchTerms`. |
| `query` | string | `diabetes` | Keyword for `searchTerms` (e.g. `diabetes`, `apoptosis`). |
| `ontologyId` | string | – | Ontology short ID for `ontologyTerms` (e.g. `efo`, `go`, `hp`, `mondo`, `chebi`, `uberon`, `ncit`). |
| `ontologies` | string | – | Optional comma-separated ontology IDs to restrict `searchTerms` (e.g. `efo,mondo,hp`). |
| `entityType` | select | – | Optional `searchTerms` filter: class, property, or individual. |
| `exactMatch` | boolean | `false` | `searchTerms` — only return exact label/synonym matches. |
| `includeObsoleteInSearch` | boolean | `false` | `searchTerms` — set true to return obsolete/deprecated concepts (hidden by default). |
| `localOnly` | boolean | `false` | `searchTerms` — set true to return only hits from the ontology that natively defines each concept. |
| `includeObsolete` | boolean | `true` | `ontologyTerms` — set false to skip obsolete terms. |
| `maxItems` | integer | `25` | Hard cap on emitted records (1–250000). |

#### Example: search disease concepts across all ontologies

```json
{
  "mode": "searchTerms",
  "query": "diabetes",
  "maxItems": 100
}
````

#### Example: search restricted to specific ontologies

```json
{
  "mode": "searchTerms",
  "query": "diabetes",
  "ontologies": "efo,mondo,hp",
  "entityType": "class",
  "maxItems": 100
}
```

#### Example: browse all non-obsolete terms of an ontology

```json
{
  "mode": "ontologyTerms",
  "ontologyId": "hp",
  "includeObsolete": false,
  "maxItems": 500
}
```

#### Example: catalogue every ontology on OLS

```json
{
  "mode": "listOntologies",
  "maxItems": 300
}
```

#### Example output (search term)

```json
{
  "recordType": "term",
  "iri": "http://purl.obolibrary.org/obo/HP_0005978",
  "label": "Type II diabetes mellitus",
  "description": "A type of diabetes mellitus characterized by insulin resistance…",
  "ontologyName": "hp",
  "ontologyPrefix": "HP",
  "shortForm": "HP_0005978",
  "oboId": "HP:0005978",
  "entityType": "class",
  "isDefiningOntology": true,
  "synonyms": ["Type 2 diabetes", "NIDDM", "Diabetes mellitus type 2"],
  "exactSynonyms": ["Type 2 diabetes", "NIDDM"],
  "sourceUrl": "https://www.ebi.ac.uk/ols4/ontologies/hp/classes/http%253A%252F%252Fpurl.obolibrary.org%252Fobo%252FHP_0005978",
  "scrapedAt": "2026-07-02T13:30:24.344658+00:00"
}
```

### Use cases

- **Data annotation** — normalize free-text disease/phenotype/anatomy labels to canonical ontology IRIs.
- **Knowledge graphs** — ingest ontology terms, synonyms, and identifiers as graph nodes.
- **Medical NLP** — build dictionaries and gazetteers from HP, MONDO, DOID and other clinical vocabularies.
- **Bioinformatics pipelines** — resolve `oboId` accessions (e.g. `GO:0008150`) to labels and definitions.
- **Ontology discovery** — catalogue every ontology on OLS with term counts and versions for research.
- **Term normalization** — map synonyms to preferred labels across a chosen subset of ontologies.

### FAQ

**Do I need an account or API key?**
No. OLS is a free, public service from EMBL-EBI. The actor works out of the box.

**Which ontologies are available?**
All 280+ hosted on OLS — including GO (Gene Ontology), EFO, MONDO, HP (Human Phenotype), CHEBI, UBERON, NCIT, DOID and many more. Run `listOntologies` to get the full list with IDs.

**How do I get every term in an ontology?**
Use `ontologyTerms` with the `ontologyId` and raise `maxItems`. Large ontologies (e.g. EFO has 90k+ terms) can be capped with `maxItems` and paged in batches.

**What is the `oboId` vs `iri`?**
`iri` is the full canonical concept URI. `oboId` (e.g. `HP:0005978`) is the compact OBO-style accession commonly used in datasets and papers.

**Can I limit a search to specific ontologies?**
Yes — set `ontologies` to a comma-separated list (e.g. `efo,mondo`).

**Are obsolete terms included?**
By default `searchTerms` excludes obsolete concepts; enable `includeObsoleteInSearch` to retrieve the deprecated ones. In `ontologyTerms`, set `includeObsolete` to false to skip obsolete terms.

### Data source

This actor uses the public EMBL-EBI Ontology Lookup Service API at `https://www.ebi.ac.uk/ols4/api`. Ontology content is provided by EMBL-EBI and the individual ontology maintainers under their respective open licenses.

# Actor input Schema

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

What to fetch.

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

Keyword to search concepts by, e.g. `diabetes`, `apoptosis`, `heart`.

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

The ontology short ID whose terms to browse, e.g. `efo`, `go`, `hp`, `mondo`, `chebi`, `uberon`, `ncit`.

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

Optional comma-separated ontology IDs to restrict the search to, e.g. `efo,mondo,hp`. Leave empty to search all.

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

Optional filter for the kind of entity returned by search.

## `exactMatch` (type: `boolean`):

When enabled, only return concepts whose label or synonym exactly matches the query.

## `includeObsoleteInSearch` (type: `boolean`):

When enabled, the search returns obsolete/deprecated concepts, which are hidden by default.

## `localOnly` (type: `boolean`):

When enabled, only return hits from the ontology that natively defines each concept (excludes cross-imported copies).

## `includeObsolete` (type: `boolean`):

When disabled, terms flagged obsolete by the ontology are skipped.

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

Hard cap on emitted records. The scraper paginates until it reaches this many records or the ontology/result set is exhausted.

## Actor input object example

```json
{
  "mode": "listOntologies",
  "query": "diabetes",
  "entityType": "",
  "exactMatch": false,
  "includeObsoleteInSearch": false,
  "localOnly": false,
  "includeObsolete": true,
  "maxItems": 25
}
```

# Actor output Schema

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

Dataset containing all scraped OLS ontology and term records.

# 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 = {
    "mode": "listOntologies",
    "query": "diabetes",
    "exactMatch": false,
    "includeObsolete": true,
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/ebi-ontology-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 = {
    "mode": "listOntologies",
    "query": "diabetes",
    "exactMatch": False,
    "includeObsolete": True,
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/ebi-ontology-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 '{
  "mode": "listOntologies",
  "query": "diabetes",
  "exactMatch": false,
  "includeObsolete": true,
  "maxItems": 25
}' |
apify call crawlerbros/ebi-ontology-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "EBI Ontology Lookup (OLS) Scraper",
        "description": "Scrape the EMBL-EBI Ontology Lookup Service (OLS4) - 280+ biomedical and scientific ontologies. List ontologies, browse terms, or search across concepts by keyword. Returns labels, definitions, IRIs, synonyms and identifiers as clean JSON.",
        "version": "1.0",
        "x-build-id": "nvfxRFM1BinjdmpYQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~ebi-ontology-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-ebi-ontology-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/crawlerbros~ebi-ontology-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-ebi-ontology-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/crawlerbros~ebi-ontology-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-ebi-ontology-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "listOntologies",
                            "ontologyTerms",
                            "searchTerms"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "listOntologies"
                    },
                    "query": {
                        "title": "Search query (mode=searchTerms)",
                        "type": "string",
                        "description": "Keyword to search concepts by, e.g. `diabetes`, `apoptosis`, `heart`.",
                        "default": "diabetes"
                    },
                    "ontologyId": {
                        "title": "Ontology ID (mode=ontologyTerms)",
                        "type": "string",
                        "description": "The ontology short ID whose terms to browse, e.g. `efo`, `go`, `hp`, `mondo`, `chebi`, `uberon`, `ncit`."
                    },
                    "ontologies": {
                        "title": "Restrict to ontologies (mode=searchTerms)",
                        "type": "string",
                        "description": "Optional comma-separated ontology IDs to restrict the search to, e.g. `efo,mondo,hp`. Leave empty to search all."
                    },
                    "entityType": {
                        "title": "Entity type (mode=searchTerms)",
                        "enum": [
                            "",
                            "class",
                            "property",
                            "individual"
                        ],
                        "type": "string",
                        "description": "Optional filter for the kind of entity returned by search.",
                        "default": ""
                    },
                    "exactMatch": {
                        "title": "Exact match only (mode=searchTerms)",
                        "type": "boolean",
                        "description": "When enabled, only return concepts whose label or synonym exactly matches the query.",
                        "default": false
                    },
                    "includeObsoleteInSearch": {
                        "title": "Include obsolete terms in search (mode=searchTerms)",
                        "type": "boolean",
                        "description": "When enabled, the search returns obsolete/deprecated concepts, which are hidden by default.",
                        "default": false
                    },
                    "localOnly": {
                        "title": "Defining ontology only (mode=searchTerms)",
                        "type": "boolean",
                        "description": "When enabled, only return hits from the ontology that natively defines each concept (excludes cross-imported copies).",
                        "default": false
                    },
                    "includeObsolete": {
                        "title": "Include obsolete terms (mode=ontologyTerms)",
                        "type": "boolean",
                        "description": "When disabled, terms flagged obsolete by the ontology are skipped.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 250000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. The scraper paginates until it reaches this many records or the ontology/result set is exhausted.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```