# Common Crawl Scraper (Archived HTML Finder) (`igolaizola/commoncrawl-scraper`) Actor

Find URLs across historical commoncrawl.org indexes and download archived HTML. Search the 10 newest or oldest snapshots, choose a crawl year, or provide up to 10 exact indexes for SEO audits, page recovery, content research, and historical web datasets.

- **URL**: https://apify.com/igolaizola/commoncrawl-scraper.md
- **Developed by:** [Iñigo Garcia Olaizola](https://apify.com/igolaizola) (community)
- **Categories:** SEO tools, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Common Crawl Scraper — Archived HTML, URL Lookup & Historical Pages

Find URLs across the **Common Crawl** archive at **commoncrawl.org** and download HTML from historical web pages. Use the results for page recovery, SEO audits, website research, content comparison, and archive-based datasets.

### 🤖 What does Common Crawl Scraper do?

Common Crawl Scraper checks whether URLs appear in Common Crawl and returns the first matching archived snapshot from the indexes you choose to search as HTML, Markdown, plain text, or any combination.

- **Find archived URLs** — confirm whether a domain or page was captured
- **Download historical HTML** — recover page content from a matching crawl
- **Choose your output** — return HTML, Markdown, plain text, or multiple formats
- **Choose the search period** — start with the newest or oldest available indexes
- **Choose a crawl year** — search every available index from a specific year
- **Target exact crawls** — provide specific index IDs in your preferred order

**Great for:** SEO audits, expired-page recovery, competitor research, website history analysis, content archiving, and training-data collection.

> SEO keywords: **Common Crawl scraper**, **commoncrawl.org scraper**, **Common Crawl HTML extractor**, **download archived HTML**, **historical webpage scraper**, **Common Crawl API alternative**, **Apify actor**.

### 💡 Why use Common Crawl?

- 📚 **Recover missing content** — retrieve archived HTML after a live page changes or disappears
- 🔎 **Research website history** — inspect earlier landing pages, articles, and product pages
- 📈 **Support SEO analysis** — investigate historical content, redirects, and page availability
- 🧠 **Build research datasets** — collect archived source material for analysis or machine learning
- 🗓️ **Focus on a time period** — search recent crawls, early crawls, or selected index IDs

### 🧠 Choose how indexes are searched

The Actor supports two index-selection modes:

#### Automatic discovery

Leave `indexes` empty and the Actor discovers the available Common Crawl indexes. Without `year`, it checks 10 indexes from the end selected by `indexOrder`: the 10 newest or the 10 oldest. Set `year` to check every available index from that year. The search stops at the first matching HTML snapshot.

#### Explicit indexes

Provide `indexes` when you already know which crawls matter. The Actor checks up to the first 10 unique IDs in the exact order supplied and ignores `year` and `indexOrder`.

### 🚀 How to use

1. **Add the Actor** – Open **Common Crawl Scraper** in Apify Store.
2. **Add URLs** – Enter full URLs or host-and-path values in `urls`.
3. **Choose the index strategy** – Keep the default 10 newest indexes, select the 10 oldest, set `year` for every index from one year, or provide exact `indexes`.
4. **Run the Actor** – Click **Run** in Apify Console or trigger it through the API.
5. **Choose output formats** – Keep HTML, or select Markdown, plain text, or multiple formats.
6. **Download results** – Export the dataset as JSON, CSV, Excel, XML, or another supported format.

### 💳 Pricing

Apify's **Free plan** includes monthly credits suitable for small tests and occasional archived-page lookups. Larger URL lists and deeper index searches use more requests, so paid plans provide more capacity for recurring research and automation.

### 📝 Input Parameters

| Parameter | Type | Required | Description |
| --------- | ---- | -------- | ----------- |
| `urls` | Array of strings | Yes | URLs or host-and-path values to find in Common Crawl. Empty and duplicate entries are removed. |
| `year` | Integer | No | Crawl year to search, such as `2025`. Every available index from that year is checked. When omitted, 10 indexes are selected according to `indexOrder`. Ignored when `indexes` is provided. |
| `indexOrder` | String | No | Discovery order: `"newest"` · `"oldest"`. Default `"newest"`. Ignored when `indexes` is provided. |
| `indexes` | Array of strings | No | Exact Common Crawl index IDs, such as `CC-MAIN-2026-25`. Up to the first 10 unique IDs are checked in the supplied order, bypassing automatic discovery. |
| `outputFormats` | Array of strings | No | Content fields to return: `"html"`, `"markdown"`, and/or `"text"`. Defaults to `["html"]`. |

#### Example inputs

**Recover the freshest available snapshots**

```json
{
  "urls": [
    "https://commoncrawl.org/",
    "https://example.com/about",
    "apify.com/store"
  ],
  "outputFormats": [
    "html",
    "markdown",
    "text"
  ],
  "indexOrder": "newest"
}
````

**Search every crawl from a historical year**

```json
{
  "urls": [
    "https://example.com/",
    "https://example.com/products"
  ],
  "year": 2024,
  "indexOrder": "oldest"
}
```

**Search selected crawls in a custom order**

```json
{
  "urls": [
    "https://example.com/blog/launch-announcement"
  ],
  "indexes": [
    "CC-MAIN-2024-10",
    "CC-MAIN-2025-30",
    "CC-MAIN-2026-25"
  ]
}
```

### 📊 Output / Results

Each requested URL produces one dataset item:

- **`requestedUrl`** *(string)* — the URL or host-and-path value submitted
- **`found`** *(boolean)* — whether a matching archived HTML page was found
- **`index`** *(string, optional)* — the Common Crawl index containing the match
- **`url`** *(string, optional)* — the resolved URL stored in the crawl
- **`html`** *(string, optional)* — the archived HTML content when selected in `outputFormats`
- **`markdown`** *(string, optional)* — Markdown converted from the archived HTML when selected in `outputFormats`
- **`text`** *(string, optional)* — plain text converted from the archived HTML when selected in `outputFormats`
- **`error`** *(string, optional)* — details when a lookup cannot be completed

```json
{
  "requestedUrl": "https://commoncrawl.org/",
  "found": true,
  "index": "CC-MAIN-2026-25",
  "url": "https://commoncrawl.org/",
  "html": "<!DOCTYPE html><html lang=\"en-US\"><head><title>Common Crawl</title>...</head><body>...</body></html>"
}
```

When no snapshot is found in the selected indexes:

```json
{
  "requestedUrl": "https://example.com/page-that-was-never-crawled",
  "found": false
}
```

### 🧭 Tips / Common Recipes

- **Recover recent content:** omit `year` and choose `indexOrder: "newest"` to check the 10 newest indexes.
- **Find the earliest available page:** choose `indexOrder: "oldest"`; the first match is the earliest matching crawl index.
- **Search one historical year:** set `year: 2024` to check every available index from 2024.
- **Compare selected periods:** run the same URL with different one-item `indexes` lists and compare the returned HTML.
- **Keep explicit lists focused:** only the first 10 unique `indexes` are checked.
- **Reduce unnecessary lookups:** use exact page URLs and omit `year` when you only care about recent history.
- **Search without a scheme:** values such as `example.com/about` are accepted alongside full URLs.
- **Reduce result size:** omit `"html"` from `outputFormats` when you only need Markdown or plain text.

### ⚙️ Best Practices

- **Use canonical URLs** when possible to reduce ambiguous or duplicate matches.
- **Choose indexes deliberately** because the Actor returns the first match, not every historical capture.
- **Plan for large results** because returning multiple formats, especially full HTML, can make dataset exports significantly larger.
- **Retry individual failures** when an item contains `error`, as archive availability and network conditions can vary.
- **Remember that snapshots are historical** and may not represent the current live page.

### 🌍 Proxy Usage

Common Crawl is a public archive, so most runs do not require special proxy routing. If your network cannot reach the archive reliably, Apify proxy settings can improve connectivity; residential targeting is usually unnecessary.

### ⚖️ Legal & Ethical Considerations

- **Respect applicable website terms**, archive policies, and downstream content restrictions.
- **Protect personal information** and comply with privacy requirements such as GDPR or CCPA.
- **Use reasonable workloads** and avoid abusive or unnecessarily repetitive archive requests.
- **Preserve attribution and ownership** when publishing, redistributing, or analyzing archived content.
- **Review usage rights** before using archived pages in commercial datasets or machine-learning projects.

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Common Crawl**. All trademarks belong to their respective owners.

### ❓ FAQ

**Does the Actor fetch the live page?**
No. It returns HTML stored in Common Crawl, not the current version of the website.

**Which index is searched by default?**
The Actor checks up to the 10 newest indexes and stops at the first matching HTML snapshot.

**What happens when I set `year`?**
The Actor checks every available index from that year in the selected `indexOrder` and stops at the first matching HTML snapshot.

**What happens when I provide `indexes`?**
Automatic discovery is skipped. Up to the first 10 unique IDs are checked in order, while `year` and `indexOrder` are ignored.

**Does the Actor return every snapshot of a URL?**
No. It returns the first matching HTML snapshot found using your chosen index order.

**Why does a result contain `error` instead of HTML?**
The archive lookup or download could not be completed for that URL. Retry the item, verify any explicit index IDs, and check your proxy settings if failures continue.

### 🛟 Support

Need a different archive field, a bulk-domain workflow, or multiple snapshots per URL?
Open an issue or contact me at https://igolaizola.com/#contact

# Actor input Schema

## `urls` (type: `array`):

List of URLs or host/path values to look up in Common Crawl. The actor returns whether each one was found, the crawl index that matched, and the archived HTML.

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

Optional crawl year, such as 2025. All indexes from that year are tested. When omitted, 10 indexes are selected according to the index order. Ignored when explicit indexes are provided.

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

Choose whether automatically selected indexes are tested from newest to oldest or from oldest to newest. Ignored when explicit indexes are provided.

## `indexes` (type: `array`):

Optional Common Crawl index IDs, such as CC-MAIN-2026-25. When provided, discovery is bypassed and up to the first 10 unique indexes are tested in the order listed.

## `outputFormats` (type: `array`):

Choose one or more content formats to include in each result.

## Actor input object example

```json
{
  "urls": [
    "https://apify.com"
  ],
  "indexOrder": "newest",
  "outputFormats": [
    "html"
  ]
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "urls": [
        "https://apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("igolaizola/commoncrawl-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 = { "urls": ["https://apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("igolaizola/commoncrawl-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 '{
  "urls": [
    "https://apify.com"
  ]
}' |
apify call igolaizola/commoncrawl-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Common Crawl Scraper (Archived HTML Finder)",
        "description": "Find URLs across historical commoncrawl.org indexes and download archived HTML. Search the 10 newest or oldest snapshots, choose a crawl year, or provide up to 10 exact indexes for SEO audits, page recovery, content research, and historical web datasets.",
        "version": "0.0",
        "x-build-id": "w1vCmNoLVkv4whGcb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igolaizola~commoncrawl-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igolaizola-commoncrawl-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/igolaizola~commoncrawl-scraper/runs": {
            "post": {
                "operationId": "runs-sync-igolaizola-commoncrawl-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/igolaizola~commoncrawl-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-igolaizola-commoncrawl-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "URLs",
                        "type": "array",
                        "description": "List of URLs or host/path values to look up in Common Crawl. The actor returns whether each one was found, the crawl index that matched, and the archived HTML.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "year": {
                        "title": "Crawl year",
                        "minimum": 2008,
                        "type": "integer",
                        "description": "Optional crawl year, such as 2025. All indexes from that year are tested. When omitted, 10 indexes are selected according to the index order. Ignored when explicit indexes are provided."
                    },
                    "indexOrder": {
                        "title": "Index order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Choose whether automatically selected indexes are tested from newest to oldest or from oldest to newest. Ignored when explicit indexes are provided.",
                        "default": "newest"
                    },
                    "indexes": {
                        "title": "Explicit indexes",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional Common Crawl index IDs, such as CC-MAIN-2026-25. When provided, discovery is bypassed and up to the first 10 unique indexes are tested in the order listed.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "outputFormats": {
                        "title": "Output formats",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose one or more content formats to include in each result.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "html",
                                "markdown",
                                "text"
                            ],
                            "enumTitles": [
                                "HTML",
                                "Markdown",
                                "Plain text"
                            ]
                        },
                        "default": [
                            "html"
                        ]
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```