# Summits Profile Scraper (`scraperoka/summits-profile-scraper`) Actor

🚀 Summits Profile Scraper extracts detailed professional profiles from Summits—names, titles, bios, contacts & more. Ideal for B2B lead gen, sales outreach & targeted research. ⚡ Fast, efficient, SEO-friendly data capture for growth!

- **URL**: https://apify.com/scraperoka/summits-profile-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Summits Profile Scraper 🚀

Manually visiting property pages to collect details like price, area, and agent contacts wastes hours you don’t have. **Summits Profile Scraper** extracts property listing information and agent details from Summit.co.nz in bulk. The **Summits profile scraper** (and **Summits user profile scraper**) output is ideal for marketers, recruiters, and growth teams looking to build a contact-ready lead list at speed—processing multiple listings into usable records in minutes.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "productTitle": "Auckland CBD Apartment",
  "area": "85m² (approx.)",
  "price": "$895,000",
  "description": "Modern apartment with bright living spaces...\n\nKey features:\n• Open-plan layout\n• Close to transport\n• Stylish finishes",
  "agents": [
    {
      "name": "Jane Smith",
      "role": "Sales Consultant",
      "profile": "https://summit.co.nz/about/our-team/meet-our-team/jane-smith",
      "phones": ["(09) 123 4567"]
    }
  ],
  "url": "https://summit.co.nz/buy/listings/17145"
}
````

| Field | Type | What It Tells You |
|---|---|---|
| `productTitle` | string | The listing title you can use to identify the property instantly |
| `area` | string | The area value shown on the listing, useful for filtering and segmentation |
| `price` | string | The displayed price for quick qualification in your pipeline |
| `description` | string | The listing description text, ready for research, CRM notes, or tagging |
| `agents` | array | Agent contact blocks linked to the listing |
| `agents[].name` | string | Agent name for personalized outreach and team assignment |
| `agents[].role` | string | Agent role/title to route leads to the right specialist |
| `agents[].profile` | string | A direct link to the agent’s profile page for verification |
| `agents[].phones` | array | Phone numbers associated with the agent (when present) |
| `url` | string | The original listing URL so you can audit source context later |
| `status` | n/a | Not returned by this actor; if a listing fails to fetch, no record is pushed |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Summits Profile Scraper?

There are a lot of ways to pull data from real estate listing sources — here’s what sets **Summits Profile Scraper** apart for **Summits data scraper** use cases.

#### Listing-first extraction (property + agent details)

Instead of only collecting listing text, Summits Profile Scraper also extracts agent information linked from the listing page. That means your **Summits contact scraper** workflow can start with listings and end with outreach-ready person details.

#### Clean, structured output for downstream tools

The actor returns consistent JSON objects with clear fields like `productTitle`, `price`, `area`, `description`, and an `agents` array. This makes **Summits profile extraction tool** output easy to load into spreadsheets, CRMs, or analysis pipelines.

#### Resilient scraping with practical failure handling

If a page can’t be fetched (for example, a non-200 response), the actor logs a warning and returns `None` for that URL—so you avoid half-baked records. Each listing is processed with a short delay between requests to help keep runs stable.

#### Agent contact blocks included per listing

Agent details are returned as structured entries containing `name`, `role`, `profile`, and `phones`. This supports **Summits lead scraper** workflows where you need both property context and the people behind it.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```json
{
  "startUrls": [
    { "url": "https://summit.co.nz/buy/listings/17145" }
  ]
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | List of Summit property listing URLs to scrape, provided as `{ "url": "..." }` entries |

***

### Core Capabilities

#### Bulk listing processing from your URL list

Provide multiple `startUrls` and the actor will process each listing page and generate structured results. This makes Summits Profile Scraper useful as a **Summits web scraper for profiles** when you have a shortlist of targets to compile quickly.

#### Complete listing fields (title, area, price, description)

Each pushed record includes `productTitle`, `area`, `price`, and `description`. If you’re building a **Summits person search scraper** style dataset for research, those core fields are ready to use without extra formatting.

#### Agent enrichment with contact details when available

For every listing, the actor collects agent entries into an `agents` array. Each agent object includes `name`, `role`, `profile`, and `phones` (when phone links exist), which helps power **Summits email scraper**-adjacent prospecting workflows—even when you only need phone contacts.

#### Source traceability with `url` and profile links

Every result includes the original listing `url`, and each agent includes a `profile` link. That helps your team verify provenance and keep records auditable for later review.

#### Dataset writing as results are ready

As each listing is processed, the actor pushes the extracted object into the Apify dataset using `Actor.push_data(...)` with `charged_event_name="result"`. This supports large runs because you can stop anytime and still keep the records already captured.

***

### Who Gets the Most Out of This

Here's how different teams put Summits Profile Scraper to work:

**Real estate marketers and campaign teams** — they start from a set of Summit listings, then build a clean dataset with property context plus agent contacts for faster outreach and better personalization. The outcome is a ready-to-use lead table with listing details and agent blocks per property.

**Sales development and lead generation teams** — they use the structured `price`, `area`, and `agents[].role` fields to qualify quickly and route leads to the right specialists. The outcome is a faster pipeline build from a list of property URLs.

**Recruiters and talent coordinators** — they can use the agent `name`, `role`, and `profile` links to compile lists of people associated with specific listings. The outcome is simplified research and consistent person records gathered from publicly visible pages.

**Freelance researchers and analysts** — they transform extracted listing descriptions into searchable notes and analyze property attributes using the consistent fields returned. The outcome is a uniform dataset suitable for reporting and segmentation.

**Automation and integration developers** — they call the actor via the Apify workflow, then pass the dataset results downstream into their systems. The outcome is reliable, structured JSON for **Summits account scraper**-style data pipelines (without manual copy/paste).

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Summits Profile Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open Summits Profile Scraper.
2. **Enter your inputs** — add your listing URLs in the `startUrls` field as `{ "url": "https://..." }` entries.
3. **Configure proxy settings** — if you expect larger batches, set up proxy preferences in the Apify UI for better reliability.
4. **Hit Run and watch the live log** — monitor progress and see any fetch warnings as the actor processes each URL.
5. **View results in the dataset tab** — each successful listing produces a JSON record with listing and agent details.
6. **Export as JSON, CSV, or Excel** — download the dataset in your preferred format directly from Apify.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Summits Profile Scraper plugs directly into your existing workflow. Export your dataset as JSON, CSV, or Excel from the Apify dashboard for easy importing into spreadsheets, CRMs, or analysis tools.

You can also use Apify’s automation options such as API access, webhooks, and no-code automation platforms like Zapier or Make to move your scraped results into other systems. For deeper setup details, refer to the Apify documentation for API and automation options: https://apify.com/docs/api

***

### Pricing & Free Trial

Summits Profile Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free allocation for several test runs to validate your `startUrls` and confirm the fields match your needs.

From there, scaling is typically pay-as-you-go based on Apify platform compute units (CU), while you avoid per-row style surprise fees. For current plan options and credits, check pricing on the Apify website: https://apify.com/pricing

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting pressure | Uses request pacing (includes a short delay) to help runs stay stable |
| Proxy support | Designed to work with proxy configuration for more reliable fetching |
| Empty or missing sections | If a field isn’t found, the actor keeps it as an empty string (or an empty list for agents) |
| Non-success fetches | When a listing page doesn’t return success, the actor logs and skips pushing a record for that URL |
| Error visibility | Errors are logged with the URL and error type |

**Limitations:** This actor extracts data from publicly available listing and team profile pages only. If specific details (like agent phone numbers) aren’t present in the visible page content, those fields may be empty.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes—Apify offers a **free tier** so you can run Summits Profile Scraper with credits before you commit to paid usage. Use a small `startUrls` list first to confirm your output fields look right for your **Summits profile scraper** workflow.

#### Do I need to log in to Summits to use this?

No. Summits Profile Scraper operates on publicly accessible pages and does not require a user login. It’s designed for extracting property listing information and agent details from what’s visible to the public.

#### How accurate is the data?

The data accuracy depends on what Summit.co.nz displays on each listing page and on linked agent profile pages. The actor extracts the visible listing fields like `productTitle`, `area`, `price`, and `description`, plus agent blocks found on the page.

#### How many results can I get per run?

There’s no special “result count” input in this actor—your output size is determined by how many `startUrls` you provide. For very large URL lists, plan accordingly and consider proxy configuration for reliability.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor. Because it fetches pages during the run, your dataset reflects the content as it exists at scraping time—there is no built-in scheduling or periodic update feature inside the actor itself.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor only accesses **publicly available data** and does not require login-gated access. It’s still your responsibility to comply with GDPR, CCPA, platform ToS, and any applicable local regulations when storing or using the extracted information.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your Apify dataset as JSON, CSV, or Excel directly from the dashboard, then import it into Google Sheets or your spreadsheet workflow.

#### Can I run this on a schedule automatically?

Yes. Apify supports scheduled runs for actors via its automation features. Once Summits Profile Scraper is configured, you can set it to run automatically on a schedule depending on your research cadence.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically using the Apify API. See https://apify.com/docs/api for API documentation.

#### What happens if the actor hits an error?

If a listing fetch fails (for example, the response status code is not 200), the actor logs a warning and does not push a record for that URL. Errors are also logged with the URL so you can identify which `startUrls` need attention.

***

### Need Help or Have a Request?

Got a question about Summits Profile Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests that improve how **Summits contact scraper** users collect and structure lead data. We also actively maintain this actor based on user feedback—send your ideas like scheduled runs enhancements or additional export-friendly fields.

***

### Disclaimer & Responsible Use

*Summits Profile Scraper is the fastest, most reliable way to extract listing and agent details from publicly available sources — start your free run today.*

This actor collects **publicly available data** only and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any applicable local regulations when using or storing the extracted data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `startUrls` (type: `array`):

List of Summit property listing URLs to scrape.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://summit.co.nz/buy/listings/17145"
    }
  ]
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://summit.co.nz/buy/listings/17145"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/summits-profile-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 = { "startUrls": [{ "url": "https://summit.co.nz/buy/listings/17145" }] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/summits-profile-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 '{
  "startUrls": [
    {
      "url": "https://summit.co.nz/buy/listings/17145"
    }
  ]
}' |
apify call scraperoka/summits-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Summits Profile Scraper",
        "description": "🚀 Summits Profile Scraper extracts detailed professional profiles from Summits—names, titles, bios, contacts & more. Ideal for B2B lead gen, sales outreach & targeted research. ⚡ Fast, efficient, SEO-friendly data capture for growth!",
        "version": "0.1",
        "x-build-id": "owccyO53vYhSXzJP8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~summits-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-summits-profile-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/scraperoka~summits-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-summits-profile-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/scraperoka~summits-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-summits-profile-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Summit property listing URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
