# Sysco Food Service Scraper (`parseforge/sysco-scraper`) Actor

Scrape wholesale food products from Sysco by zip code with no account needed. Get 40+ fields per item including pack size, weight, stock status, barcode, images, categories, and real time availability. Filter by brand, category, or search term. Export as JSON, CSV, or Excel.

- **URL**: https://apify.com/parseforge/sysco-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 7 total users, 3 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🛒 Sysco Food Service Scraper

Quickly extract wholesale food product data from Sysco's regional catalogs without needing an account. Whether you're building restaurant cost models, monitoring supplier catalogs, or gathering product data for food service integration, this tool collects product names, brands, pack sizes, stock status, and availability details in minutes.

> **The Sysco Food Service Scraper gathers over 30 fields of product data, including real-time stock status and next receive dates, without requiring an account or login.**

### ✨ What Does It Do

- 🏷️ **Product Identity**: Includes product ID, name, brand, brand ID, GTIN barcode, and Sysco private label flag.
- 📦 **Pack and Weight Data**: Covers pack count, size, unit of measure, units per case, average weight per case, and both gross and net weight.
- 🏬 **Category Hierarchy**: Provides the full Sysco category path with main, major, minor, and display name.
- 📊 **Stock and Availability**: Details stock status, stock type, quantity on hand, available on hand, and next receive date.
- 🧊 **Storage and Handling**: Indicates storage type (chilled, frozen, dry), catch weight flag, and sold as configuration (split or case).
- 🌱 **Sustainability**: Lists sustainability type labels when available.
- 🖼️ **Images**: Includes all product images, with primary and additional angles.

### 🔧 Input

- **Search Query**: A keyword to search Sysco's catalog, such as chicken, pasta, beef, produce, or dairy.
- **Zip Code**: A US zip code that determines your regional Sysco distribution center. Different zip codes yield different product assortments and availability data.
- **Max Items**: The maximum number of products to collect. Free users can collect up to 100, while paid users can collect up to 1,000,000.
- **Category ID**: Optional filter by Sysco category ID to narrow down to a specific food category.
- **Brand ID**: Optional filter by brand ID to restrict results to a specific brand, such as SYS CLS for Sysco Classic or SYS IMP for Sysco Imperial.
- **Request Delay**: Optional milliseconds to wait between requests if rate limiting occurs.

Example input:

```json
{
  "searchQuery": "chicken",
  "zipCode": "10001",
  "maxItems": 100
}
````

Example with filters:

```json
{
  "searchQuery": "chicken breast",
  "zipCode": "90001",
  "categoryId": "5",
  "brandId": "SYS CLS",
  "maxItems": 50
}
```

### 📊 Output

Each product includes identity, pack data, category, stock, and handling fields.

| 🖼️ Image | 🏷️ Product ID | 📝 Name |
|---|---|---|
| 🏷️ Brand | 🏷️ Brand ID | ✅ Is Sysco Brand |
| ⚠️ Is Phased Out | ⏳ Is Leaving Soon | 📦 Is Expanded Assortment |
| ⚖️ Is Catch Weight | 🔀 Is Sold As Split | 📦 Is Sold As Case |
| 📊 Stock Status | 🏷️ Stock Type | 🔢 Stock Type Code |
| 🔢 Stock Indicator | 📂 Category Main | 📂 Category Major |
| 📂 Category Minor | 📂 Category Name | 📦 Pack Size |
| 🔢 Pack Count | 📏 Size Value | 📏 Size UOM |
| 🔢 Units Per Case | 🔢 Quantity On Hand | 🔢 Available On Hand |
| 📅 Next Receive Date | ⚖️ Avg Weight Per Case | ⚖️ Gross Weight |
| ⚖️ Net Weight | 🧊 Storage Flag | 🔢 GTIN / Barcode |
| 🌱 Sustainability Types | 🏭 Source Vendor | 🏪 Seller ID |
| 🏪 Site ID | 📄 Description | 🖼️ Images |
| 🔗 URL | 🕒 Scraped At | ⚠️ Error |

### 💎 Why Choose the Sysco Food Service Scraper?

| Feature | Our Actor |
|---|---|
| No account or login required | ✔️ |
| Regional catalog by zip code (different products per distribution center) | ✔️ |
| Full pack data: count, size, UOM, units per case | ✔️ |
| Weight fields: average, gross, net per case | ✔️ |
| Storage flag: chilled, frozen, or dry for logistics | ✔️ |
| Live stock levels and next receive date | ✔️ |
| GTIN barcode field for POS integration | ✔️ |
| All product images, not just thumbnail | ✔️ |
| Sustainability type labels for sourcing compliance | ✔️ |
| Category hierarchy: main, major, minor, display name | ✔️ |
| Catch weight and split order flags | ✔️ |
| Filter by category ID or brand ID | ✔️ |

### 📋 How to Use

No technical skills needed. Just follow these steps:

1. **Sign Up**: [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool**: Search for "Sysco Food Service Scraper" in the Apify Store and set up your input
3. **Run It**: Click "Start" and watch your results appear

That's it. No coding, no setup, no complicated configuration. You can export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 🍽️ **Restaurant Procurement Manager**: Gather pack sizes, units per case, and weight data across protein, dairy, and dry goods to build accurate cost models for seasonal menu planning.
- 📋 **Menu Planner**: Search by category or brand to find available SKUs in your regional distribution center before placing orders or designing new menu items.
- 🏷️ **Category Analyst**: Compare Sysco private label products against national brands in the same category to evaluate quality and identify cost savings.
- 📦 **Supply Chain Manager**: Monitor stock status, quantity on hand, and next receive dates to anticipate shortages and plan inventory during peak periods.
- 💻 **Food Tech Developer**: Build or enrich product databases for food ordering platforms, recipe apps, or procurement software using real SKU data with barcodes and images.

### ❓ FAQ

**🔍 Does this require a Sysco account?**
No. This scraper works without any account or login. It accesses the public product catalog using your zip code to determine the regional distribution center.

**🌍 Why does zip code matter?**
Sysco operates regional distribution centers across the US. Different zip codes yield different product assortments and stock availability. Los Angeles may return over 600 results for the same search that returns 280 in New York.

**💰 What about account-specific features?**
This tool returns public catalog data accessible without authentication. Account-specific features like reservations and special ordering options are not available.

**📊 How current is the data?**
Data is fetched live at run time directly from Sysco's systems. Stock quantities and availability reflect near real-time inventory.

**🧊 What does the storage flag mean?**
C means chilled or refrigerated, F means frozen, and D means dry or ambient. Useful for logistics planning and storage allocation.

**⚖️ What is a catch weight product?**
A catch weight product is one where each case has a variable weight, common in fresh proteins. The isCatchWeight field flags these so you can handle them correctly in your ordering systems.

**💾 What formats can I export?**
You can export the dataset in JSON, CSV, or Excel.

**⚠️ Are there any limits?**
Free users can collect up to 100 results per run. Paid users can collect up to 1,000,000 results per run.

### 🔗 Integrate Sysco Food Service Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5,000+ apps
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Iron Planet Scraper](https://apify.com/parseforge/iron-planet-scraper) - Collect heavy equipment auction listings from IronPlanet with condition, hours, and bid history.
- [Petco Scraper](https://apify.com/parseforge/petco-scraper) - Collect pet food and supply product data from Petco, including availability and breed filters.
- [BizBuySell Scraper](https://apify.com/parseforge/bizbuysell-scraper-v2) - Gather business for sale listings with asking price, revenue, cash flow, and industry from BizBuySell.
- [FINRA BrokerCheck Scraper](https://apify.com/parseforge/finra-brokercheck-scraper) - Retrieve broker and firm registration data from FINRA's public database for financial due diligence.
- [Copart Public Search Scraper](https://apify.com/parseforge/copart-public-search-scraper) - Pull vehicle and equipment auction data from Copart, including lot details, damage type, and sale prices.

Check out our full range of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and run your first Sysco product search in minutes.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> **This tool is independent and not affiliated with, endorsed by, or sponsored by Sysco Corporation or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.**

# Actor input Schema

## `searchQuery` (type: `string`):

Search term to find products (e.g. 'chicken', 'beef', 'produce', 'pasta').

## `zipCode` (type: `string`):

US zip code that determines your regional Sysco distribution center. Different zip codes return different regional catalogs and availability data (e.g. 10001=NYC, 90001=LA, 60601=Chicago).

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

Free users: Limited to 100. Paid users: Optional, max 1,000,000.

## `categoryId` (type: `string`):

Filter by Sysco category ID to narrow results to a specific food category (e.g. '5' for Poultry, '1' for Beef).

## `brandId` (type: `string`):

Filter by brand ID to restrict results to a specific brand (e.g. 'SYS CLS' for Sysco Classic, 'SYS IMP' for Sysco Imperial).

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between page requests. Increase if you encounter rate limiting.

## Actor input object example

```json
{
  "searchQuery": "chicken",
  "zipCode": "10001",
  "maxItems": 10,
  "requestDelayMs": 0
}
```

# Actor output Schema

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

Dataset with scraped Sysco product items

# 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 = {
    "searchQuery": "chicken",
    "zipCode": "10001",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/sysco-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 = {
    "searchQuery": "chicken",
    "zipCode": "10001",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/sysco-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 '{
  "searchQuery": "chicken",
  "zipCode": "10001",
  "maxItems": 10
}' |
apify call parseforge/sysco-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sysco Food Service Scraper",
        "description": "Scrape wholesale food products from Sysco by zip code with no account needed. Get 40+ fields per item including pack size, weight, stock status, barcode, images, categories, and real time availability. Filter by brand, category, or search term. Export as JSON, CSV, or Excel.",
        "version": "1.0",
        "x-build-id": "vnR0ewHkuUZmjT6Rg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~sysco-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-sysco-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/parseforge~sysco-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-sysco-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/parseforge~sysco-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-sysco-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search term to find products (e.g. 'chicken', 'beef', 'produce', 'pasta')."
                    },
                    "zipCode": {
                        "title": "Zip Code",
                        "type": "string",
                        "description": "US zip code that determines your regional Sysco distribution center. Different zip codes return different regional catalogs and availability data (e.g. 10001=NYC, 90001=LA, 60601=Chicago).",
                        "default": "10001"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 100. Paid users: Optional, max 1,000,000."
                    },
                    "categoryId": {
                        "title": "Category ID",
                        "type": "string",
                        "description": "Filter by Sysco category ID to narrow results to a specific food category (e.g. '5' for Poultry, '1' for Beef)."
                    },
                    "brandId": {
                        "title": "Brand ID",
                        "type": "string",
                        "description": "Filter by brand ID to restrict results to a specific brand (e.g. 'SYS CLS' for Sysco Classic, 'SYS IMP' for Sysco Imperial)."
                    },
                    "requestDelayMs": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between page requests. Increase if you encounter rate limiting.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
