# eBay Search Scraper - Listings, Prices & Sellers (`scrapeworks/ebay-search-scraper`) Actor

Scrape eBay search results in bulk - get product titles, prices, condition, shipping, sellers, watchers and image URLs as clean JSON. No eBay API key needed. Pass many keywords or eBay search URLs per run, paginate deep, on any eBay marketplace.

- **URL**: https://apify.com/scrapeworks/ebay-search-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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.

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

## eBay Search Scraper — Listings, Prices, Conditions & Sellers

Scrape **eBay search results at scale** and get every listing as clean, structured
JSON — **no eBay API key, no developer account, no login required.** Just type
keywords (or paste eBay search URLs) and the actor returns titles, prices,
condition, shipping, seller, watchers and image URLs, paginating deep automatically.

Built for **bulk**: pass a whole list of keywords or search URLs in a single run,
and set how many listings you want per query. Works on **any eBay marketplace**
(ebay.com, ebay.co.uk, ebay.de, ebay.com.au, ebay.ca and more).

### What you can do with it

- **Price research & repricing** — track what identical items sell for across thousands of listings.
- **Product & market research** — measure supply, price spread and demand (watchers) for a niche.
- **Reseller / arbitrage sourcing** — pull every "Buy It Now" under a price, with free shipping only.
- **Competitor & brand monitoring** — watch new listings for a brand or model, sorted newest-first.
- **Dropshipping / catalog building** — harvest titles, images and prices to seed a catalog.

### Input

| Field | Type | What it does |
|---|---|---|
| `searchTerms` | array of strings | Keywords to search. Each is searched and paginated separately. Add as many as you want. |
| `directUrls` | array of strings | Optional. Paste full eBay `/sch/i.html?...` search URLs (with your own filters/category). |
| `domain` | string | eBay marketplace: `ebay.com`, `ebay.co.uk`, `ebay.de`, `ebay.com.au`, `ebay.ca`, `ebay.fr`, `ebay.it`, `ebay.es`, `ebay.nl`, `ebay.ie`, `ebay.in`. |
| `maxResultsPerQuery` | integer | Max listings to return per keyword/URL (default 100). Paginates 240 per page. |
| `sortBy` | string | `best_match`, `ending_soonest`, `newly_listed`, `price_low`, `price_high`. |
| `conditionFilter` | string | `any`, `new`, `used`, `open_box`, `refurbished`. |
| `buyingFormat` | string | `any`, `buy_it_now`, `auction`. |
| `freeShippingOnly` | boolean | Only listings with free shipping. |
| `proxyConfiguration` | object | Proxy. **RESIDENTIAL Apify Proxy is strongly recommended** — eBay blocks datacenter IPs. |

#### Example input

```json
{
  "searchTerms": ["mechanical keyboard", "vintage rolex"],
  "domain": "ebay.com",
  "maxResultsPerQuery": 200,
  "sortBy": "best_match",
  "conditionFilter": "any",
  "buyingFormat": "any",
  "freeShippingOnly": false,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
````

### Output

Each listing is one dataset row:

| Field | Description |
|---|---|
| `listingId` | eBay item number. |
| `title` | Listing title. |
| `url` | Canonical listing URL (`/itm/<id>`). |
| `condition` | New, Pre-Owned, Open box, Refurbished, etc. |
| `subtitle` | Item aspects eBay shows under the condition (e.g. material), when present. |
| `price` | Price text as shown (single price or a range). |
| `priceValue` | Numeric low price. |
| `priceMax` | Numeric high price (for ranges; otherwise null). |
| `currency` | Currency symbol/code of the marketplace. |
| `buyingFormat` | "Buy It Now", "or Best Offer", or auction. |
| `bids` | Bid count for auctions. |
| `shipping` | Shipping/delivery text. |
| `seller` | Seller username (when eBay shows it on the results page). |
| `sellerFeedback` | Seller positive-feedback % and count (when shown). |
| `watchers` | Number of watchers, when shown. |
| `sold` | Units sold, when shown. |
| `image` | Thumbnail image URL. |
| `searchTerm` | The keyword/URL that produced this row. |
| `domain` | Marketplace scraped. |
| `scrapedAt` | UTC timestamp. |

#### Example output row

```json
{
  "listingId": "287376560372",
  "title": "LEGO STAR WARS: UCS Y-Wing Starfighter - Set 75181 (used - Build Only)",
  "url": "https://www.ebay.com/itm/287376560372",
  "condition": "Pre-Owned",
  "subtitle": null,
  "price": "$249.99",
  "priceValue": 249.99,
  "priceMax": null,
  "currency": "$",
  "buyingFormat": "Buy It Now",
  "bids": null,
  "shipping": "+$23.80 shipping estimate",
  "seller": "brickbuilder_us",
  "sellerFeedback": "99.4% positive (3.1K)",
  "watchers": 14,
  "sold": null,
  "image": "https://i.ebayimg.com/images/g/r40AAeSwTDxqIwjn/s-l500.jpg",
  "searchTerm": "lego star wars ucs",
  "domain": "ebay.com",
  "scrapedAt": "2026-06-14T10:22:35Z"
}
```

> Prices come back in the **marketplace's local currency**, and that currency
> follows the proxy location too. Run with US residential proxy on `ebay.com` for
> USD; `ebay.co.uk` for GBP, etc. `seller`, `watchers` and `sold` are populated
> when eBay shows them on the results page — for some categories eBay omits them
> there, so they may be null.

### Pricing

This actor is **pay per result**: you are charged **$0.001 per listing** returned
to your dataset. Blocked or empty pages are never charged — you only pay for real
rows. A 1,000-listing run costs about **$1.00** plus Apify proxy/compute usage.

### Tips

- Use **RESIDENTIAL** proxy groups. eBay blocks datacenter traffic; residential is the reliable path.
- To use eBay's own advanced filters (price range, category, location), build the search on eBay, copy the URL, and drop it into `directUrls`.
- `maxResultsPerQuery` paginates automatically; eBay itself caps a single search at a few thousand results.

### FAQ

**Do I need an eBay API key or account?** No. The actor reads eBay's public search pages.

**Why residential proxy?** eBay aggressively blocks datacenter IPs. The actor bootstraps
session cookies and rotates proxy sessions on blocks, but residential IPs are what keep it reliable.

**Can I scrape multiple keywords at once?** Yes — that's the point. Pass a list in
`searchTerms`; each is paginated independently, and every row records which `searchTerm` it came from.

**Which marketplaces are supported?** ebay.com, ebay.co.uk, ebay.de, ebay.com.au,
ebay.ca, ebay.fr, ebay.it, ebay.es, ebay.nl, ebay.ie and ebay.in.

**Is this legal?** It reads publicly available, non-logged-in search pages. You are
responsible for complying with eBay's terms and applicable law in your use of the data.

# Actor input Schema

## `searchTerms` (type: `array`):

One or more keywords/phrases to search on eBay (e.g. 'mechanical keyboard', 'vintage rolex'). Each term is searched separately and paginated deep up to 'Max results per query'. Add as many as you like in a single run.

## `directUrls` (type: `array`):

Optional: paste full eBay search-results URLs (e.g. an /sch/i.html?... link with your own filters, category or price range already applied). Each URL is scraped and paginated just like a keyword. Use this when you want eBay's own advanced filters; otherwise just use 'Search keywords'.

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

Which eBay site to search. Prices are returned in that site's local currency. Most-used is ebay.com (US).

## `maxResultsPerQuery` (type: `integer`):

Maximum listings to return for EACH keyword/URL. The actor paginates automatically (240 listings per page). eBay itself caps a single search at a few thousand results.

## `sortBy` (type: `string`):

Result order, same as eBay's own sort dropdown.

## `conditionFilter` (type: `string`):

Only return listings of this condition. 'Any' returns everything.

## `buyingFormat` (type: `string`):

Restrict to a buying format. 'Any' returns both fixed-price and auction listings.

## `freeShippingOnly` (type: `boolean`):

If on, only return listings that offer free shipping.

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

Proxy used to reach eBay. eBay blocks datacenter traffic, so RESIDENTIAL Apify Proxy is strongly recommended for reliable results. Defaults to Apify Proxy.

## Actor input object example

```json
{
  "searchTerms": [
    "mechanical keyboard"
  ],
  "domain": "ebay.com",
  "maxResultsPerQuery": 100,
  "sortBy": "best_match",
  "conditionFilter": "any",
  "buyingFormat": "any",
  "freeShippingOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchTerms": [
        "mechanical keyboard"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeworks/ebay-search-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 = {
    "searchTerms": ["mechanical keyboard"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/ebay-search-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 '{
  "searchTerms": [
    "mechanical keyboard"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call scrapeworks/ebay-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "eBay Search Scraper - Listings, Prices & Sellers",
        "description": "Scrape eBay search results in bulk - get product titles, prices, condition, shipping, sellers, watchers and image URLs as clean JSON. No eBay API key needed. Pass many keywords or eBay search URLs per run, paginate deep, on any eBay marketplace.",
        "version": "0.1",
        "x-build-id": "ggpFgZIE1sMy8kiqf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapeworks~ebay-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapeworks-ebay-search-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/scrapeworks~ebay-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapeworks-ebay-search-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/scrapeworks~ebay-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapeworks-ebay-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerms": {
                        "title": "Search keywords",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "One or more keywords/phrases to search on eBay (e.g. 'mechanical keyboard', 'vintage rolex'). Each term is searched separately and paginated deep up to 'Max results per query'. Add as many as you like in a single run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "directUrls": {
                        "title": "eBay search URLs (optional, power users)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional: paste full eBay search-results URLs (e.g. an /sch/i.html?... link with your own filters, category or price range already applied). Each URL is scraped and paginated just like a keyword. Use this when you want eBay's own advanced filters; otherwise just use 'Search keywords'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "domain": {
                        "title": "eBay marketplace",
                        "enum": [
                            "ebay.com",
                            "ebay.co.uk",
                            "ebay.de",
                            "ebay.com.au",
                            "ebay.ca",
                            "ebay.fr",
                            "ebay.it",
                            "ebay.es",
                            "ebay.nl",
                            "ebay.ie",
                            "ebay.in"
                        ],
                        "type": "string",
                        "description": "Which eBay site to search. Prices are returned in that site's local currency. Most-used is ebay.com (US).",
                        "default": "ebay.com"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum listings to return for EACH keyword/URL. The actor paginates automatically (240 listings per page). eBay itself caps a single search at a few thousand results.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "best_match",
                            "ending_soonest",
                            "newly_listed",
                            "price_low",
                            "price_high"
                        ],
                        "type": "string",
                        "description": "Result order, same as eBay's own sort dropdown.",
                        "default": "best_match"
                    },
                    "conditionFilter": {
                        "title": "Item condition",
                        "enum": [
                            "any",
                            "new",
                            "used",
                            "open_box",
                            "refurbished"
                        ],
                        "type": "string",
                        "description": "Only return listings of this condition. 'Any' returns everything.",
                        "default": "any"
                    },
                    "buyingFormat": {
                        "title": "Buying format",
                        "enum": [
                            "any",
                            "buy_it_now",
                            "auction"
                        ],
                        "type": "string",
                        "description": "Restrict to a buying format. 'Any' returns both fixed-price and auction listings.",
                        "default": "any"
                    },
                    "freeShippingOnly": {
                        "title": "Free shipping only",
                        "type": "boolean",
                        "description": "If on, only return listings that offer free shipping.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach eBay. eBay blocks datacenter traffic, so RESIDENTIAL Apify Proxy is strongly recommended for reliable results. Defaults to Apify Proxy.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
