# Ofsted School Register Scraper (`automation-lab/ofsted-school-register-scraper`) Actor

Extract official GOV.UK/Ofsted school register, provider details and inspection outcome CSV data with useful filters for education workflows.

- **URL**: https://apify.com/automation-lab/ofsted-school-register-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Ofsted School Register Scraper

Extract official GOV.UK and Ofsted state-funded school register data, provider details, and inspection outcome fields into a clean Apify dataset.

The actor is built for public education data workflows where teams need more than a PDF or spreadsheet download. It discovers the latest official GOV.UK CSV, parses the school/provider rows, applies useful filters, and returns records with stable field names.

### What does Ofsted School Register Scraper do?

Ofsted School Register Scraper downloads the official public state-funded schools inspections and outcomes dataset published on GOV.UK.

It returns structured rows for schools and providers, including identifiers, region, local authority, school type, phase, postcode, inspection dates, OEIF grades, ungraded inspection outcomes, safeguarding, trust details, sponsor details, and source metadata.

### Who is it for?

- Education suppliers building school lead lists
- Local authority analysts monitoring Ofsted outcomes
- Compliance teams checking provider status
- Recruiters targeting schools by phase or region
- Market researchers mapping education providers
- Data teams enriching CRMs with URN and inspection fields

### Why use this actor?

The GOV.UK CSV is large and changes over time. This actor makes the workflow repeatable.

- Use the latest official file automatically
- Or provide a direct historic CSV URL
- Filter before exporting
- Keep source dataset metadata on every row
- Export to JSON, CSV, Excel, or API

### Data source

Default source:

https://www.gov.uk/government/collections/maintained-schools-and-academies-inspections-and-outcomes-official-statistics

The actor follows GOV.UK pages and selects the main official CSV asset for state-funded schools inspections and outcomes.

### Data fields

| Field | Description |
| --- | --- |
| `urn` | Official unique reference number |
| `laestab` | Local authority establishment identifier |
| `schoolName` | Published school/provider name |
| `providerUrl` | Official Ofsted provider/report URL |
| `ofstedPhase` | Phase such as Primary, Secondary, Nursery, Special |
| `educationType` | Type of education/provider |
| `localAuthority` | Local authority name |
| `region` | Government region |
| `ofstedRegion` | Ofsted region |
| `postcode` | Published postcode |
| `multiAcademyTrustName` | MAT name when available |
| `academySponsorName` | Sponsor name when available |
| `totalPupils` | Total pupils from the source file |
| `latestOeifOverallEffectivenessText` | Outstanding, Good, Requires improvement, Inadequate, or Not applicable |
| `latestOeifInspectionPublicationDate` | Publication date for latest OEIF inspection |
| `ungradedInspectionOverallOutcome` | Published ungraded inspection outcome |
| `mostRecentCategoryOfConcern` | Most recent concern flag |
| `sourceDatasetUrl` | CSV asset used |
| `scrapedAt` | Actor run timestamp |

### How much does it cost to extract Ofsted school register data?

The actor uses pay-per-event pricing:

- Start fee: $0.005 per run
- School record event: formula-derived tiered pricing starting at $0.000020902 per record on Bronze

A 20-record default run is designed to be cheap for first-time testing. Larger exports are priced per saved record.

### Input

You can leave the default input as-is to fetch the latest official dataset.

```json
{
  "maxRecords": 20
}
````

### Input options

- `startUrls` - optional GOV.UK collection/statistics pages or direct CSV URLs
- `maxRecords` - maximum records to save
- `ofstedRegions` - exact Ofsted region filters
- `regions` - exact government region filters
- `localAuthorities` - exact local authority filters
- `phases` - exact Ofsted phase filters
- `educationTypes` - exact provider type filters
- `overallEffectivenessGrades` - grades `1`, `2`, `3`, or `4`
- `onlyConcerns` - include only category-of-concern rows
- `includeRawRecord` - attach the full original CSV row

### Output example

```json
{
  "urn": "100000",
  "schoolName": "The Aldgate School",
  "ofstedPhase": "Primary",
  "educationType": "Voluntary Aided School",
  "localAuthority": "City of London",
  "region": "London",
  "postcode": "EC3A 5DE",
  "latestOeifOverallEffectiveness": "1",
  "latestOeifOverallEffectivenessText": "Outstanding",
  "providerUrl": "http://www.ofsted.gov.uk/inspection-reports/find-inspection-report/provider/ELS/100000"
}
```

### How to run

1. Open the actor on Apify.
2. Keep the default source or add your own GOV.UK CSV URL.
3. Set `maxRecords`.
4. Add filters if needed.
5. Start the run.
6. Export the dataset.

### Filtering examples

#### London primary schools

```json
{
  "maxRecords": 500,
  "regions": ["London"],
  "phases": ["Primary"]
}
```

#### Camden nursery providers

```json
{
  "maxRecords": 100,
  "localAuthorities": ["Camden"],
  "phases": ["Nursery"]
}
```

#### Schools with low Ofsted grades

```json
{
  "maxRecords": 1000,
  "overallEffectivenessGrades": ["3", "4"]
}
```

### Tips

- Use exact published values for filters.
- Start with a small `maxRecords` value when testing.
- Use direct CSV URLs when you need a reproducible historic snapshot.
- Turn on `includeRawRecord` only when you need audit-level detail.

### Integrations

Use the results in:

- CRM enrichment workflows
- Local authority dashboards
- Supplier lead generation pipelines
- Education compliance monitoring
- BI tools such as Looker, Power BI, or Tableau
- Google Sheets or Airtable via Apify integrations

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/ofsted-school-register-scraper').call({
  maxRecords: 100,
  regions: ['London']
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/ofsted-school-register-scraper').call(run_input={
    'maxRecords': 100,
    'regions': ['London'],
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~ofsted-school-register-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"maxRecords":100,"regions":["London"]}'
```

### MCP usage

Use Apify MCP with:

https://mcp.apify.com/?tools=automation-lab/ofsted-school-register-scraper

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/ofsted-school-register-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-ofsted-school-register": {
      "url": "https://mcp.apify.com/?tools=automation-lab/ofsted-school-register-scraper"
    }
  }
}
```

Example prompts:

- "Extract 200 Ofsted school records for London primary schools."
- "Find schools in Camden with the latest overall effectiveness grade 1 or 2."
- "Create a CSV of schools with category-of-concern fields."

### Legality

This actor reads public GOV.UK and Ofsted data. You are responsible for using the output lawfully, respecting applicable public-sector data terms, privacy rules, and your own compliance requirements.

### FAQ

#### Does it require login?

No. The default workflow uses public GOV.UK pages and public CSV downloads.

#### Does it scrape individual PDF reports?

No. The MVP focuses on the official register/outcomes CSV and provider URLs. PDF parsing can be added later if users need report text.

#### Why did my filter return no rows?

Filters are exact matches against GOV.UK CSV values. Try a run without filters, inspect values, then copy the exact value into your input.

#### Can I use historic datasets?

Yes. Provide a direct GOV.UK CSV asset URL in `startUrls`.

### Related scrapers

- https://apify.com/automation-lab/uk-ofsted-inspections-scraper
- https://apify.com/automation-lab/uk-companies-house-scraper
- https://apify.com/automation-lab/uk-charity-commission-scraper

### Changelog

#### 0.1

- Initial release with latest GOV.UK CSV discovery
- Direct CSV input support
- Region, authority, phase, type, grade, and concern filters
- Structured Ofsted school/provider output

### Support

If a GOV.UK dataset changes shape, open an Apify issue with the source URL and example input so we can update the mapping.

# Actor input Schema

## `startUrls` (type: `array`):

Optional GOV.UK collection/statistics pages or direct CSV asset URLs. Leave empty to use the latest official state-funded schools inspections and outcomes collection.

## `maxRecords` (type: `integer`):

Maximum matching school/provider records to save.

## `ofstedRegions` (type: `array`):

Optional exact Ofsted region filters, for example London or North West.

## `regions` (type: `array`):

Optional exact government region filters, for example London or South East.

## `localAuthorities` (type: `array`):

Optional exact local authority filters, for example Camden, Birmingham, or Manchester.

## `phases` (type: `array`):

Optional exact phase filters such as Primary, Secondary, Nursery, Special, or Alternative provision.

## `educationTypes` (type: `array`):

Optional exact type filters such as Academy converter, Community school, Voluntary aided school, or Pupil referral unit.

## `overallEffectivenessGrades` (type: `array`):

Optional latest OEIF overall effectiveness grade filters. Use 1=Outstanding, 2=Good, 3=Requires improvement, 4=Inadequate.

## `onlyConcerns` (type: `boolean`):

Return only records with a category of concern value.

## `includeRawRecord` (type: `boolean`):

Attach the full original CSV row as rawRecord for audits and custom mapping.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.gov.uk/government/collections/maintained-schools-and-academies-inspections-and-outcomes-official-statistics"
    }
  ],
  "maxRecords": 20,
  "ofstedRegions": [],
  "regions": [],
  "localAuthorities": [],
  "phases": [],
  "educationTypes": [],
  "overallEffectivenessGrades": [],
  "onlyConcerns": false,
  "includeRawRecord": false
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.gov.uk/government/collections/maintained-schools-and-academies-inspections-and-outcomes-official-statistics"
        }
    ],
    "maxRecords": 20,
    "ofstedRegions": [],
    "regions": [],
    "localAuthorities": [],
    "phases": [],
    "educationTypes": [],
    "overallEffectivenessGrades": [],
    "onlyConcerns": false,
    "includeRawRecord": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/ofsted-school-register-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 = {
    "startUrls": [{ "url": "https://www.gov.uk/government/collections/maintained-schools-and-academies-inspections-and-outcomes-official-statistics" }],
    "maxRecords": 20,
    "ofstedRegions": [],
    "regions": [],
    "localAuthorities": [],
    "phases": [],
    "educationTypes": [],
    "overallEffectivenessGrades": [],
    "onlyConcerns": False,
    "includeRawRecord": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/ofsted-school-register-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 '{
  "startUrls": [
    {
      "url": "https://www.gov.uk/government/collections/maintained-schools-and-academies-inspections-and-outcomes-official-statistics"
    }
  ],
  "maxRecords": 20,
  "ofstedRegions": [],
  "regions": [],
  "localAuthorities": [],
  "phases": [],
  "educationTypes": [],
  "overallEffectivenessGrades": [],
  "onlyConcerns": false,
  "includeRawRecord": false
}' |
apify call automation-lab/ofsted-school-register-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Ofsted School Register Scraper",
        "description": "Extract official GOV.UK/Ofsted school register, provider details and inspection outcome CSV data with useful filters for education workflows.",
        "version": "0.1",
        "x-build-id": "w6D5xyYXFdbWxYduz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~ofsted-school-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-ofsted-school-register-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~ofsted-school-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-ofsted-school-register-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~ofsted-school-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-ofsted-school-register-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": {
                    "startUrls": {
                        "title": "GOV.UK pages or CSV URLs",
                        "type": "array",
                        "description": "Optional GOV.UK collection/statistics pages or direct CSV asset URLs. Leave empty to use the latest official state-funded schools inspections and outcomes collection.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRecords": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum matching school/provider records to save.",
                        "default": 20
                    },
                    "ofstedRegions": {
                        "title": "Ofsted regions",
                        "type": "array",
                        "description": "Optional exact Ofsted region filters, for example London or North West.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Government regions",
                        "type": "array",
                        "description": "Optional exact government region filters, for example London or South East.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "localAuthorities": {
                        "title": "Local authorities",
                        "type": "array",
                        "description": "Optional exact local authority filters, for example Camden, Birmingham, or Manchester.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "phases": {
                        "title": "Ofsted phases",
                        "type": "array",
                        "description": "Optional exact phase filters such as Primary, Secondary, Nursery, Special, or Alternative provision.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "educationTypes": {
                        "title": "Education types",
                        "type": "array",
                        "description": "Optional exact type filters such as Academy converter, Community school, Voluntary aided school, or Pupil referral unit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "overallEffectivenessGrades": {
                        "title": "Overall effectiveness grades",
                        "type": "array",
                        "description": "Optional latest OEIF overall effectiveness grade filters. Use 1=Outstanding, 2=Good, 3=Requires improvement, 4=Inadequate.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyConcerns": {
                        "title": "Only category-of-concern schools",
                        "type": "boolean",
                        "description": "Return only records with a category of concern value.",
                        "default": false
                    },
                    "includeRawRecord": {
                        "title": "Include raw CSV record",
                        "type": "boolean",
                        "description": "Attach the full original CSV row as rawRecord for audits and custom mapping.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
