# Soundcloud Email Scraper (`scraperoka/soundcloud-email-scraper`) Actor

🎧 Soundcloud Email Scraper extracts creator emails from SoundCloud profiles & tracks. 📩 Perfect for outreach, lead gen & marketing research. ⚡ Fast, accurate, saves time—built for professionals who need verified contact info.

- **URL**: https://apify.com/scraperoka/soundcloud-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Automation, Social media
- **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

### SoundCloud Email Scraper 🎯 — Find Outreach Emails from SoundCloud Profiles

Manually collecting contact emails from SoundCloud creators is slow and inconsistent—**SoundCloud Email Scraper** automates the process for SoundCloud email finder and SoundCloud email scraping at scale. It’s ideal for marketers, recruiters, and growth teams who need SoundCloud outreach email scraper results fast. In a single run, you can gather thousands of prospects into a structured dataset for your next campaign.

---

### What You Get: Sample Output

Here's a sample record from a single run:

```json
[
  {
    "keyword": "marketing",
    "title": "SoundCloud · Example Profile Title",
    "description": "Example publicly available text that includes john@example.com and additional context.",
    "url": "https://soundcloud.com/example-profile",
    "email": "john@example.com"
  },
  {
    "keyword": "john",
    "title": "SoundCloud · Another Profile Title",
    "description": "Example publicly available text that includes contact@artistdomain.com.",
    "url": "https://soundcloud.com/another-profile",
    "email": "contact@artistdomain.com"
  }
]
````

| Field | Type | What It Tells You |
|---|---|---|
| `keyword` | string | Which keyword you used to find this SoundCloud artist email candidate |
| `title` | string | The title text associated with the match (useful for quick relevance checks) |
| `description` | string | The extracted publicly available text where the email was detected |
| `url` | string | The related link you can use to verify the context in your workflow |
| `email` | string | The extracted email address matching your `customDomains` filters |

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

***

### Why SoundCloud Email Scraper?

There are a lot of ways to pull data from SoundCloud for outreach—here’s what sets **SoundCloud Email Scraper** apart.

#### Keyword-driven email harvesting

Use your own `keywords` list to drive what gets matched, making this SoundCloud user email scraper a practical tool for targeted SoundCloud prospecting email list building.

#### Custom email-domain filtering

Provide `customDomains` (like `@gmail.com`) so you focus on the email addresses that matter most for your outreach workflow.

#### Resilient scraping with fallbacks

If the first attempt doesn’t produce results, the actor can switch to a fallback approach to help you keep results coming—useful when running SoundCloud email leads jobs at scale.

#### Clear, integration-ready output

Every match is pushed as a structured JSON object containing `keyword`, `title`, `description`, `url`, and `email`, so it’s easy to import into your CRM, spreadsheets, or downstream automation.

***

### Configuring Your Run

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

```json
{
  "keywords": ["john", "marketing"],
  "location": "United States",
  "platform": "SoundCloud",
  "customDomains": ["@gmail.com"],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for when looking for SoundCloud email finder candidates |
| `location` | ⬜ | Filters results using a single location string (leave empty to not apply a location filter) |
| `platform` | ⬜ | Select platform (the only supported option is `SoundCloud`) |
| `customDomains` | ⬜ | Limits email extraction to the domains you specify (for example `@gmail.com`) |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor (helps with reliable scraping) |
| ↳ `proxy support` | ⬜ | When set, routes requests through Apify Proxy |

***

### Core Capabilities

#### SoundCloud-focused email extraction

SoundCloud Email Scraper is built specifically to extract emails connected to publicly available SoundCloud content, making it a focused SoundCloud contact email scraper for prospecting workflows.

#### Flexible targeting with keywords and location

Combine multiple `keywords` with an optional `location` string to narrow results. This is especially useful when you’re building a SoundCloud influencer email scraper shortlist by theme or audience.

#### Email-domain control for cleaner lead lists

By using `customDomains`, you can prevent irrelevant emails from polluting your dataset. It’s a simple way to keep your SoundCloud email harvesting aligned with your outreach preferences.

#### Dataset output ready for downstream use

Each extracted match is collected into a single output dataset with consistent fields (`keyword`, `title`, `description`, `url`, `email`) so analysts and marketers can quickly filter, deduplicate, and enrich.

#### Automation-friendly runs at scale

Run the actor repeatedly with different keyword sets to grow a SoundCloud outreach email scraper library over time—ideal for ongoing campaigns and list-refresh workflows.

***

### Who Gets the Most Out of This

Here’s how different teams put SoundCloud Email Scraper to work:

**Growth and Performance Marketers** — Use keyword-based runs to build a SoundCloud marketing email list scraper dataset for campaign audiences, then import results into your outreach tooling to speed up testing and iteration.

**Sales Development Teams** — Feed a campaign keyword set (and optionally `customDomains`) to quickly assemble a prospecting list and reduce the time spent manually tracking down SoundCloud artist email contacts.

**Recruiters and Talent Scouts** — Identify creator niches and get contact emails associated with relevant SoundCloud profiles, helping you reach out faster when evaluating collaborators.

**Freelance Researchers** — Generate reproducible datasets for client deliverables by running consistent keyword searches and exporting results for review and analysis.

**Data Engineers and Automation Specialists** — Treat the actor as a repeatable data source: trigger runs via the Apify workflow and feed structured email records into your pipelines without manual reformatting.

***

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

No coding needed. Here's how to run SoundCloud Email Scraper from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and find SoundCloud Email Scraper.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, and `proxyConfiguration`.
3. **Configure proxy settings** — choose proxy preferences in `proxyConfiguration` for more reliable scraping runs.
4. **Hit Run and watch the live log** — monitor progress and any extraction messages in real time.
5. **View results in the dataset tab** — each extracted record is included in the run output.
6. **Export as JSON, CSV, or Excel** — download the dataset for use in your CRM, spreadsheets, or analysis.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, SoundCloud Email Scraper plugs directly into your existing workflow.

You can export results from Apify’s dataset tab in formats like **JSON, CSV, or Excel**, which makes it easy to move SoundCloud email leads into BI tools or spreadsheets.

You can also use Apify’s ecosystem (including **API access**, **webhooks**, and **Zapier / Make automations**) to push results into downstream systems programmatically—see Apify documentation for the latest options: https://apify.com/docs/api

***

### Pricing & Free Trial

SoundCloud Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You’ll typically get a small amount of platform credit to test extraction workflows before scaling up. For ongoing use, pricing is pay-as-you-go based on Apify platform compute usage, with subscription options available for heavier workloads. Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting pressure | The run uses built-in resilience to keep scraping steady |
| Proxy reliability | Built-in proxy support for more dependable requests |
| Empty result scenarios | Includes fallback behavior when no emails are found initially |
| Output consistency | Extracted matches are returned with the same dataset field names |

**Limitations:** This actor relies on publicly available sources and extracts emails only when they appear in those sources. If a creator doesn’t publish an email in publicly visible content that matches your `customDomains`, you may get fewer or no results for that keyword.

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

***

### Frequently Asked Questions

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

Yes. Apify provides a free tier with test credits so you can try SoundCloud Email Scraper before committing to bigger runs.

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

No. This actor is designed to work with publicly available web data, without requiring a SoundCloud login.

#### How accurate is the data?

The accuracy depends on what contact details are publicly available. The actor extracts emails when they match your `customDomains` filter and are found in the extracted publicly available text.

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

There’s no single fixed number in the input schema. Results depend on your `keywords`, optional `location`, and how many matching public pages contain emails for your selected `customDomains`.

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

Data freshness depends on when the actor is run. Run it again with the same keywords to refresh your SoundCloud email scraping dataset.

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

The actor accesses **publicly available data** only, but compliance is ultimately your responsibility. Review GDPR/CCPA and any applicable platform rules before using or storing the extracted emails.

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

Yes. You can export your Apify dataset as JSON, CSV, or Excel directly from the Apify dashboard, and then import into Google Sheets or your reporting stack.

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

Yes. You can schedule actor runs using Apify’s automation features so your SoundCloud contact email scraper runs periodically.

#### Can I access this via API?

Yes. You can integrate with Apify through API access to pull run results programmatically. See: https://apify.com/docs/api

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

If a particular request fails, the actor logs the error and continues processing other keyword/domain combinations where possible. Results that were successfully extracted still get pushed to the dataset.

***

### Need Help or Have a Request?

Got a question about SoundCloud Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like webhook notifications on completion and more export-friendly formats for faster CRM import. The actor is actively maintained and improved based on user feedback.

***

### Disclaimer & Responsible Use

*SoundCloud Email Scraper is the fastest, most reliable way to extract outreach emails from publicly available SoundCloud content — start your free run today.*

This actor collects **publicly available data** 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 extracted data. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords to search for.

## `location` (type: `string`):

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `customDomains` (type: `array`):

List of custom email domains

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

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "john",
    "marketing"
  ],
  "location": "",
  "platform": "SoundCloud",
  "customDomains": [
    "@gmail.com"
  ]
}
```

# 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 = {
    "keywords": [
        "john",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/soundcloud-email-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 = {
    "keywords": [
        "john",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/soundcloud-email-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 '{
  "keywords": [
    "john",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/soundcloud-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Soundcloud Email Scraper",
        "description": "🎧 Soundcloud Email Scraper extracts creator emails from SoundCloud profiles & tracks. 📩 Perfect for outreach, lead gen & marketing research. ⚡ Fast, accurate, saves time—built for professionals who need verified contact info.",
        "version": "0.0",
        "x-build-id": "aXf5QJfVOlV3beaex"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperoka~soundcloud-email-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperoka-soundcloud-email-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~soundcloud-email-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperoka-soundcloud-email-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~soundcloud-email-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperoka-soundcloud-email-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "A list of keywords to search for.",
                        "default": [
                            "john",
                            "marketing"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location to filter search results.",
                        "default": ""
                    },
                    "platform": {
                        "title": "Platform",
                        "enum": [
                            "SoundCloud"
                        ],
                        "type": "string",
                        "description": "Select platform.",
                        "default": "SoundCloud"
                    },
                    "customDomains": {
                        "title": "Custom Email Domains",
                        "type": "array",
                        "description": "List of custom email domains",
                        "default": [
                            "@gmail.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxies for this Actor."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
