# Facebook Video Transcript Extractor (`scrapepilotapi/facebook-video-transcript-extractor`) Actor

Extract transcripts from Facebook videos by analyzing video pages and making GraphQL requests to Facebook's API.

- **URL**: https://apify.com/scrapepilotapi/facebook-video-transcript-extractor.md
- **Developed by:** [ScrapePilot](https://apify.com/scrapepilotapi) (community)
- **Categories:** Automation, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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

### Facebook Video Transcript Extractor

Facebook Video Transcript Extractor is a fast, reliable Apify actor that converts public Facebook videos into clean, downloadable text. It analyzes video pages and makes GraphQL requests to extract available captions/transcripts — ideal for teams who need a Facebook video transcript downloader to repurpose content, improve accessibility, and run large-scale content analysis. Built for marketers, developers, data analysts, and researchers, it helps you download Facebook video transcripts at scale and integrate them into your workflows.

### What data / output can you get?

Below are the exact JSON fields this actor saves to the Apify dataset. You can export results in JSON, CSV, or Excel from the Apify platform.

| Data type | Description | Example value |
| --- | --- | --- |
| url | Source URL of the Facebook video being processed | https://www.facebook.com/mrbeast/videos/546259055092102 |
| transcript | Extracted transcript/captions text found in Facebook’s response | This is your money. How much of it do you want? I'm taking my share... |
| error | Error details if extraction fails or no transcript is found; null on success | No transcript found in the response |
| timestamp | Unix epoch timestamp (seconds) when the item was processed | 1761496105.9149563 |

Note: The actor returns plain text transcript content found in Facebook’s data. If a transcript isn’t available for a video, transcript will be null and error will contain a descriptive message. Use Apify’s dataset viewer to export your results to JSON, CSV, or Excel.

### Key features

- ⚡ Dynamic GraphQL extraction
  Extracts available captions/transcripts by calling Facebook’s GraphQL endpoint with robust parsing and cleanup for readable text.

- 🔁 Smart proxy fallback logic
  Starts with no proxy, then automatically falls back to Apify datacenter proxy, and then to residential proxy with up to 3 retries — improving success rates against blocks.

- 📦 Batch processing
  Feed multiple Facebook video URLs in one run to download captions from Facebook videos at scale.

- 🧪 Reliable retry strategy
  Implements multiple retries for both page fetches and API requests to improve stability under varying network conditions.

- 🧩 Developer-friendly JSON
  Outputs structured JSON fields (url, transcript, error, timestamp) for easy automation and integration with your data pipelines.

- 🔐 No login required
  Works on publicly available Facebook video pages without cookies or account authentication.

- 🌐 Apify-native infrastructure
  Runs on the Apify platform with dataset storage and export tools — ideal for integrating with automation stacks and downstream analytics.

### How to use Facebook Video Transcript Extractor — step by step

1. Create or log in to your Apify account.
2. Open the Facebook Video Transcript Extractor actor in the Apify Console.
3. Add input data:
   - Paste one or more Facebook video URLs into urls (e.g., https://www.facebook.com/{page}/videos/{id}).
   - Optional: Configure proxyConfiguration to use Apify Proxy for higher success rates.
   - Note: The keyword field exists in the schema but is not implemented for searching yet.
4. Configure proxy settings (recommended):
   - Set proxyConfiguration.useApifyProxy to true for automatic fallback from datacenter to residential proxy if needed.
5. Start the run:
   - The actor processes each URL, fetches the page, extracts the video_id, calls Facebook’s GraphQL API, and parses available transcript text.
6. Monitor progress:
   - Results for each video are pushed incrementally to the run’s dataset with transcript or error details.
7. Download results:
   - Open the run’s dataset and export to JSON, CSV, or Excel for analysis or import into your systems.

Pro tip: Use the Apify API to trigger runs programmatically and pipe dataset exports into your data warehouse or NLP pipeline to convert Facebook video to text at scale.

### Use cases

| Use case name | Description |
| --- | --- |
| Marketing — Content repurposing | Turn Facebook video captions into blog drafts, social captions, and newsletters for faster content production. |
| SEO — Keyword extraction | Analyze transcripts to surface keyword-rich phrases and improve on-page optimization. |
| Accessibility — Caption availability | Provide text alternatives for public videos to improve accessibility and compliance. |
| Media & News — Fast transcripts | Quickly extract statements from public videos for coverage and editorial workflows. |
| Competitive research — Topic analysis | Aggregate transcripts to study competitors’ messaging, themes, and trends over time. |
| Academic research — Dataset creation | Build corpora from public videos for topic modeling, sentiment, or social trend analysis. |
| Data engineering — Pipeline integration | Automate dataset exports and downstream processing in ETL/ELT workflows or LLM pipelines. |

### Why choose Facebook Video Transcript Extractor?

Built for precision and reliability, this actor focuses on extracting available captions/transcripts from public Facebook videos without logins or manual work.

- ✅ Accuracy-first parsing: Cleans and normalizes transcript text for easier downstream analysis.
- 🔄 Robust fallback & retries: No-proxy → datacenter → residential, plus up to 3 residential retries.
- 📈 Scales with your workload: Processes many video URLs in one run for bulk transcript extraction.
- 💻 Developer-ready: Clean JSON output designed for pipelines and integrations.
- 🛡️ Safe & ethical: Targets publicly available data and avoids authenticated/private content.
- 💸 Cost-effective: Runs on Apify infrastructure with dataset export capabilities.
- 🧰 Better than extensions: Avoids brittle browser plugins and unstable local setups with a production-ready cloud actor.

Bottom line: If you need a dependable Facebook video captions extractor for automation workflows, this actor is built to run at scale.

### Is it legal / ethical to use Facebook Video Transcript Extractor?

Yes — when used responsibly. This actor extracts publicly available transcript/caption data from Facebook video pages and does not access private or authenticated content.

Guidelines for compliant use:
- Only process public videos you’re authorized to analyze.
- Review and respect Facebook’s Terms of Service.
- Follow applicable data protection laws (e.g., GDPR, CCPA).
- Do not use data for spam or abusive activities.
- Consult your legal team for edge cases and jurisdiction-specific questions.

### Input parameters & output format

#### Example JSON input
```json
{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/4141502542759187",
    "https://www.facebook.com/100044280796927/videos/2301741263587145"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

Input fields (from the schema):

- urls
  - Type: array of string
  - Description: Array of Facebook video URLs to extract transcripts from
  - Default: not set (the UI shows sample prefill URLs)
  - Required: no

- keyword
  - Type: string
  - Description: Keyword to search for Facebook videos (alternative to URLs)
  - Default: "" (empty string)
  - Required: no
  - Note: Keyword search is not implemented yet in the current version (the actor logs a warning and returns if only keyword is provided).

- sort\_order
  - Type: string (enum: "relevance" | "date" | "views")
  - Description: Sort order for search results
  - Default: not set
  - Required: no

- max\_comments
  - Type: integer (minimum: 1, maximum: 1000)
  - Description: Maximum number of comments to extract
  - Default: not set
  - Required: no
  - Note: Not used by the current extraction flow.

- proxyConfiguration
  - Type: object
  - Description: Configure proxy settings for the actor
  - Default: {"useApifyProxy": false} if not provided
  - Required: no

#### Example JSON output

```json
[
  {
    "url": "https://www.facebook.com/mrbeast/videos/546259055092102",
    "transcript": "This is your money. How much of it do you want? I'm taking my share, 1 hundredthousand. Okay. 10 people said they trusted me. You have the opportunity right now to take a million dollars. Absolutely not. They won't know. Uh",
    "error": null,
    "timestamp": 1761496105.9149563
  }
]
```

Field notes:

- transcript may be null when Facebook doesn’t provide captions/transcripts for the video.
- error contains a descriptive message on failure (e.g., “No transcript found in the response”); it is null on success.
- timestamp is the processing time recorded in seconds since the Unix epoch.

### Related tools

| Category | Tool |
| --- | --- |
| Facebook pages | [Facebook Page Scraper](https://apify.com/scraper-engine/facebook-page-scraper) |
| Facebook reels | [Facebook Reels Scraper](https://apify.com/scraper-engine/facebook-reels-scraper) |
| Facebook videos | [Facebook Videos Scraper](https://apify.com/scraper-engine/facebook-videos-scraper) |

### FAQ

#### How do I get a transcript of a Facebook video?

Paste one or more public Facebook video URLs into urls and run the actor. If Facebook provides captions/transcripts for the video, the tool will extract and output them as plain text.

#### Do I need to log in or provide cookies?

No. The actor works with publicly available videos and does not require login or cookies.

#### Can I download SRT files?

No. The actor outputs the transcript as a single plain-text string (transcript). It does not generate SRT/VTT files. You can convert the text to SRT format externally if needed.

#### Does it work with Facebook Reels or Live videos?

The actor targets Facebook video URLs that contain /videos/{id}. Reels or other URL formats may not be supported. Ensure your input URLs follow the /videos/{id} pattern.

#### Can I process multiple videos at once?

Yes. Provide an array of video URLs in urls to run batch extraction in a single execution.

#### What if a transcript isn’t available?

If Facebook doesn’t provide a transcript/captions for a given video, transcript will be null and error will include a message such as “No transcript found in the response.”

#### How do proxies and retries work?

The actor starts with no proxy. On blocks or failures, it automatically falls back to Apify datacenter proxy, then to residential proxy with up to 3 residential retries. It also retries requests to improve reliability.

#### Is there a free trial?

Yes. The listing includes a 120‑minute trial period on Apify, which you can use to test before subscribing. Check the Apify actor page for current pricing details.

### Closing CTA / Final thoughts

Facebook Video Transcript Extractor is built to extract available captions/transcripts from public Facebook videos at scale. It delivers clean JSON output, robust proxy fallback, and batch processing so marketers, researchers, analysts, and developers can export Facebook video captions, run text analysis, and integrate results into automation pipelines. Use the Apify API and dataset exports to connect this Facebook video transcript downloader to your workflows — start extracting smarter, structured transcript data from Facebook today.

# Actor input Schema

## `urls` (type: `array`):

Array of Facebook video URLs to extract transcripts from

## `keyword` (type: `string`):

Keyword to search for Facebook videos (alternative to URLs)

## `sort_order` (type: `string`):

Sort order for search results

## `max_comments` (type: `integer`):

Maximum number of comments to extract

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

Configure proxy settings for the actor

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "https://www.facebook.com/100044280796927/videos/4141502542759187"
  ]
}
```

# 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 = {
    "urls": [
        "https://www.facebook.com/100044280796927/videos/2301741263587145",
        "https://www.facebook.com/100044280796927/videos/4141502542759187"
    ],
    "keyword": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilotapi/facebook-video-transcript-extractor").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 = {
    "urls": [
        "https://www.facebook.com/100044280796927/videos/2301741263587145",
        "https://www.facebook.com/100044280796927/videos/4141502542759187",
    ],
    "keyword": "",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilotapi/facebook-video-transcript-extractor").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 '{
  "urls": [
    "https://www.facebook.com/100044280796927/videos/2301741263587145",
    "https://www.facebook.com/100044280796927/videos/4141502542759187"
  ],
  "keyword": ""
}' |
apify call scrapepilotapi/facebook-video-transcript-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapepilotapi/facebook-video-transcript-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Video Transcript Extractor",
        "description": "Extract transcripts from Facebook videos by analyzing video pages and making GraphQL requests to Facebook's API.",
        "version": "1.0",
        "x-build-id": "SFRm3F0CSQ6Q801Lg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilotapi~facebook-video-transcript-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilotapi-facebook-video-transcript-extractor",
                "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/scrapepilotapi~facebook-video-transcript-extractor/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilotapi-facebook-video-transcript-extractor",
                "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/scrapepilotapi~facebook-video-transcript-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilotapi-facebook-video-transcript-extractor",
                "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": {
                    "urls": {
                        "title": "Facebook Video URLs",
                        "type": "array",
                        "description": "Array of Facebook video URLs to extract transcripts from",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Keyword to search for Facebook videos (alternative to URLs)"
                    },
                    "sort_order": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "date",
                            "views"
                        ],
                        "type": "string",
                        "description": "Sort order for search results"
                    },
                    "max_comments": {
                        "title": "Maximum Comments",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of comments to extract"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings for the 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
