# Anoprague Artcles Spider (`getdataforme/anoprague-artcles-spider`) Actor

The Anoprague Articles Spider scrapes comprehensive article data from Prague websites, extracting titles, content, metadata, images, and FAQs. Perfect for research, content aggregation, and analyzing transportation, dining, and nightlife trends....

- **URL**: https://apify.com/getdataforme/anoprague-artcles-spider.md
- **Developed by:** [GetDataForMe](https://apify.com/getdataforme) (community)
- **Categories:** AI, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 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.

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

### Description

The Anoprague Articles Spider scrapes comprehensive article data from Prague websites, extracting titles, content, metadata, images, and FAQs. Perfect for research, content aggregation, and analyzing transportation, dining, and nightlife trends....

---

## Anoprague Articles Spider

### Overview
The Anoprague Articles Spider is a powerful Apify Actor designed to scrape and extract comprehensive article data from Prague-related websites. It efficiently gathers detailed information including titles, excerpts, full content, metadata, and FAQs, making it ideal for content aggregation, research, and analysis. This tool delivers high-quality, structured data to help users stay informed about topics ranging from transportation and dining to nightlife in Prague.

### Features
- **Comprehensive Data Extraction**: Captures full article content, metadata, images, and structured FAQs for in-depth analysis.
- **Flexible Filtering**: Supports article type selection to focus on specific categories like taxis, restaurants, or bars.
- **High-Quality Output**: Provides clean, JSON-formatted data with SEO details, publication dates, and author information.
- **Reliable Performance**: Built for robust scraping with error handling and rate limiting to ensure consistent results.
- **Multilingual Support**: Handles content in multiple languages, including Hebrew, for diverse use cases.
- **Easy Integration**: Outputs data in JSON, CSV, or Excel formats, ready for downstream processing or storage.

### Input Parameters

| Parameter   | Type   | Required | Description | Example |
|-------------|--------|----------|-------------|---------|
| ArticleType | string | No       | Specifies the type of articles to scrape (e.g., "All" for everything, or specific categories like "taxi", "restaurants", "bars"). Defaults to "All" if not provided. | "All" |

### Example Usage

#### Input Configuration
```json
{
  "ArticleType": "restaurants"
}
````

#### Output Example

```json
[
  {
    "id": "3fbdf5cd-7328-4cf2-af27-3cb4205a8e87",
    "slug": "taxi",
    "title": "מוניות בפראג: איך לקחת מונית בלי שיעקצו אותך",
    "excerpt": "גלו טיפים מעשיים לנסיעה במוניות בפראג: איך לבחור מונית אמינה, להימנע מעקיצות, לבדוק מחירים מקומיים ואפליקציות, לחוות בטוחה וחלקה.",
    "content": "<article>\n\n <h1> מוניות בפראג – כל מה שצריך לדעת כדי שלא יעקצו אותך</h1>\n\n <h2>למה לא לקחת מונית רגילה</h2>\n <p>\n במשך שנים רבות סבלו תיירים בפראג מנהגי מוניות שגבו מחירים מופרזים, במיוחד במרכז העיר ובשדה התעופה.\n למערת שהמצב השתפר, ההמלצה הבורורה היא להימנע ממוניות רגילות. ברוב המקומות ובגם במקומיים משתמשים באפליקציות כמו אובר ובולט, שמציעות מחיר קבוע מראש ומונעות כל הפתעות לא נעימות.\n </p>\n\n <h2>מחירים בעיר ובשדה התעופה</h2>\n <p>\n בתוך העיר עולה נסיעה קצרה תעלה לרוב בין 120 ל–200 קרונות, בעוד נסיעה ארוכה יותר תעלה סביב 300–400 קרונות. משדה התעופה למרכז פרוג המחיר עומד על כ–650 קרונות, תלוי בשעה וביום התנועה.\n בשעות הלילה, בסופי שבוע ובתקופות חגים המחירים משתנים לגבוה יותר יחסית.\n </p>\n\n <h2>אובר מול בולט</h2>\n <p>\n שתי האפליקציות פועלות בפרוג, ורוב הבולט יותר. עם זאת, המחירים משתנים בזמן אמת בהתאם לביקוש, ולעתים דווקא אובר יוצאת משתלמת יותר. ההמלצה היא לבדוק את שתי האפליקציות בטלפון ולבחור בהתאם.\n </p>\n\n <h2>תשלום ושירותים נוספים</h2>\n <p>\n אפשר לשלם באשראי דרך האפליקציה או לבחור באפשרויות מזומנות, אבל חשוב להחזיק קרונות צ'כיות. פתיחת משתמש פשוטה: נרשמים עם מספר טלפון ומקבלים קוד אימות. לא חייבים להוסיף כרטיס אשראי – אפשר להתחיל במזומן ולעבור לדיגיטל מאוחר יותר. בנוסף, ניתן לבחור רכבים גדולים יותר לנסיעות קבוצתיות, להזמין נסיעות מתוזמנות לנכים או לקבוע נסיעות מראש.\n </p>\n\n <h2>שקיפות ובטיחות</h2>\n <p>\n האפליקציה מציגה את שם הנהג, מספר הרכב והדגם, כך שקל לוודא שהרכב הנכון. אפשר גם לשתף את המיקום בזמן אמת עם חברים או בני משפחה – תכונה שימושית במיוחד למי שמרגיש פחות בחן בנוח בנסיעות לילה.\n </p>\n\n <h2>לסיכום</h2>\n <p>\n מוניות בפרוג הן אמצעי תחבורה נוח, אבל הדרך המשתלמת והבטוחה להשתמש בהן היא דרך אפליקציות אובר ובולט. הן חוסכות ומבטיחות על מחיר, מבטיחות טוחה וחלקה, ומאפשרות להזמין נסיעות נגישות לכל הצרכים השלכם. כך תוכלו לנוע בעיר בביטחון וליהנות מהחופשה בלי דאגות מיוחדות.\n </p>\n\n</article>",
    "cover_image_url": "https://images.unsplash.com/photo-1556122071-e404eaedb77f?w=600&auto=format&fit=crop&q=60&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxzZWFyY2h8NHx8VEFYSXxlbnwwfHwwfHx8MA%3D%3D",
    "seo_title": "מוניות בפראג – איך לקחת מונית שלא יעקצו אותך",
    "seo_description": "גלו טיפים מעשיים לנסיעה במוניות בפראג: איך לבחור מונית אמינה, להימנע מעקיצות, לבדוק מחירים מקומיים ואפליקציות, לחוות בטוחה וחלקה.",
    "author_name": null,
    "published_at": "2025-09-09T09:52:57.143955+00:00",
    "is_published": true,
    "created_at": "2025-09-09T09:52:57.143955+00:00",
    "updated_at": "2025-09-15T10:24:11.127619+00:00",
    "main": "<p>\nמוניות בפרוג הן נושא שמעסיק תיירים רבים. בעבר נרשמו לא מעט תלונות על נהגי מוניות שגבו מחירים מופרזים מתיירים. היום, רוב המבקרים והמקומיים משתמשים באפליקציות כמו אובר ובולט. הן מציעות מחיר קבוע מראש, מציגות את פרטי הנהג והרכב, ומאפשרות לשלם באשראי או במזומן. כן אפשר להזמין נסיעות לנכים או לקבוע נסיעות מראש. בנוסף, ניתן לבחור רכבים גדולים לנסיעות קבוצתיות, להזמין נסיעות מתוזמנות לנכים או לקבוע נסיעות מראש. כן תוכלו לנוע בעיר בביטחון, בלי הפתעות מיוחדות.\n</p>",
    "faq": [
      {
        "a": "לא מומלץ. מוניות רגילות עלולות לגבות מחירים מופרזים מתיירים. עדיף להשתמש באפליקציות כמו אובר ובולט.",
        "q": "האם כדאי לקחת מונית רגילה?"
      },
      {
        "a": "נסיעה קצרה בעיר עולה לרוב בין 120 ל–200 קרונות. נסיעה ארוכה יותר סביב 300–400 קרונות.",
        "q": "כמה עולה נסיעה בתוך העיר?"
      },
      {
        "a": "המחיר עומד על כ–650 קרונות, תלוי בשעה וביום התנועה.",
        "q": "כמה עולה נסיעה משדה התעופה למרכז פרוג?"
      },
      {
        "a": "בדרך כלל בולט יותר, אבל המחירים משתנים בזמן אמת. לעתים דווקא אובר יוצאת משתלמת יותר. לבדוק את שתי האפליקציות.",
        "q": "מה ההבדל בין אובר לבולט?"
      },
      {
        "a": "אפשר לשלם באשראי דרך האפליקציה או במזומנות, אבל חשוב להחזיק קרונות צ'כיות.",
        "q": "איך משלמים על הנסיעה?"
      },
      {
        "a": "נרשמים עם מספר טלפון ומקבלים קוד אימות. לא חייבים להוסיף כרטיס אשראי – אפשר להתחיל במזומן.",
        "q": "איך פותחים משתמש באפליקציה?"
      },
      {
        "a": "האפליקציה מציגה את שם הנהג, מספר הרכב והדגם. אפשר לשתף את המיקום בזמן אמת עם חברים.",
        "q": "איך יודעים שהרכב בטוח?"
      },
      {
        "a": "ניתן לבחור רכבים גדולים לנסיעות קבוצתיות או להזמין נסיעות מתוזמנות.",
        "q": "איך לשמור על בטיחות בנסיעה?"
      }
    ],
    "actor_id": "A4LRcb0ZacM87ydy1",
    "run_id": "CQ8qSoTGWoqdWHH1N"
  }
]
```

### Use Cases

- **Market Research**: Analyze trends in Prague's tourism, dining, and transportation sectors by aggregating article data.
- **Competitive Intelligence**: Monitor competitor content and pricing strategies in local businesses.
- **Price Monitoring**: Track fare changes for taxis, restaurant menus, or bar specials.
- **Content Aggregation**: Build a database of Prague-related articles for blogs, travel sites, or apps.
- **Academic Research**: Collect data on cultural, economic, or social topics in Prague for studies.
- **Business Automation**: Automate data feeds for travel agencies or content management systems.

### Installation and Usage

1. Search for "Anoprague Articles Spider" in the Apify Store.
2. Click "Try for free" or "Run".
3. Configure input parameters (e.g., set ArticleType to "restaurants").
4. Click "Start" to begin extraction.
5. Monitor progress in the log.
6. Export results in your preferred format (JSON, CSV, Excel).

### Output Format

The Actor outputs an array of JSON objects, each representing an article. Key fields include:

- `id`: Unique identifier.
- `slug`: URL-friendly title.
- `title`: Article headline.
- `excerpt`: Short summary.
- `content`: Full HTML content.
- `cover_image_url`: Image link.
- `seo_title` and `seo_description`: SEO metadata.
- `published_at`, `created_at`, `updated_at`: Timestamps.
- `is_published`: Publication status.
- `main`: Main content snippet.
- `faq`: Array of Q\&A pairs.
- `actor_id` and `run_id`: Apify metadata.

Data is clean and structured for easy parsing.

### Error Handling

The Actor includes built-in error handling for network issues, invalid inputs, or site changes. Check logs for retries or failures. If errors persist, verify input parameters or contact support.

### Rate Limiting and Best Practices

- Respects website rate limits to avoid bans; runs efficiently without overloading servers.
- Best practices: Run during off-peak hours, limit concurrent runs, and monitor usage to stay within Apify quotas.
- For large datasets, use pagination or filter by ArticleType to optimize performance.

### Limitations and Considerations

- Dependent on source website availability; may not work if sites change structure.
- Content in Hebrew; ensure your tools support Unicode.
- Free tier has limits; upgrade for higher volumes.
- Not suitable for real-time scraping; best for batch processing.

### Support

For custom/simplified outputs or bug reports, please contact:

- Email: support@getdataforme.com
- Subject line: "custom support"
- Contact form: https://getdataforme.com/contact/

We're here to help you get the most out of this Actor!

***

# Actor input Schema

## `ArticleType` (type: `string`):

The article type for the spider.

## Actor input object example

```json
{
  "ArticleType": "All"
}
```

# Actor output Schema

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

Scraped data items from dataset

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("getdataforme/anoprague-artcles-spider").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("getdataforme/anoprague-artcles-spider").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 '{}' |
apify call getdataforme/anoprague-artcles-spider --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Anoprague Artcles Spider",
        "description": "The Anoprague Articles Spider scrapes comprehensive article data from Prague websites, extracting titles, content, metadata, images, and FAQs. Perfect for research, content aggregation, and analyzing transportation, dining, and nightlife trends....",
        "version": "0.0",
        "x-build-id": "1EfW5C3LtGschFRkg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getdataforme~anoprague-artcles-spider/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getdataforme-anoprague-artcles-spider",
                "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/getdataforme~anoprague-artcles-spider/runs": {
            "post": {
                "operationId": "runs-sync-getdataforme-anoprague-artcles-spider",
                "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/getdataforme~anoprague-artcles-spider/run-sync": {
            "post": {
                "operationId": "run-sync-getdataforme-anoprague-artcles-spider",
                "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": {
                    "ArticleType": {
                        "title": "Article Type",
                        "type": "string",
                        "description": "The article type for the spider.",
                        "default": "All"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
