# The Numbers Box Office Scraper (`crawlerbros/the-numbers-box-office-scraper`) Actor

Scrape The Numbers (the-numbers.com) box-office data - weekend, daily, and weekly charts, yearly top-grossing rankings, and per-movie financials (production budget, domestic/international/worldwide gross, opening weekend).

- **URL**: https://apify.com/crawlerbros/the-numbers-box-office-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

## The Numbers Box Office Scraper

Scrape [The Numbers](https://www.the-numbers.com) — one of the web's most detailed free sources of movie box-office and financial data. Get weekend, daily, and weekly box-office charts, yearly top-grossing rankings, and per-movie financials (production budget, domestic/international/worldwide gross, opening weekend, theater counts, MPA rating, and more) by title. HTTP-only, no login, no paywall.

### What this actor does

- **Six modes:** `weekend`, `daily`, `weekly` box-office charts, `yearly` top-grossing rankings, `byTitle` movie financial lookup, and `releaseSchedule` upcoming/just-released movie schedule
- **Full financial profile per movie:** production budget, domestic/international/worldwide box office, opening weekend gross & share, "legs" multiplier, inflation-adjusted domestic gross, theater counts, MPA rating, running time, genre, distributor, release date
- **Filters:** minimum gross, distributor (yearly / releaseSchedule modes), genre (yearly mode)
- **Empty fields are omitted** — a field only appears when The Numbers actually publishes that data point for the movie

### Output per record

#### Box-office chart entry (`weekend` / `daily` / `weekly`)

- `rank`, `previousRank`, `isNewEntry`
- `title`, `detailUrl`
- `gross`, `isEstimate`, `totalGross`
- `dailyChangePercent`, `weeklyChangePercent`
- `theaterCount`, `theaterAverage`, `daysInRelease`
- `chartType`, `chartDate`
- `recordType: "boxOfficeChartEntry"`, `scrapedAt`

#### Yearly top-grossing entry (`yearly`)

- `rank`, `title`, `detailUrl`, `year`
- `releaseDate`, `distributor`, `genre`
- `grossForYear`, `ticketsSold`
- `recordType: "yearlyBoxOfficeEntry"`, `scrapedAt`

#### Movie financials (`byTitle`)

- `title`, `year`, `posterUrl`, `leadCast`, `director`
- `domesticBoxOffice`, `internationalBoxOffice`, `worldwideBoxOffice`, `inflationAdjustedDomesticBoxOffice`
- `openingWeekendGross`, `openingWeekendPercent`, `legs`, `domesticSharePercent`
- `productionBudget`
- `openingTheaters`, `maxTheaters`, `avgWeeksPerTheater`
- `domesticReleaseDate`, `distributor`, `mpaRating`, `runningTimeMinutes`
- `genre`, `subgenre`, `franchise`, `source`, `productionMethod`, `creativeType`
- `productionCompanies`, `productionCountries`, `languages`
- `sourceUrl`, `recordType: "movieFinancials"`, `scrapedAt`

#### Release schedule entry (`releaseSchedule`)

- `title`, `detailUrl`
- `releaseDate` — `YYYY-MM-DD`
- `releaseType` — e.g. `Wide`, `Limited`, `Expands Wide`, `IMAX`, `Special Engagement`, `Wide, re-release`, `Canceled`
- `distributor`
- `domesticBoxOfficeToDate` — populated only once the movie has opened and started earning
- `recordType: "releaseScheduleEntry"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `weekend` | `weekend` / `daily` / `weekly` / `yearly` / `byTitle` / `releaseSchedule` |
| `chartDate` | string | – | `YYYY-MM-DD`. Weekend/weekly snap to the nearest Friday on/before this date. Blank = most recent chart. |
| `year` | int | `2026` | Calendar year for `yearly` mode (1980–current year) |
| `movieTitle` | string | `Avatar` | Title to search for (`byTitle` mode) |
| `minGross` | int | – | Drop entries below this gross |
| `distributor` | string | – | Substring filter on distributor (`yearly` / `releaseSchedule` modes) |
| `genre` | string | – | Substring filter on genre (`yearly` mode) |
| `maxItems` | int | `20` | Hard cap on emitted records (1–200) |
| `proxyConfiguration` | object | AUTO | Not required for reliable access; kept as a resilience fallback |

#### Example: this weekend's box office

```json
{ "mode": "weekend", "maxItems": 20 }
````

#### Example: daily chart for a specific date

```json
{ "mode": "daily", "chartDate": "2026-07-04", "maxItems": 20 }
```

#### Example: 2025's top-grossing movies from Walt Disney

```json
{ "mode": "yearly", "year": 2025, "distributor": "Walt Disney", "maxItems": 50 }
```

#### Example: movie financials by title

```json
{ "mode": "byTitle", "movieTitle": "Toy Story", "maxItems": 10 }
```

#### Example: upcoming Walt Disney releases

```json
{ "mode": "releaseSchedule", "distributor": "Walt Disney", "maxItems": 50 }
```

### Use cases

- **Box-office trackers** — pull the current weekend/daily chart into a dashboard
- **Film industry research** — build datasets of budgets vs. gross by year/distributor
- **Investment & greenlight analysis** — compare production budget to worldwide gross ("legs", ROI multiples)
- **Media & journalism** — source up-to-date box-office figures for reporting
- **Academic research** — study box-office trends by genre, studio, or release year

### FAQ

**What's The Numbers?** A free, publicly accessible movie-industry data site tracking box office, budgets, and release schedules since the late 1990s.

**How far back does the data go?** Daily/weekend/weekly charts are reliably available from 1998 onward; yearly top-grossing charts from 1980 onward. Older dates return an empty result with a status message rather than an error.

**Why do some movies lack `productionBudget`?** Budgets are self-reported/estimated by the industry and not disclosed for every film (especially independent or foreign releases). The field is simply omitted rather than emitted as null or a placeholder.

**What does `isNewEntry` mean?** `true` when the chart shows `(new)` in the "Prev" column — the movie has no prior-week ranking. `previousRank` is omitted in that case (there is no previous rank to report).

**What does `legs` mean?** The Numbers' "legs" metric = domestic box office ÷ biggest single weekend. Higher values indicate a film held well over its run rather than front-loading its gross.

**Does `byTitle` return multiple movies for the same title?** Yes — franchises and remakes share titles (e.g. "Toy Story" has five entries). The actor returns every distinct match up to `maxItems`; check the `year` field to disambiguate.

**Is a proxy required?** No. The Numbers serves all covered pages to Apify's datacenter IPs without blocking. `proxyConfiguration` is exposed only as a resilience fallback (Apify's free AUTO group).

**What does `releaseSchedule` mode return?** The Numbers' full upcoming-release calendar — every movie with a confirmed or announced release date, starting from today, plus already-open movies whose domestic box-office-to-date is still being tracked. `domesticBoxOfficeToDate` is omitted until the movie has actually opened.

**Does this cover everything on The Numbers?** This actor covers every reliable, free chart/lookup axis The Numbers exposes: daily/weekend/weekly box-office charts, yearly top-grossing rankings, per-title financial lookup, and the release schedule. A few additional axes visible in the site's navigation are intentionally out of scope: per-distributor lifetime totals (`/market/distributor/<name>` returns HTTP 404 for the slugs tested — not a reliably available public page), and "Bankability" talent-value reports and The Numbers Business Report, which are subscriber-only features behind a paywall.

# Actor input Schema

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

What to fetch from The Numbers.

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

Date in YYYY-MM-DD format. Weekend/weekly charts snap to the nearest Friday on or before this date. Leave blank to use the most recent available chart. Charts are available from 1998 onward.

## `year` (type: `integer`):

Calendar year for the top-grossing-movies chart. Data available from 1980 through the current year.

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

Movie title to search for. Returns full financial details (budget, domestic/international/worldwide gross, opening weekend, etc.) for every matching movie.

## `minGross` (type: `integer`):

Drop chart/yearly entries below this gross (weekend/daily/weekly: period gross; yearly: gross for the year).

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

Only keep entries whose distributor contains this text, e.g. `Walt Disney`, `Universal`, `Warner Bros`.

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

Only keep yearly entries whose genre contains this text, e.g. `Action`, `Comedy`, `Drama`, `Horror`, `Documentary`.

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

Hard cap on emitted records.

## `proxyConfiguration` (type: `object`):

The Numbers' chart and movie pages work without any proxy from datacenter IPs. Leave AUTO on for resilience; no paid proxy group is required.

## Actor input object example

```json
{
  "mode": "weekend",
  "year": 2026,
  "movieTitle": "Avatar",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing all scraped box-office chart entries, yearly rankings, and movie financial 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": "weekend",
    "year": 2026,
    "movieTitle": "Avatar",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/the-numbers-box-office-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": "weekend",
    "year": 2026,
    "movieTitle": "Avatar",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/the-numbers-box-office-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": "weekend",
  "year": 2026,
  "movieTitle": "Avatar",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/the-numbers-box-office-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Numbers Box Office Scraper",
        "description": "Scrape The Numbers (the-numbers.com) box-office data - weekend, daily, and weekly charts, yearly top-grossing rankings, and per-movie financials (production budget, domestic/international/worldwide gross, opening weekend).",
        "version": "1.0",
        "x-build-id": "LRgMD58oemMThJxQR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~the-numbers-box-office-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-the-numbers-box-office-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~the-numbers-box-office-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-the-numbers-box-office-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~the-numbers-box-office-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-the-numbers-box-office-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": [
                            "weekend",
                            "daily",
                            "weekly",
                            "yearly",
                            "byTitle",
                            "releaseSchedule"
                        ],
                        "type": "string",
                        "description": "What to fetch from The Numbers.",
                        "default": "weekend"
                    },
                    "chartDate": {
                        "title": "Chart date (weekend / daily / weekly modes)",
                        "type": "string",
                        "description": "Date in YYYY-MM-DD format. Weekend/weekly charts snap to the nearest Friday on or before this date. Leave blank to use the most recent available chart. Charts are available from 1998 onward."
                    },
                    "year": {
                        "title": "Year (yearly mode)",
                        "minimum": 1980,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Calendar year for the top-grossing-movies chart. Data available from 1980 through the current year.",
                        "default": 2026
                    },
                    "movieTitle": {
                        "title": "Movie title (byTitle mode)",
                        "type": "string",
                        "description": "Movie title to search for. Returns full financial details (budget, domestic/international/worldwide gross, opening weekend, etc.) for every matching movie."
                    },
                    "minGross": {
                        "title": "Minimum gross (USD)",
                        "minimum": 0,
                        "maximum": 10000000000,
                        "type": "integer",
                        "description": "Drop chart/yearly entries below this gross (weekend/daily/weekly: period gross; yearly: gross for the year)."
                    },
                    "distributor": {
                        "title": "Distributor filter (yearly / releaseSchedule modes)",
                        "type": "string",
                        "description": "Only keep entries whose distributor contains this text, e.g. `Walt Disney`, `Universal`, `Warner Bros`."
                    },
                    "genre": {
                        "title": "Genre filter (yearly mode)",
                        "type": "string",
                        "description": "Only keep yearly entries whose genre contains this text, e.g. `Action`, `Comedy`, `Drama`, `Horror`, `Documentary`."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "The Numbers' chart and movie pages work without any proxy from datacenter IPs. Leave AUTO on for resilience; no paid proxy group is required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
