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

Summits Profile Scraper extracts attendee and speaker profile data, including names, job titles, companies, bios, social links, contact details, and event information from online summit platforms. Ideal for networking, lead generation, event research, and audience analysis.

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

## Pricing

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

### Summits Profile Scraper 🚀

Scraping Summits property listings manually is slow and doesn’t scale when you need agent details and property context in bulk. **Summits Profile Scraper** automatically extracts key listing fields from Summit property pages, saving you hours of copy-paste work. This Summits profile scraper is great for teams that need a Summits contact scraper or automated Summits profile scraping workflow fast. It’s built for marketing teams, data analysts, and researchers who want structured results from publicly available Summits pages—without slowing down. In a single run, you can process a list of property listing URLs and collect clean records ready for analysis or outreach.

---

### See the Data: Sample Output

Here's a real record from a single run:

```json
{
  "productTitle": "3-bedroom townhouse in Roseneath",
  "area": "Roseneath · Wellington",
  "price": "$1,050,000",
  "description": "Modern townhouse offering ...\n\nFeatures include ...",
  "agents": [
    {
      "name": "Alex Morgan",
      "role": "Sales Consultant",
      "profile": "https://summit.co.nz/about-our-team/meet-our-team/alex-morgan",
      "phones": ["+64 21 123 4567"]
    }
  ],
  "url": "https://summit.co.nz/buy/listings/17145"
}
````

**Output Fields**

| Field | Type | What It Tells You |
|---|---|---|
| `productTitle` | string | The listing title exactly as shown on the page—use it for display, deduping, and content summaries. |
| `area` | string | The listing area text—handy for filtering by region in your dataset. |
| `price` | string | The listing price as displayed—use for segmentation and lead scoring. |
| `description` | string | The listing description content—use as your source text for analysis or enrichment. |
| `agents` | array | A structured list of agent details associated with the listing. |
| `agents[].name` | string | Agent name as shown on the page—use for CRM mapping. |
| `agents[].role` | string | Agent role/title—use for routing leads to the right specialist. |
| `agents[].profile` | string | The agent profile link—use for verification or follow-up research. |
| `agents[].phones` | array | Phone numbers found for each agent—use for direct calling/outreach workflows. |
| `url` | string | The exact listing URL that produced this record—use for traceability and auditing. |
| `status` | not present | This actor returns listing objects; there is no `status` field in the pushed output. |
| `error_message` | not present | This actor logs errors and returns no record for failed fetches; there is no `error_message` field in the pushed output. |

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

***

### Setting It Up

Drop this into your `input.json` and you're ready to go:

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

| Parameter | Required | What It Does |
|---|---|---|
| `startUrls` | ✅ | List of Summit property listing URLs to scrape. |
| ↳ `startUrls[].url` | ✅ | One property listing page URL. |

***

### What It Does

Summits Profile Scraper pulls structured listing and agent details from Summit property listing pages and writes each result into your Apify dataset.

#### Extract listing context with key fields

For each start URL, it captures `productTitle`, `area`, `price`, and the full `description` text from the page so you can analyze properties without manually opening every listing.

#### Build agent contact records per listing

It collects `agents` as an array, including each agent’s `name`, `role`, `profile` link, and `phones` list. This makes it useful as a Summits contact scraper when you need outreach-ready context tied to specific listings.

#### Uses your list of URLs for focused scraping

You control what gets scraped by providing `startUrls`. If you want to scrape Summits profiles for only certain listings, this approach keeps your run targeted and manageable—just like a Summits directory scraper for property pages.

#### Clean, integration-ready JSON output

Results are pushed as consistent JSON objects with the same top-level fields (`productTitle`, `area`, `price`, `description`, `agents`, `url`) so you can load them into your pipelines with minimal cleanup. This also makes Summits profile scraping software-style workflows easier for analysts and automation specialists.

#### Handles fetch failures gracefully

If a listing page cannot be fetched successfully (for example, a non-200 response), that URL is skipped and no output record is pushed for it. This keeps your dataset focused on successful pages, while failures are visible in the actor logs.

Overall, Summits Profile Scraper turns Summit listing pages into structured data you can export, analyze, and reuse—fast.

***

### Why Summits Profile Scraper?

There are plenty of ways to pull data from real estate directories—here’s why Summits Profile Scraper stands out.

#### Faster from URLs to structured records

Instead of manually compiling a spreadsheet from many listings, Summits Profile Scraper processes your `startUrls` and outputs ready-to-use JSON records. That’s especially valuable when you need scrape Summits profiles for multiple properties in one go.

#### Practical output for lead and research workflows

The dataset is designed around the listing plus agent details you actually need (`description` and `agents` with `phones`, `role`, and `profile`). This aligns with how a Summits lead scraper is typically used—linking listings to the people behind them.

#### Reliability-focused request handling

Built-in proxy support and resilience features help keep scraping dependable across multiple requests. This helps you run automated Summits profile scraping jobs without babysitting every step.

***

### Real-World Use Cases

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

**Sales and Business Development Teams**\
A rep gets a batch of Summit listing links from marketing and needs the agent contacts for follow-up. They run Summits Profile Scraper on the provided URLs, then import the `agents` records (including `phones` and `profile`) into their CRM.

**Marketing and Campaign Operations**\
A team is building a market map by area and price bands. After scraping the listings, they filter by `area` and use `price` and `description` for segmentation and campaign planning, backed by structured dataset fields.

**Freelance Researchers and Data Analysts**\
A researcher needs property narrative text and agent metadata in a consistent format for analysis. They scrape multiple Summits property listing URLs, then work directly with `productTitle`, `description`, and `agents` without rewriting a scraper for every new request.

**Automation and Integration Specialists**\
A data engineer wants a repeatable pipeline that ingests property listing data into an internal datastore. They trigger the actor, then store each pushed record keyed by the listing `url` for traceability and downstream enrichment.

**Lead List Building for Property-Adjacent Outreach**\
A marketer is trying to identify who to contact for specific property types. Using the extracted `agents` array, they build a contact shortlist that ties outreach targets to the relevant listing context.

***

### How to Run It

No code required. Here's how to get your first results in under 5 minutes:

1. **Open the actor on Apify**\
   Go to the actor page on [console.apify.com](https://console.apify.com).

2. **Enter your inputs**\
   In the `startUrls` field, add one or more Summit property listing URLs (each as an object with `url`).

3. **Configure proxy settings (recommended)**\
   Enable proxy settings if you want improved reliability for larger URL lists.

4. **Start the run and watch the live log**\
   The actor logs which URL is being scraped, and skips pages it can’t fetch.

5. **Open the Dataset tab to see results**\
   As each page is processed, listing records appear with `productTitle`, `area`, `price`, `description`, `agents`, and `url`.

6. **Export in your preferred format**\
   Download your dataset as JSON, CSV, or Excel directly from the Apify dashboard.

The whole setup takes under 5 minutes — results start appearing within seconds of launch.

***

### Export & Integration Options

Once your data is collected, Summits Profile Scraper fits directly into your existing workflow.

You can export your dataset from the Apify dashboard as JSON, CSV, or Excel, which is ideal for analysis, reporting, or creating a clean lead spreadsheet.

You can also connect results to your tooling using Apify’s API and automations (for example, no-code platforms like Zapier/Make) so your pipeline can ingest new runs automatically. If you need run-to-run automation, you can schedule the actor to run on a cron-like schedule as supported by Apify.

For depth on integrations, refer to the Apify documentation for dataset export, API access, and automation options.

***

### Pricing

Summits Profile Scraper runs on Apify, which includes a **free tier** — no credit card needed to start. You’ll get `$5 platform credits on sign-up`, which is typically enough for several real test runs.

For ongoing work, billing is **pay-as-you-go** based on Actor compute units (CU), so you only pay when you run. If you scale up to heavier workloads, review Apify’s subscription plans on the pricing page.

Start free at [apify.com](https://apify.com) — scale up when you need to.

***

### Reliability & Limitations

| What We Handle | How |
|---|---|
| Rate limiting concerns | Uses request management and pacing to stay stable across multiple pages. |
| Network/proxy reliability | Built-in proxy support helps keep requests dependable. |
| Page fetch failures | If a page can’t be fetched (for example, non-200 responses), that URL is skipped. |
| Partial progress | Successfully scraped listings are pushed to the dataset as they complete. |
| Unexpected page structure | Parsing is resilient; missing fields result in empty strings for top-level fields and fewer/empty `agents` entries. |

**Limitations:** This actor extracts details from publicly accessible listing pages. It does not access private or login-gated content, and if an agent section is absent or contact details are not present, the corresponding fields (like `phones`) may be empty.

For enterprise-scale needs or custom configurations, reach out and we’ll help.

***

### Frequently Asked Questions

#### Is there a free plan?

Yes. Apify offers a free tier with monthly usage credits so you can test Summits Profile Scraper without paying upfront.

#### Do I need to log in or create an account on Summits to use this?

No. Summits Profile Scraper works with publicly accessible property listing pages you provide as `startUrls`.

#### How accurate is the extracted data?

The output is as accurate as what’s displayed on the listing pages at the time of scraping. If a listing shows certain fields (like `price` or agent `phones`), those are captured; if not, the corresponding fields may be empty.

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

You can scrape as many `startUrls` as you include in your input. Any practical limits depend on your Apify run settings and the size of the URL list you submit.

#### How fresh is the data?

Data is captured at the moment each URL is scraped. If listing details change, running the actor again will reflect the latest page content.

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

Summits Profile Scraper is designed to work with **publicly available data**. You’re responsible for using, storing, and processing the extracted information in line with GDPR, CCPA, and applicable laws and platform terms.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel from the dashboard. From there, you can import into tools like Excel or Google Sheets.

#### Can I schedule this to run automatically?

Yes. If you use Apify scheduling features, you can run Summits Profile Scraper automatically on a recurring schedule.

#### Can I access results via the API?

Yes. Apify supports programmatic access to actor runs and datasets via the Apify API, so you can integrate Summits Profile Scraper into your systems.

#### What happens when the actor encounters an error?

If a listing URL can’t be fetched successfully, the actor skips pushing a record for that URL and logs details in the run logs. Successfully scraped pages still appear in your dataset.

***

### Get Help & Use Responsibly

Got a question about Summits Profile Scraper or a feature you'd like added? Reach out at <dataforleads@gmail.com>. We welcome feedback and we actively maintain this actor based on user needs.

***

**publicly available data**: Summits Profile Scraper extracts information from publicly available listing pages. It does not access private accounts, login-gated pages, or password-protected content. You’re responsible for complying with GDPR, CCPA, and any applicable platform terms when using the 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("scrapedrift/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("scrapedrift/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 scrapedrift/summits-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapedrift/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 attendee and speaker profile data, including names, job titles, companies, bios, social links, contact details, and event information from online summit platforms. Ideal for networking, lead generation, event research, and audience analysis.",
        "version": "0.1",
        "x-build-id": "cvcZbjszuSEPIX2v7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapedrift~summits-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapedrift-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/scrapedrift~summits-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapedrift-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/scrapedrift~summits-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapedrift-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
