# Scribd Document Search Scraper (`solidcode/scribd-scraper`) Actor

\[💰 $3.5 / 1K] Search Scribd by keyword and export structured metadata for every matching document, book, audiobook, sheet music, or podcast — title, author, type, page count, ratings, views, language, categories, and links.

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

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Scribd Document Search Scraper

Search Scribd by keyword and pull clean, structured metadata for every matching document — title, author, page count, view counts, ratings, language, categories, and direct reader and download links. Run many keywords in a single pass and get one tidy row per document. Built for market researchers, competitive analysts, and content and lead-gen teams who need Scribd document data at scale without paging through search results by hand.

### Why This Scraper?

- **Multi-keyword batch in one run** — pass a list of search terms and each keyword runs as its own search, so you cover an entire topic map in a single pass instead of one query at a time.
- **Up to 10,000 results per keyword** — lifts the typical 100-result search ceiling 100× so you can sweep a whole topic, not just the first page.
- **23 structured fields per document** — id, title, author, type, description, page count, release date, views, reading time, ratings, language, categories, and direct links — every row consumption-ready, no raw markup.
- **Derived 0–5 star rating** — a clean star score computed from each document's community upvotes and downvotes, alongside the raw `upvoteCount`, `downvoteCount`, and `ratingCount`.
- **Author profile URLs for outreach** — every row carries the primary author's name and absolute profile link, plus a full `authors` array with each contributor's id, name, and profile URL.
- **Engagement signals built in** — real view counts (parsed from Scribd's "15K"/"1.2M" shorthand to plain integers) and estimated reading time let you rank documents by popularity, not just relevance.
- **Direct reader and download links** — every row includes the canonical reader URL and a ready-to-use download link when the document is downloadable, so you never have to reconstruct paths.
- **Result-language preference across 21 languages** — bias results toward English, Spanish, Portuguese, French, German, Arabic, Hindi, Japanese, and more so you collect documents in the language your audience reads.
- **Query provenance on every row** — each document carries the exact keyword that surfaced it, so a single mixed dataset stays attributable per search term.

### Use Cases

**Market & Content Research**
- Map how much Scribd content exists around a topic, product, or industry
- Surface the most-viewed and highest-rated documents in a niche
- Track templates, whitepapers, and guides circulating in your space
- Build topic libraries spanning dozens of keywords in one run

**Competitive Analysis**
- See which authors and brands publish the most in your category
- Benchmark engagement (views, ratings) against competing documents
- Monitor new uploads tied to a brand or product name
- Compare document depth by page count across competitors

**Lead Generation & Outreach**
- Collect author profile URLs and names for creator outreach
- Identify prolific publishers in a target vertical
- Build prospect lists from documents matching buyer-intent keywords
- Prioritize outreach by author reach using view counts and ratings

**Academic & Reference**
- Gather reference document metadata across many search terms at once
- Filter your reading list by page count and reading time before opening anything
- Prefer results in a specific language for non-English literature reviews
- Catalog community ratings to triage which documents are worth reading

**Content Curation**
- Power recommendation feeds and resource roundups with fresh metadata
- Enrich an existing content database with views, ratings, and categories
- Curate by category labels Scribd files each document under
- Feed a newsletter or knowledge base with structured document records

### Getting Started

#### Simple — one keyword

```json
{
    "queries": ["business plan template"]
}
````

#### Several keywords, more results each

```json
{
    "queries": ["machine learning", "data science", "neural networks"],
    "maxResultsPerQuery": 250
}
```

#### Advanced — language preference and a deep sweep

```json
{
    "queries": ["recetas de cocina", "plan de negocios"],
    "maxResultsPerQuery": 1000,
    "language": "4"
}
```

### Input Reference

All fields are optional — run with just a keyword and sensible defaults handle the rest.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `queries` | string\[] | `["business plan template"]` | One or more keywords to search on Scribd. Each keyword runs its own search — add several to cover a whole topic in one run. |
| `maxResultsPerQuery` | integer | `100` | How many documents to return per keyword. Set to `0` to fetch every available match. Results arrive in pages of 40, so the final page may slightly overshoot rather than cut off mid-page. |
| `language` | select | `Any language` | Prefer results written in a chosen language — English, Spanish, Portuguese, French, German, Italian, Dutch, Russian, Japanese, Korean, Chinese, Arabic, Hindi, Indonesian, Turkish, Polish, Danish, Romanian, Thai, Swedish, or Czech. Leave on "Any language" for no preference. Coverage depends on how much content Scribd has in that language for your keyword. |

### Output

Each matching document becomes one flat row. Here's a representative result:

```json
{
    "id": "238702049",
    "title": "Sample Business Plan Template",
    "author": "Jane Author",
    "authorUrl": "https://www.scribd.com/user/12345678/jane-author",
    "authors": [
        { "id": 12345678, "name": "Jane Author", "url": "https://www.scribd.com/user/12345678/jane-author" }
    ],
    "type": "document",
    "description": "A complete business plan template covering executive summary, market analysis, and financials...",
    "url": "https://www.scribd.com/document/238702049/Sample-Business-Plan-Template",
    "downloadUrl": "https://www.scribd.com/document_downloads/238702049",
    "imageUrl": "https://imgv2-1-f.scribdassets.com/img/document/238702049/original.jpg",
    "pageCount": 32,
    "releasedAt": "2018-04-12",
    "views": 15000,
    "consumptionTime": 24,
    "isUnlocked": true,
    "rating": 4.5,
    "upvoteCount": 90,
    "downvoteCount": 10,
    "ratingCount": 100,
    "language": "English",
    "languageIso": "en",
    "categories": ["Business", "Templates"],
    "query": "business plan template"
}
```

#### Document Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Scribd document identifier |
| `title` | string | Document title |
| `type` | string | Document type label as classified by Scribd |
| `description` | string | Description or snippet |
| `pageCount` | integer | Number of pages (null for non-paged content) |
| `releasedAt` | string | Publication or upload date |
| `consumptionTime` | integer | Estimated reading time in minutes |
| `isUnlocked` | boolean | Whether the document is freely accessible |
| `categories` | string\[] | Category labels Scribd files the document under |
| `query` | string | The search keyword that surfaced this row |

#### Author Fields

| Field | Type | Description |
|-------|------|-------------|
| `author` | string | Primary author name (may be null) |
| `authorUrl` | string | Primary author profile URL |
| `authors` | object\[] | All contributors, each with `id`, `name`, and profile `url` |

#### Engagement & Ratings

| Field | Type | Description |
|-------|------|-------------|
| `views` | integer | View count, parsed to a plain integer |
| `rating` | number | Derived 0–5 star rating from community votes |
| `upvoteCount` | integer | Number of upvotes |
| `downvoteCount` | integer | Number of downvotes |
| `ratingCount` | integer | Total ratings cast |
| `language` | string | Language name |
| `languageIso` | string | ISO language code |

#### Links & Media

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical Scribd reader URL |
| `downloadUrl` | string | Direct download link when available |
| `imageUrl` | string | Cover thumbnail image URL |

### Tips for Best Results

- **Use specific multi-word phrases** to narrow large topics — a broad single word like "business" returns tens of thousands of loosely related documents, while "small business marketing plan" returns a focused, usable set.
- **Batch related keywords in one run** — the `query` field tags every row with its source keyword, so you can split one mixed dataset back out per term afterward.
- **Start with a small `maxResultsPerQuery`** (40–100) to confirm the results match your intent, then raise it once you're happy with the keywords.
- **Set `maxResultsPerQuery` to 0** only when you genuinely want the full match set — it sweeps deep and is best paired with tight, specific phrases.
- **Treat `language` as a preference, not a hard filter** — for keywords with little Scribd content in a given language, results fall back to the most available language; pair a language with a keyword written in that language for the best hit rate.
- **Rank by `views` and `rating` together** — a high view count with a strong derived star score is the surest sign a document is both popular and well received.
- **Use `pageCount` and `consumptionTime`** to pre-screen depth before opening anything — filter out one-page stubs or zero in on long-form references in seconds.

### Pricing

**From $3.50 per 1,000 results** — undercuts comparable Scribd search scrapers while lifting the result ceiling 100×. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.42 | $0.40 | $0.38 | $0.35 |
| 1,000 | $4.20 | $3.95 | $3.75 | $3.50 |
| 10,000 | $42.00 | $39.50 | $37.50 | $35.00 |
| 100,000 | $420.00 | $395.00 | $375.00 | $350.00 |

A "result" is any document row in the output dataset. The fixed per-run start fee and any platform usage (storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate research, market analysis, content curation, and lead generation. Users are responsible for complying with applicable laws and Scribd's Terms of Service. Only collect publicly available document metadata, respect copyright and authors' rights, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `queries` (type: `array`):

Keywords to search on Scribd (e.g., 'business plan template' or 'machine learning'). Each query produces its own set of results. Add several queries to run them all in one go.

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

How many documents to return for each search query. Set to 0 to collect all available results for the query (capped at 10,000 per keyword). Results are returned in pages of 40, so the final page may slightly overshoot this number rather than be cut off mid-page.

## `language` (type: `string`):

Prefer results in this language. Scribd biases results toward your choice, but coverage depends on how much content exists for each keyword, so some results may still appear in other languages. Choose 'Any language' for no preference.

## Actor input object example

```json
{
  "queries": [
    "business plan template"
  ],
  "maxResultsPerQuery": 100,
  "language": "any"
}
```

# Actor output Schema

## `documents` (type: `string`):

Table of document results with title, author, type, page count, rating, views, and links.

# 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 = {
    "queries": [
        "business plan template"
    ],
    "maxResultsPerQuery": 100,
    "language": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/scribd-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 = {
    "queries": ["business plan template"],
    "maxResultsPerQuery": 100,
    "language": "any",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/scribd-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 '{
  "queries": [
    "business plan template"
  ],
  "maxResultsPerQuery": 100,
  "language": "any"
}' |
apify call solidcode/scribd-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Scribd Document Search Scraper",
        "description": "[💰 $3.5 / 1K] Search Scribd by keyword and export structured metadata for every matching document, book, audiobook, sheet music, or podcast — title, author, type, page count, ratings, views, language, categories, and links.",
        "version": "1.0",
        "x-build-id": "iMgzeaATazLWgoaG3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~scribd-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-scribd-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/solidcode~scribd-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-scribd-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/solidcode~scribd-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-scribd-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Keywords to search on Scribd (e.g., 'business plan template' or 'machine learning'). Each query produces its own set of results. Add several queries to run them all in one go.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum Results per Query",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many documents to return for each search query. Set to 0 to collect all available results for the query (capped at 10,000 per keyword). Results are returned in pages of 40, so the final page may slightly overshoot this number rather than be cut off mid-page.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "any",
                            "1",
                            "4",
                            "13",
                            "5",
                            "9",
                            "8",
                            "16",
                            "14",
                            "3",
                            "7",
                            "6",
                            "11",
                            "99",
                            "84",
                            "78",
                            "89",
                            "10",
                            "17",
                            "60",
                            "93",
                            "70"
                        ],
                        "type": "string",
                        "description": "Prefer results in this language. Scribd biases results toward your choice, but coverage depends on how much content exists for each keyword, so some results may still appear in other languages. Choose 'Any language' for no preference.",
                        "default": "any"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
