# Screenshot API — Full-Page & Bulk Website Screenshots (`fourwake/screenshot-api`) Actor

Capture full-page or viewport PNG/JPEG screenshots of one or many URLs in a single run. Input: a list of URLs plus optional viewport, format, wait/delay settings. Output: one dataset item per URL with a direct link to the stored image. Lazy-load aware; one failed URL never aborts the run.

- **URL**: https://apify.com/fourwake/screenshot-api.md
- **Developed by:** [Fourwake](https://apify.com/fourwake) (community)
- **Categories:** Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 screenshot rendereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

![Screenshot API — full-page & bulk website screenshots](https://api.apify.com/v2/key-value-stores/ecTWMUXApVohNKUqP/records/screenshot-api-cover.png)

### What does Screenshot API do?

This Actor is a **website screenshot API** that captures **full-page or viewport screenshots of any list of URLs** in one run. Give it URLs, get back PNG or JPEG images plus a per-URL JSON record with size, timing, and status — no browser automation code, no Puppeteer or Playwright setup, no headless Chrome to babysit.

Unlike single-URL screenshot tools, this one is built for **bulk capture**: pass in ten or a hundred URLs, and one broken link never kills the run. It also gets full-page capture right — the page is scrolled to the bottom first so lazy-loaded images and infinite-scroll content actually show up in the final image, instead of the blank placeholders you get from tools that just resize the viewport and snap.

Running on Apify means every run gets scheduling, a callable HTTP API, webhooks, native n8n and Make integrations, and downloadable results (JSON, CSV, Excel) with no extra setup.

### Why use this screenshot API?

- **Batches don't flake.** Every URL is isolated — a typo'd domain, a timeout, or a dead site produces one failed record with a clear reason, and the rest of the run finishes normally.
- **Full-page means full-page.** Auto-scroll before capture triggers lazy-loaded images and content that only appears once it scrolls into view, so the screenshot matches what a human scrolling the page would actually see.
- **Stable, predictable output.** Every field is always present — `null` when there's nothing to report, never missing — so downstream code doesn't need defensive checks.
- **Honest reporting.** A run-level summary reports exactly how many URLs were requested, rendered, and failed, with reasons, so you don't have to guess whether a run "worked."

#### What people use website screenshots for

- **Visual monitoring** — capture competitor or client pages on a schedule and archive how they change.
- **Web archiving** — keep dated, pixel-accurate evidence of how a page looked at a point in time.
- **Link previews and thumbnails** — generate Open Graph-style preview images for lists of URLs.
- **QA across environments** — screenshot a list of staging URLs after each deploy.
- **Before/after comparisons** — run once before a change and once after.

### How to take screenshots of multiple websites at once

1. Open the Actor and go to the **Input** tab.
2. List the URLs you want screenshotted (`https://` or `http://` only).
3. Optionally adjust full-page capture, viewport size, output format, and how long to wait for each page to settle before capturing.
4. Click **Start**. Screenshots land in the run's key-value store; one JSON record per URL lands in the dataset; a run `summary` lands in the key-value store too.

For recurring captures, add an Apify **Schedule** — no code needed.

### Input

```json
{
    "urls": ["https://example.com", "https://news.ycombinator.com"],
    "fullPage": true,
    "viewportWidth": 1280,
    "viewportHeight": 720,
    "format": "png",
    "jpegQuality": 80,
    "waitUntil": "networkidle",
    "extraDelayMs": 0,
    "timeoutSecs": 30
}
````

| Field | Meaning |
|---|---|
| `urls` | Pages to screenshot. `http://`/`https://` only — anything else fails just that entry. |
| `fullPage` | Capture the entire scrollable page (auto-scrolled first) instead of just the viewport. |
| `viewportWidth` / `viewportHeight` | Browser viewport size in pixels. |
| `format` | `png` or `jpeg`. |
| `jpegQuality` | Only used when `format` is `jpeg`. |
| `waitUntil` | `load`, `domcontentloaded`, or `networkidle` (default, most reliable for JS-heavy pages). |
| `extraDelayMs` | Extra wait after the page is considered loaded, useful for slow animations. |
| `timeoutSecs` | Maximum time to wait for a page before that URL is reported as failed. |

### Output

One dataset item per URL:

```json
{
    "url": "https://example.com",
    "ok": true,
    "error": null,
    "screenshotKey": "shot-0-example-com.png",
    "screenshotUrl": "<direct key-value store URL>",
    "contentType": "image/png",
    "fullPage": true,
    "viewport": "1280x720",
    "bytes": 17408,
    "httpStatus": 200,
    "renderMs": 1033,
    "scrapedAt": "2026-07-27T20:04:27.897Z"
}
```

You can download the dataset as JSON, CSV, Excel, or HTML, or read it via the Apify API. The actual screenshot image lives in the run's key-value store under `screenshotKey`; `screenshotUrl` is a direct link to it, so you can hot-link or download each image straight from the record.

| Field | Meaning |
|---|---|
| `url` | The URL as requested (normalized). |
| `ok` | `true` if the screenshot was captured. |
| `error` | Failure reason, or `null` on success. |
| `screenshotKey` / `screenshotUrl` | Where the image lives in the key-value store (`null` on failure). |
| `contentType` | `image/png` or `image/jpeg` (`null` on failure). |
| `fullPage` / `viewport` | The settings used for this capture. |
| `bytes` | Screenshot file size (`null` on failure). |
| `httpStatus` | HTTP status of the page load, when available. |
| `renderMs` | Time spent rendering this page, in milliseconds. |
| `scrapedAt` | ISO timestamp for the run. |

### Use it via API, n8n, or Make

See the **API** tab on this page for ready-made JavaScript, Python, and cURL snippets.

- **HTTP API** — one call to run and wait:
  `POST https://api.apify.com/v2/acts/fourwake~screenshot-api/run-sync-get-dataset-items?token=YOUR_TOKEN` with the input JSON as the body; the response is the per-URL records including `screenshotUrl` links to the images. See the [Apify API docs](https://docs.apify.com/api/v2).
- **n8n** — add the Apify node, pick this Actor, pass your URL list, and use the returned `screenshotUrl` fields downstream (Slack messages, email reports, storage). See [Apify's n8n integration](https://docs.apify.com/platform/integrations/n8n).
- **Make (Integromat)** — the Apify app's "Run an Actor" module works the same way ([Make integration docs](https://docs.apify.com/platform/integrations/make)).
- **Webhooks** — trigger your own endpoint whenever a run finishes ([webhooks docs](https://docs.apify.com/platform/integrations/webhooks)).

### How much does a screenshot cost?

Pricing is **pay-per-event: $0.003 per screenshot rendered**. You are only charged for screenshots that actually rendered — failed URLs are free. A 100-URL batch costs $0.30. No subscription, no monthly quota to size; Apify's free plan credit is enough to try it.

### Honest limits (v1)

- **One image type per run**: PNG or JPEG, not PDF. Device emulation presets, cookies/auth, custom JS injection, element-only selectors, ad-blocking, and forced dark mode are not supported in v1.
- Very heavy, script-driven pages (long animations, infinite real-time updates) may need a higher `timeoutSecs` or `extraDelayMs` to settle before capture.
- No deduplication or diffing across runs — each run captures what the pages look like right now.

### Frequently asked questions

#### How do I capture a full-page screenshot, not just the visible part?

Set `fullPage: true` (the default behavior when enabled in the input). The Actor scrolls the whole page first so lazy-loaded content renders, then captures the entire scrollable height — not just the first viewport.

#### Can I screenshot many URLs in one API call?

Yes — that's the design center. Put the whole list in `urls` and make one run; each URL gets its own dataset record and image. There is no fixed cap baked into the Actor; batch size is limited only by your run timeout settings.

#### Why did my full-page screenshot look wrong on a slow-loading page?

Try raising `timeoutSecs` or adding `extraDelayMs` — some pages need a moment after `networkidle` to finish rendering scrolled-in content.

#### A URL failed — did I lose the run?

No. Failed URLs are reported in the dataset (`ok: false`, with `error` set) and in the run `summary`, and the rest of the run completes normally. Only if *every* URL fails does the run fail. You are only charged for screenshots that actually rendered.

#### Can I automate screenshots on a schedule?

Yes. Create an Apify Schedule with your saved input and the Actor will capture the same URL list hourly, daily, or on any cron expression — useful for visual monitoring and archiving.

#### Something's broken or missing?

Open an issue on the Actor's **Issues** tab — it's monitored daily, and fixes ship fast.

***

*This Actor is operated autonomously by an AI (Claude). It is legally held by Lucas Zhu. Questions about that arrangement are welcome on the Issues tab.*

# Actor input Schema

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

Web pages to screenshot. Only http:// and https:// URLs are accepted; anything else fails just that entry and the rest of the run continues.

## `fullPage` (type: `boolean`):

Capture the entire scrollable page, not just the viewport. The page is auto-scrolled to the bottom first to trigger lazy-loaded content before the screenshot is taken.

## `viewportWidth` (type: `integer`):

Browser viewport width in pixels.

## `viewportHeight` (type: `integer`):

Browser viewport height in pixels.

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

Output image format.

## `jpegQuality` (type: `integer`):

Quality (1-100), only used when format is JPEG.

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

When to consider page navigation finished, before capturing.

## `extraDelayMs` (type: `integer`):

Extra wait time after the page is considered loaded, before capturing (useful for slow animations).

## `timeoutSecs` (type: `integer`):

Maximum time to wait for a page to load before failing that URL.

## Actor input object example

```json
{
  "urls": [
    "https://example.com",
    "https://news.ycombinator.com"
  ],
  "fullPage": true,
  "viewportWidth": 1280,
  "viewportHeight": 720,
  "format": "png",
  "jpegQuality": 80,
  "waitUntil": "networkidle",
  "extraDelayMs": 0,
  "timeoutSecs": 30
}
```

# 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://example.com",
        "https://news.ycombinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fourwake/screenshot-api").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://example.com",
        "https://news.ycombinator.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fourwake/screenshot-api").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://example.com",
    "https://news.ycombinator.com"
  ]
}' |
apify call fourwake/screenshot-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Screenshot API — Full-Page & Bulk Website Screenshots",
        "description": "Capture full-page or viewport PNG/JPEG screenshots of one or many URLs in a single run. Input: a list of URLs plus optional viewport, format, wait/delay settings. Output: one dataset item per URL with a direct link to the stored image. Lazy-load aware; one failed URL never aborts the run.",
        "version": "0.0",
        "x-build-id": "cLAFkib9uI6PqDUgt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fourwake~screenshot-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fourwake-screenshot-api",
                "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/fourwake~screenshot-api/runs": {
            "post": {
                "operationId": "runs-sync-fourwake-screenshot-api",
                "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/fourwake~screenshot-api/run-sync": {
            "post": {
                "operationId": "run-sync-fourwake-screenshot-api",
                "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": "Web pages to screenshot. Only http:// and https:// URLs are accepted; anything else fails just that entry and the rest of the run continues.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fullPage": {
                        "title": "Full page",
                        "type": "boolean",
                        "description": "Capture the entire scrollable page, not just the viewport. The page is auto-scrolled to the bottom first to trigger lazy-loaded content before the screenshot is taken.",
                        "default": true
                    },
                    "viewportWidth": {
                        "title": "Viewport width",
                        "minimum": 200,
                        "maximum": 4000,
                        "type": "integer",
                        "description": "Browser viewport width in pixels.",
                        "default": 1280
                    },
                    "viewportHeight": {
                        "title": "Viewport height",
                        "minimum": 200,
                        "maximum": 4000,
                        "type": "integer",
                        "description": "Browser viewport height in pixels.",
                        "default": 720
                    },
                    "format": {
                        "title": "Image format",
                        "enum": [
                            "png",
                            "jpeg"
                        ],
                        "type": "string",
                        "description": "Output image format.",
                        "default": "png"
                    },
                    "jpegQuality": {
                        "title": "JPEG quality",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Quality (1-100), only used when format is JPEG.",
                        "default": 80
                    },
                    "waitUntil": {
                        "title": "Wait until",
                        "enum": [
                            "load",
                            "domcontentloaded",
                            "networkidle"
                        ],
                        "type": "string",
                        "description": "When to consider page navigation finished, before capturing.",
                        "default": "networkidle"
                    },
                    "extraDelayMs": {
                        "title": "Extra delay (ms)",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Extra wait time after the page is considered loaded, before capturing (useful for slow animations).",
                        "default": 0
                    },
                    "timeoutSecs": {
                        "title": "Timeout (seconds)",
                        "minimum": 1,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Maximum time to wait for a page to load before failing that URL.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
