# Regex Helper (`maximedupre/regex-helper`) Actor

Apply named regular expressions to submitted text or an Apify dataset. Get matches by pattern with values, positions, capture groups, and a total match count.

- **URL**: https://apify.com/maximedupre/regex-helper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.01 / 1,000 processed texts

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### 🧩 Find regex matches in a batch of text

Regex Helper is for developers, data teams, and business teams that need structured matches from text. Apply named Python-compatible regular expressions to pasted text or rows in an Apify dataset. Get each match value, its position, capture groups, named groups, and a total match count.

- Pull LinkedIn references from text with the **[LinkedIn Extractor](https://apify.com/maximedupre/regex-helper/examples/linkedin-extractor)** preset.
- Find links in each text with the **[URL Extractor](https://apify.com/maximedupre/regex-helper/examples/url-extractor)** preset.
- Pull phone numbers from a text batch with the **[Phone Number Extractor](https://apify.com/maximedupre/regex-helper/examples/phone-number-extractor)** preset.
- Find email addresses in text with the **[Email Extractor](https://apify.com/maximedupre/regex-helper/examples/email-extractor)** preset.
- Apply your own named patterns with the **[Regex Matcher](https://apify.com/maximedupre/regex-helper/examples/regex-matcher)** preset.

#### 📦 Returned data

The Actor saves one row for each processed text. Matches are grouped by your pattern names. A pattern gets an empty array when it finds no match, so you can still see which patterns were checked.

For each match, you get the full value, zero-based start and end positions, numbered capture groups, and named capture groups. You can ask for every occurrence or only the first occurrence for each pattern in each text.

#### ▶️ Running the Actor

1. Choose **Submitted texts** or **Apify dataset** as the target.
2. Add your text, or choose a dataset and the field that holds its text.
3. Keep the ready-made patterns, or add your own named patterns.
4. Choose all or first match mode and any regex flags.
5. Run the Actor and open the dataset.

The ready-made patterns find emails, phone numbers, URLs, and LinkedIn references. They find text that fits each pattern. They do not prove ownership, identity, or deliverability.

#### 🧾 Input

| Field | Type | What it does |
| --- | --- | --- |
| `target` | string | Chooses text entered in the form or rows from an Apify dataset. |
| `texts` | array of strings | Lists text values to process when `target` is `texts`. Each value is handled on its own. |
| `datasetId` | string | Selects the Apify dataset to read when `target` is `dataset`. |
| `datasetTextField` | string | Names the dataset row field that holds the text. The default is `text`. |
| `patterns` | array of objects | Sets custom named Python-compatible regular expressions. Leave it empty to use the ready-made contact patterns. |
| `patterns[].name` | string | Gives a pattern its unique output group name. |
| `patterns[].expression` | string | Sets the Python-compatible regular expression. |
| `matchMode` | string | Uses `all` for every occurrence or `first` for only the first occurrence per pattern and text. |
| `flags` | array of strings | Applies `IGNORECASE`, `MULTILINE`, `DOTALL`, `VERBOSE`, or `ASCII` to all custom patterns. |

This example is the public input from a successful run with the default text:

```json
{
  "target": "texts",
  "texts": [
    "Team contacts:\nsupport@example.com and sales@example.com\nCall +1 (415) 555-0134\nVisit https://example.com/help\nLinkedIn: linkedin.com/company/example"
  ],
  "datasetTextField": "text",
  "matchMode": "all"
}
````

The Actor checks the input before it starts. Invalid regular expressions, unknown flags, and repeated pattern names cause a clear error.

#### 📊 Output

Each dataset row has this shape:

| Field | Type | What it does |
| --- | --- | --- |
| `text` | string | Holds the full text that was processed. |
| `matchCount` | integer | Counts all matches across all patterns. |
| `matchesByPattern` | object | Groups match arrays by pattern name. |
| `matchesByPattern.<name>` | array of objects | Lists matches for one pattern, or an empty array when none were found. |
| `matchesByPattern.<name>[].value` | string | Holds the full matched value. |
| `matchesByPattern.<name>[].start` | integer | Gives the zero-based position where the match starts. |
| `matchesByPattern.<name>[].end` | integer | Gives the zero-based position just after the match ends. |
| `matchesByPattern.<name>[].groups` | array | Lists numbered capture values in pattern order. A missed group is `null`. |
| `matchesByPattern.<name>[].namedGroups` | object | Maps named capture groups to their values. A missed group is `null`. |

```json
{
  "text": "Team contacts:\nsupport@example.com and sales@example.com\nCall +1 (415) 555-0134\nVisit https://example.com/help\nLinkedIn: linkedin.com/company/example",
  "matchCount": 5,
  "matchesByPattern": {
    "emails": [
      {
        "value": "support@example.com",
        "start": 15,
        "end": 34,
        "groups": [],
        "namedGroups": {}
      },
      {
        "value": "sales@example.com",
        "start": 39,
        "end": 56,
        "groups": [],
        "namedGroups": {}
      }
    ],
    "phoneNumbers": [
      {
        "value": "+1 (415) 555-0134",
        "start": 62,
        "end": 79,
        "groups": [],
        "namedGroups": {}
      }
    ],
    "urls": [
      {
        "value": "https://example.com/help",
        "start": 86,
        "end": 110,
        "groups": [],
        "namedGroups": {}
      }
    ],
    "linkedinReferences": [
      {
        "value": "linkedin.com/company/example",
        "start": 121,
        "end": 149,
        "groups": [],
        "namedGroups": {}
      }
    ]
  }
}
```

#### 💳 Pricing

This Actor uses pay-per-event pricing. You pay for each processed text saved to the dataset. The charge covers the text row and its match data, including rows where the checked patterns find no match.

#### 🔌 Integrations

Use the dataset through the Apify API, webhooks, schedules, or Apify integrations. This video shows how to connect an Actor to other tools:

https://www.youtube.com/watch?v=bNACk1\_S\_6w\&list=PLObrtcm1Kw6MUrlLNDbK9QRg8VDJg0gOW\&index=4

#### ❓ FAQ

##### Can it scrape text from a website?

No. The Actor only checks text you submit or text in an existing Apify dataset. Use a text extraction Actor first if you need to fetch a page.

##### Can I use my own patterns?

Yes. Add one or more unique names and Python-compatible regular expressions in `patterns`. Custom patterns replace the ready-made patterns for that run.

##### What happens when a pattern finds nothing?

The output keeps the processed text and the pattern name. That pattern has an empty match array, and `matchCount` shows the total across all patterns.

##### Can it replace or clean the matched text?

No. It finds and describes matches but does not rewrite the input text.

##### How does first match mode work?

For each pattern and each text, `first` saves only the first occurrence. Use `all` to collect every occurrence.

### 📝 Changelog

#### 0.0: Initial release

- Extract structured matches with positions and capture groups from submitted text or Apify dataset rows using built-in or custom named regex patterns.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~regex-helper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Related Actors

- [Webpage Text Extractor](https://apify.com/maximedupre/webpage-text-extractor) fetches clean text or Markdown from public web pages before you run regex patterns on it.
- [Unicode Text Inspector](https://apify.com/maximedupre/unicode-text-inspector) checks text for hidden characters, bidi controls, and homoglyphs.
- [Website Emails Scraper](https://apify.com/maximedupre/website-emails-scraper) finds public email addresses by crawling websites.
- [Email MX Verifier](https://apify.com/maximedupre/email-mx-verifier) checks the syntax, MX records, and risk signals of email addresses you already found.
- [Phone Number Validation API](https://apify.com/maximedupre/phone-number-validation) checks and formats phone numbers found in text.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

## `target` (type: `string`):

Choose whether to process text entered in this form or rows from an Apify dataset.

## `texts` (type: `array`):

Enter one or more text values. Each value is processed on its own. Used only for the Submitted texts target.

## `datasetId` (type: `string`):

Choose an Apify dataset. Used only for the Apify dataset target.

## `datasetTextField` (type: `string`):

Enter the dataset row field that holds the text. Used only for the Apify dataset target.

## `patterns` (type: `array`):

Add named Python-compatible regular expressions to use for every text. If left empty, the Actor uses ready-made patterns for emails, phone numbers, URLs, and LinkedIn references.

## `matchMode` (type: `string`):

Choose whether each pattern returns every occurrence or only its first occurrence in each text.

## `__isDebug` (type: `boolean`):

Reserved for internal run checks.

## `flags` (type: `array`):

Choose Python regular-expression modes to apply to all custom patterns. Leave this empty for normal matching.

## Actor input object example

```json
{
  "target": "texts",
  "texts": [
    "Team contacts:\nsupport@example.com and sales@example.com\nCall +1 (415) 555-0134\nVisit https://example.com/help\nLinkedIn: linkedin.com/company/example"
  ],
  "datasetTextField": "text",
  "matchMode": "all"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset rows with the text, matches grouped by pattern name, and total match count.

# 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 = {
    "target": "texts",
    "texts": [
        "Team contacts:\nsupport@example.com and sales@example.com\nCall +1 (415) 555-0134\nVisit https://example.com/help\nLinkedIn: linkedin.com/company/example"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/regex-helper").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 = {
    "target": "texts",
    "texts": ["""Team contacts:
support@example.com and sales@example.com
Call +1 (415) 555-0134
Visit https://example.com/help
LinkedIn: linkedin.com/company/example"""],
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/regex-helper").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 '{
  "target": "texts",
  "texts": [
    "Team contacts:\\nsupport@example.com and sales@example.com\\nCall +1 (415) 555-0134\\nVisit https://example.com/help\\nLinkedIn: linkedin.com/company/example"
  ]
}' |
apify call maximedupre/regex-helper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Regex Helper",
        "description": "Apply named regular expressions to submitted text or an Apify dataset. Get matches by pattern with values, positions, capture groups, and a total match count.",
        "version": "0.0",
        "x-build-id": "MgBjWGNn1WaXyTv3j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~regex-helper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-regex-helper",
                "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/maximedupre~regex-helper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-regex-helper",
                "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/maximedupre~regex-helper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-regex-helper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "target"
                ],
                "properties": {
                    "target": {
                        "title": "Target",
                        "enum": [
                            "texts",
                            "dataset"
                        ],
                        "type": "string",
                        "description": "Choose whether to process text entered in this form or rows from an Apify dataset."
                    },
                    "texts": {
                        "title": "Texts",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter one or more text values. Each value is processed on its own. Used only for the Submitted texts target.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "datasetId": {
                        "title": "Dataset",
                        "type": "string",
                        "description": "Choose an Apify dataset. Used only for the Apify dataset target."
                    },
                    "datasetTextField": {
                        "title": "Text field",
                        "minLength": 1,
                        "type": "string",
                        "description": "Enter the dataset row field that holds the text. Used only for the Apify dataset target.",
                        "default": "text"
                    },
                    "patterns": {
                        "title": "Custom patterns",
                        "type": "array",
                        "description": "Add named Python-compatible regular expressions to use for every text. If left empty, the Actor uses ready-made patterns for emails, phone numbers, URLs, and LinkedIn references.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {
                                    "type": "string",
                                    "title": "Name",
                                    "description": "Give the pattern a unique name used to group its results.",
                                    "minLength": 1
                                },
                                "expression": {
                                    "type": "string",
                                    "title": "Regular expression",
                                    "description": "Enter a Python-compatible regular expression.",
                                    "minLength": 1
                                }
                            },
                            "required": [
                                "name",
                                "expression"
                            ],
                            "additionalProperties": false
                        }
                    },
                    "matchMode": {
                        "title": "Match mode",
                        "enum": [
                            "all",
                            "first"
                        ],
                        "type": "string",
                        "description": "Choose whether each pattern returns every occurrence or only its first occurrence in each text.",
                        "default": "all"
                    },
                    "__isDebug": {
                        "title": "Internal debug mode",
                        "type": "boolean",
                        "description": "Reserved for internal run checks."
                    },
                    "flags": {
                        "title": "Regex flags",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose Python regular-expression modes to apply to all custom patterns. Leave this empty for normal matching.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "IGNORECASE",
                                "MULTILINE",
                                "DOTALL",
                                "VERBOSE",
                                "ASCII"
                            ],
                            "enumTitles": [
                                "Ignore case",
                                "Multiline",
                                "Dot matches newlines",
                                "Verbose",
                                "ASCII"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```