# X402 Domain Full Scanner (`stech_ai/x402-sds`) Actor

Discover and audit monetized AI APIs with the ultimate X402 scanner. Automatically extract real-time pricing, crypto wallets, and network data from any domain. Decode Base64 headers and export structured JSON, PDF, and DOCX reports. Perfect for Web3 researchers, developers, and AI Agent.

- **URL**: https://apify.com/stech\_ai/x402-sds.md
- **Developed by:** [Stech AI](https://apify.com/stech_ai) (community)
- **Categories:** Developer tools, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $500.00 / 1,000 events

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 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

## X402 Domain Full Scanner
**Discover, Audit, and Export X402 Payment Endpoints for AI Agents and Web3 APIs**

SDS is a specialized Market Intelligence Actor on the Apify Store that scans any root domain to discover monetized API endpoints using the X402 protocol. It automatically extracts real-time pricing, wallet addresses, and network data, returning them as structured JSON alongside ready-to-download DOCX and PDF reports.

It is especially useful for tasks such as:
*   Auditing AI Agent monetization structures
*   Competitive pricing analysis for Web3 APIs
*   Building directories of paid AI services
*   Verifying X402 protocol compliance (v1 and v2)

SDS can process a single domain and probe dozens of endpoints in a single run. Each endpoint is verified individually, ensuring the data is accurate and up-to-date.

SDS helps researchers and developers map the emerging Agent Economy with precision.

Unlike generic web scrapers, SDS is purpose-built for the X402 protocol. It actively triggers `402 Payment Required` responses and decodes complex Base64 headers to extract hidden billing information.

#### 🎯 Who SDS Is For
SDS is designed for professionals and organizations that need to track, audit, or utilize monetized AI APIs.

**Web3 Researchers & Analysts**
Map the Agent Economy, track API pricing trends, and discover which blockchain networks are dominating the AI space.

**AI Developers & Builders**
Audit your own monetized endpoints to ensure compliance, or analyze competitors' pricing models and service offerings.

**Data Aggregators**
Automatically populate directories and databases with verified, real-time data of paid AI services.

**Automation Engineers**
Use SDS as a discovery component in workflows built with n8n, Make, Zapier, or custom applications to automatically fund and consume AI APIs.

#### 📣 Why SDS Matters
Discovering X402 endpoints manually is a tedious and highly technical process. To find a single API's price, a developer usually has to:
1. Search for hidden `.well-known` files or query third-party directories.
2. Manually send HTTP requests to trigger a `402 Payment Required` error.
3. Intercept the HTTP headers and manually decode Base64 strings just to read the price and wallet address.

SDS automates this entire pipeline in seconds. 

You simply provide a domain (e.g., `stech-api.sheradogilang.workers.dev`), and SDS will intelligently harvest the paths, probe the endpoints, decode the Base64 headers, and hand you a clean, professional PDF report containing the exact price, asset (e.g., USDC), and wallet address for every API on that domain.

#### ⚙️ Two Ways to Use SDS
| As a Standalone Tool | As a Workflow Component |
| :--- | :--- |
| Enter a domain and download the PDF/DOCX report. | Integrate SDS into automated workflows and AI agents. |
| Best for analysts, researchers, and non-technical users. | Best for developers and data aggregators. |
| No coding required. | Works with APIs and automation platforms. |

#### 🚀 Key Features
*   **X402 v1 & v2 Support** — Automatically detects protocol versions and decodes Base64 `payment-required` headers.
*   **Smart Discovery (Harvester)** — Queries the public directory to find hidden endpoints (UUID harvesting).
*   **Active Probing** — Actively fetches endpoints to trigger real-time 402 responses, ensuring pricing is 100% accurate.
*   **Structured JSON Output** — Ideal for automation, API integrations, and database storage.
*   **DOCX and PDF Generation** — Ready-to-share audit reports generated automatically for every scan.
*   **Audit Hash** — Each output includes a SHA-256 fingerprint of the raw response body to support verifiable claims.
*   **Fallback Dictionary** — Uses a built-in dictionary of common AI paths if public directories fail.
*   **Bypass Blocks** — Optional residential proxy support to bypass strict Cloudflare or WAF protections.

#### 📄 Output Formats
SDS generates multiple output formats in a single run.

| Format | Purpose |
| :--- | :--- |
| **JSON** | API integrations and automated workflows |
| **CSV** | Spreadsheet review and batch export |
| **DOCX** | Editable audit documents |
| **PDF** | Finalized and archival audit reports |

*JSON is the primary output for automation. CSV, DOCX, and PDF are supporting formats for operational use.*

#### 📥 Input Fields
| Field | Required | Description |
| :--- | :--- | :--- |
| `domain` | **Yes** | The root domain to scan (e.g., `stech-api.sheradogilang.workers.dev`). |
| `paths` | No | List specific paths to check manually (one per line). |
| `maxPaths` | No | Maximum number of paths to try when using the built-in dictionary. |
| `timeout` | No | Timeout per request in milliseconds (Default: 15000). |
| `useResidentialProxy` | No | Route requests through residential IPs to avoid datacenter blocks. |

#### 📤 Example Output
```json
[{
  "domain": "stech-api.sheradogilang.workers.dev",
  "path": "/x402/scdft",
  "x402Version": "2",
  "price": "1100000",
  "priceReadable": "$1.100000",
  "network": "eip155:8453",
  "asset": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  "payTo": "0x6428761Db59894899b26809503ac83b7790C6fB0",
  "label": "Ethical AI that transforms raw complaints into clear, honest, actionable reports.",
  "description": "Ethical AI that transforms raw complaints into clear, honest, actionable reports.",
  "source": "scraper:402",
  "auditHash": "55b3e70254628b65fae5091cc3f819a0f60415a008dffdef7cfaa46ec0041dcf",
  "httpStatus": "402",
  "responseTimeMs": "2388",
  "errorMessage": "",
  "timestamp": "2026-05-30T17:07:38.567Z",
  "download_docx": "https://api.apify.com/v2/key-value-stores/qI5pToncELMaYrhrP/records/OUTPUT.docx?disableRedirect=true",
  "download_pdf": "https://api.apify.com/v2/key-value-stores/qI5pToncELMaYrhrP/records/OUTPUT.pdf?disableRedirect=true"
}]
````

#### 🧪 Example Workflow (Market Analyst)

1. Identify a new AI Agent domain (e.g., `stech-api.sheradogilang.workers.dev`).
2. Enter the domain into SDS.
3. Run the Actor.
4. Download the generated PDF report.
5. Review the exact pricing, supported blockchain networks, and wallet addresses of the target API.

*What once took hours of manual API testing and Base64 decoding can be completed in seconds.*

#### 🔌 Integrations

As a published Apify Actor, SDS can be used with:

- n8n
- Make
- Zapier
- Google Sheets / Airtable
- Custom applications via the Apify API

Users connect their own accounts and control their own workflows.

#### ❗ Important Notes

- **403 Errors during discovery are normal:** Many modern APIs block standard web scrapers. SDS is designed to handle this gracefully by falling back to the Harvester and active probing.
- **Public Data Only:** SDS only extracts data that is publicly exposed by the target server via HTTP 402 responses or public directories.
- **Rate Limiting:** SDS is built to be a "polite" scanner. It uses a strict concurrency limit and delays to ensure target servers are not overwhelmed.
- Files remain available in your Apify run outputs until you delete them.

#### 💼 Business Value

Organizations use SDS to:

- Gain real-time market intelligence on AI API pricing
- Automate the discovery of Web3 monetization structures
- Standardize API auditing processes
- Reduce manual testing and decoding time

#### ⚠️ Disclaimer

- **Data Accuracy:** SDS is an automated market intelligence tool. All data (including prices, wallet addresses, networks, and descriptions) is extracted directly from public HTTP responses provided by the target servers in real-time. SDS does not alter this data and cannot guarantee its absolute accuracy.
- **No Financial Advice:** The generated reports do not constitute financial, legal, or investment advice. Always verify wallet addresses, networks, and pricing manually before executing any cryptocurrency transactions or integrating paid APIs.
- **No Affiliation:** Stech and the SDS tool are not affiliated with, endorsed by, or sponsored by any of the domains or directories scanned using this tool.
- **User Responsibility:** Users are solely responsible for ensuring that their use of this tool complies with applicable laws, regulations, and the Terms of Service of the target domains being scanned.

#### 📄 License

All rights reserved under the Stech Commercial License (SCL) v2.1.

Stech helps organizations navigate the Agent Economy with clarity, precision, and professionalism.

Professional tools should be powerful, but they should never be overly complicated.

Stech – honest, warm, and never pretends to be human. 😊🌿

# Actor input Schema

## `domain` (type: `string`):

Enter the domain to scan (without https://). Example: stech-api.sheradogilang.workers.dev

## `paths` (type: `string`):

List specific paths to check, one per line. Must start with a slash (/). Leave empty to auto-discover all endpoints.

## `maxPaths` (type: `integer`):

Maximum number of paths to try when using the built-in dictionary.

## `timeout` (type: `integer`):

Timeout per request in milliseconds.

## `useResidentialProxy` (type: `boolean`):

Route requests through residential IPs to avoid datacenter blocks. Additional cost applies.

## Actor input object example

```json
{
  "domain": "stech-api.sheradogilang.workers.dev",
  "paths": "/x402/sapi\n/x402/scdft\n/x402/spdet",
  "maxPaths": 100,
  "timeout": 15000,
  "useResidentialProxy": false
}
```

# Actor output Schema

## `domain` (type: `string`):

Root domain that was scanned.

## `path` (type: `string`):

Full path of the endpoint that was checked.

## `httpStatus` (type: `string`):

HTTP status code returned by the endpoint.

## `x402Version` (type: `string`):

Version of the X402 protocol detected.

## `price` (type: `string`):

Raw price in atomic units of the payment token.

## `priceReadable` (type: `string`):

Price per call in USDC (e.g., $0.001000).

## `network` (type: `string`):

Blockchain network for payment (e.g., base).

## `asset` (type: `string`):

Token contract address for payment.

## `payTo` (type: `string`):

Wallet address that receives the payment.

## `label` (type: `string`):

Product label from the X402 offer.

## `description` (type: `string`):

Product description from the X402 offer.

## `source` (type: `string`):

Origin of the endpoint data (e.g., well-known-x402, llms.txt, scraper:402, dictionary).

## `auditHash` (type: `string`):

SHA-256 hash of the raw response body for verifiable claims.

## `responseTimeMs` (type: `string`):

Response time in milliseconds.

## `errorMessage` (type: `string`):

Error message if the endpoint check failed.

## `timestamp` (type: `string`):

Scan timestamp in ISO 8601 format.

## `download_docx` (type: `string`):

URL to download the full scan report as a Microsoft Word (.docx) file.

## `download_pdf` (type: `string`):

URL to download the full scan report as a PDF file.

# 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 = {
    "domain": "stech-api.sheradogilang.workers.dev",
    "paths": `/x402/sapi
/x402/scdft
/x402/spdet`
};

// Run the Actor and wait for it to finish
const run = await client.actor("stech_ai/x402-sds").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 = {
    "domain": "stech-api.sheradogilang.workers.dev",
    "paths": """/x402/sapi
/x402/scdft
/x402/spdet""",
}

# Run the Actor and wait for it to finish
run = client.actor("stech_ai/x402-sds").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 '{
  "domain": "stech-api.sheradogilang.workers.dev",
  "paths": "/x402/sapi\\n/x402/scdft\\n/x402/spdet"
}' |
apify call stech_ai/x402-sds --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X402 Domain Full Scanner",
        "description": "Discover and audit monetized AI APIs with the ultimate X402 scanner. Automatically extract real-time pricing, crypto wallets, and network data from any domain. Decode Base64 headers and export structured JSON, PDF, and DOCX reports. Perfect for Web3 researchers, developers, and AI Agent.",
        "version": "0.0",
        "x-build-id": "Giqh7aEnInVxJVR9q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stech_ai~x402-sds/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stech_ai-x402-sds",
                "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/stech_ai~x402-sds/runs": {
            "post": {
                "operationId": "runs-sync-stech_ai-x402-sds",
                "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/stech_ai~x402-sds/run-sync": {
            "post": {
                "operationId": "run-sync-stech_ai-x402-sds",
                "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": [
                    "domain"
                ],
                "properties": {
                    "domain": {
                        "title": "Root Domain",
                        "type": "string",
                        "description": "Enter the domain to scan (without https://). Example: stech-api.sheradogilang.workers.dev"
                    },
                    "paths": {
                        "title": "Specific Paths to Check (Optional)",
                        "type": "string",
                        "description": "List specific paths to check, one per line. Must start with a slash (/). Leave empty to auto-discover all endpoints."
                    },
                    "maxPaths": {
                        "title": "Max Paths (Dictionary Fallback)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of paths to try when using the built-in dictionary.",
                        "default": 100
                    },
                    "timeout": {
                        "title": "Timeout (ms)",
                        "minimum": 1000,
                        "maximum": 30000,
                        "type": "integer",
                        "description": "Timeout per request in milliseconds.",
                        "default": 15000
                    },
                    "useResidentialProxy": {
                        "title": "Use Residential Proxy (Bypass Blocks)",
                        "type": "boolean",
                        "description": "Route requests through residential IPs to avoid datacenter blocks. Additional cost applies.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```