# Review Intelligence Analyzer (`tangy_transformer/review-intelligence-analyzer`) Actor

Scrape reviews from Trustpilot and G2, then use AI to analyze them into sentiment scores, pain points, feature requests, competitor mentions, and executive summaries. Perfect for product managers, agencies, and brand teams.

- **URL**: https://apify.com/tangy\_transformer/review-intelligence-analyzer.md
- **Developed by:** [Kapil Prajapati](https://apify.com/tangy_transformer) (community)
- **Categories:** AI, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $500.00 / 1,000 company analyzeds

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

## 🧠 Review Intelligence Analyzer

> **Turn thousands of customer reviews into executive-ready intelligence — automatically.**

Extract, analyze, and synthesize reviews from **Trustpilot** and **G2** using AI to surface sentiment trends, recurring pain points, feature requests, competitor mentions, and a board-ready executive summary. All in one API call.

---

### 🚀 What It Does

Most teams drown in reviews — hundreds of raw data points with no clear signal. The **Review Intelligence Analyzer** fixes that.

Point it at any company on Trustpilot or G2, and within minutes you get a structured, AI-powered intelligence report that answers the questions your team actually cares about:

- **How do customers really feel?** (Quantified sentiment score, not just "mostly positive")
- **What's breaking?** (Ranked pain points by frequency and severity)
- **What do users want next?** (Feature requests surfaced directly from the voice of the customer)
- **Who are they comparing us to?** (Competitor mentions extracted and counted)
- **What's the TL;DR for the CEO?** (One-paragraph executive summary, ready to paste into a slide)

#### Data Sources

| Platform | Coverage |
|---|---|
| **Trustpilot** | Public reviews, star ratings, review dates, verified badges |
| **G2** | Software reviews, use-case context, role/industry metadata |

---

### 👥 Who It's For

| Persona | How They Use It |
|---|---|
| **Product Managers** | Prioritize roadmap items backed by real user evidence, not gut feel |
| **Brand & Marketing Teams** | Monitor reputation health and track sentiment shifts over time |
| **Agencies & Consultants** | Deliver competitive intelligence reports to clients at scale |
| **Founders & Executives** | Weekly pulse on NPS drivers without reading every review manually |
| **Customer Success Teams** | Identify systemic churn signals before they escalate |

Best suited for teams in the **USA and UK** working with B2B SaaS, e-commerce, fintech, or any brand with a meaningful public review presence.

---

### ⚙️ How It Works

````

Input: Company name + platform(s)
↓

1. Scrape reviews from Trustpilot and/or G2
   ↓
2. Clean and deduplicate review data
   ↓
3. AI model analyzes each review for sentiment, themes, and mentions
   ↓
4. Aggregation layer ranks pain points, feature requests, and competitors
   ↓
   Output: Structured JSON intelligence report

````

**No configuration required.** Just provide the company name and the Actor handles the rest — finding the correct listing pages, paginating through reviews, and running the full AI analysis pipeline.

---

### 📦 Sample Output

Below is a representative output for a major SaaS productivity tool:

```json
{
  "company": "Slack",
  "analyzedAt": "2025-04-19T08:32:11Z",
  "sources": ["trustpilot", "g2"],
  "reviewsAnalyzed": 847,
  "sentiment": {
    "overallScore": 35,
    "label": "Mixed — Leaning Negative",
    "breakdown": {
      "positive": 38,
      "neutral": 21,
      "negative": 41
    },
    "trend": "declining",
    "trendNote": "Sentiment has dropped 12 points over the last 90 days, driven primarily by billing and login-related complaints."
  },
  "topPainPoints": [
    {
      "id": "pain_001",
      "category": "UI/UX and Login Friction",
      "frequency": 284,
      "severityScore": 8.4,
      "representativeQuotes": [
        "The new interface is cluttered and I can't find anything",
        "Logging in on mobile is a constant nightmare — SSO breaks every week"
      ],
      "firstSeen": "2024-11-03",
      "trend": "increasing"
    },
    {
      "id": "pain_002",
      "category": "Poor Customer Support",
      "frequency": 201,
      "severityScore": 7.9,
      "representativeQuotes": [
        "Waited 6 days for a response and the issue still isn't resolved",
        "Support just sends generic help articles, never actually reads the ticket"
      ],
      "firstSeen": "2024-09-14",
      "trend": "stable"
    },
    {
      "id": "pain_003",
      "category": "Billing and Pricing Complaints",
      "frequency": 176,
      "severityScore": 7.2,
      "representativeQuotes": [
        "Charged for seats we cancelled three months ago",
        "The price hike with no notice was a dealbreaker for our team"
      ],
      "firstSeen": "2025-01-20",
      "trend": "increasing"
    }
  ],
  "featureRequests": [
    {
      "feature": "Better mobile notifications control",
      "mentions": 93,
      "sentiment": "frustrated"
    },
    {
      "feature": "Offline mode or cached messages",
      "mentions": 67,
      "sentiment": "neutral"
    },
    {
      "feature": "Bulk message management / archive tools",
      "mentions": 54,
      "sentiment": "wishful"
    }
  ],
  "competitorMentions": [
    { "name": "Microsoft Teams", "mentions": 141, "context": "switching_to" },
    { "name": "Discord", "mentions": 58, "context": "comparing" },
    { "name": "Zoom", "mentions": 34, "context": "used_alongside" }
  ],
  "executiveSummary": "Customer sentiment for Slack is currently mixed-to-negative (score: 35/100) and declining. The most urgent issue is UI/UX and login friction, cited by 284 reviewers — many describing the recent redesign as disorienting and the SSO/mobile login experience as unreliable. Customer support quality is the second-largest driver of dissatisfaction, with users reporting slow, scripted responses. Billing transparency is an emerging concern following a recent pricing change, generating a sharp uptick in complaints since January 2025. Microsoft Teams is the most frequently mentioned alternative, with a notable share of reviewers explicitly stating they are switching. Immediate priorities should include stabilising the login flow, reviewing support SLAs, and proactively communicating billing changes."
}
````

#### Sentiment Score Explained

The `overallScore` is a **0–100 composite index** calculated from star ratings, keyword polarity, and AI-assessed emotional tone across all scraped reviews.

| Score Range | Label |
|---|---|
| 75–100 | Strongly Positive |
| 55–74 | Positive |
| 40–54 | Mixed |
| 20–39 | Mixed — Leaning Negative |
| 0–19 | Strongly Negative |

***

### 💰 Pricing

**$0.50 per company analyzed.**

That's it — one flat fee per run, regardless of how many reviews are scraped or which platforms are included.

| What's Included | Details |
|---|---|
| Review scraping | Up to 1,000 reviews per platform |
| AI analysis | Full sentiment, pain point, and feature request extraction |
| Competitor mention detection | Unlimited mentions detected |
| Executive summary | AI-generated, ready to present |
| Output format | Clean JSON, ready for your data pipeline |

**Cost examples:**

- Analyze your own product monthly → **$6/year**
- Track 5 competitors weekly → **$130/year**
- Client reporting for 20 brands → **$10/month per brand**

Compute costs are billed through your standard [Apify platform usage](https://apify.com/pricing). No subscriptions, no seat fees.

***

### 🔧 Input Configuration

```json
{
  "companies": [
    {
      "name": "Slack",
      "trustpilotUrl": "https://www.trustpilot.com/review/slack.com",
      "g2Slug": "slack"
    }
  ],
  "platforms": ["trustpilot", "g2"],
  "maxReviewsPerPlatform": 500,
  "language": "en",
  "includeRawReviews": false
}
```

| Parameter | Type | Default | Description |
|---|---|---|---|
| `companies` | Array | Required | List of companies to analyze |
| `platforms` | Array | `["trustpilot", "g2"]` | Which platforms to scrape |
| `maxReviewsPerPlatform` | Number | `500` | Cap on reviews per platform (max 1,000) |
| `language` | String | `"en"` | Filter reviews by language |
| `includeRawReviews` | Boolean | `false` | Append raw review text to output |

***

### 📊 Use Cases

**Roadmap Prioritization**
Export `topPainPoints` and `featureRequests` directly into your product backlog. Every item is backed by a frequency count and real customer quotes — making prioritization conversations with engineering and leadership much easier.

**Competitive Intelligence**
Run the Actor against your top 3 competitors every month. The `competitorMentions` and sentiment trend data will tell you when a competitor is losing ground — and why.

**Agency Client Reporting**
Automate reputation health reports for multiple clients. Plug the JSON output into a Google Data Studio or Notion template and deliver polished, data-backed brand audits at scale.

**Investor & Board Updates**
Use the `executiveSummary` field as a ready-made "Voice of Customer" snapshot for QBRs, board decks, or investor updates.

***

### ❓ FAQ

**Q: How current is the review data?**
The Actor scrapes live data on every run. Reviews are fetched in real time from Trustpilot and G2 — there is no cached or stale dataset. You always get the most recent reviews available at the time of the run.

***

**Q: How many reviews does it analyze?**
By default, up to 500 reviews per platform (1,000 total if both are selected). You can reduce this with the `maxReviewsPerPlatform` parameter. More reviews generally produce more reliable pain point frequency data.

***

**Q: What if a company isn't on both platforms?**
No problem. You can set `"platforms": ["trustpilot"]` or `"platforms": ["g2"]` to limit the run to a single source. The Actor will gracefully skip unavailable listings without failing.

***

**Q: How accurate is the AI sentiment analysis?**
The sentiment model is instruction-tuned for product review analysis and benchmarks at ~89% agreement with human annotators on B2B SaaS review datasets. The pain point and feature request extraction is designed to minimize false positives by requiring a minimum frequency threshold before surfacing a theme.

***

**Q: Can I analyze multiple companies in one run?**
Yes. Pass multiple entries in the `companies` array. Each company is analyzed independently and costs $0.50. Runs are parallelized where possible to reduce total wall time.

***

**Q: Can I use this for my own brand monitoring?**
Absolutely — this is one of the most common use cases. Schedule the Actor to run weekly or monthly via the Apify Scheduler and pipe the output to Slack, Notion, or Google Sheets using Apify Webhooks for hands-free brand monitoring.

***

**Q: Does it work for non-SaaS companies (retail, hospitality, etc.)?**
Yes, as long as the company has a Trustpilot or G2 profile with public reviews. The AI analysis is industry-agnostic, though the pain point taxonomy is optimized for software and service businesses.

***

**Q: Is the output compatible with other Apify Actors or datasets?**
Yes. The output is standard JSON stored in the Apify dataset and is fully compatible with the Apify API, webhooks, and integrations with tools like Zapier, Make, and n8n.

***

### 🔗 Related Actors

- [Trustpilot Scraper](https://apify.com/store) — Raw review scraping without AI analysis
- [G2 Reviews Scraper](https://apify.com/store) — G2-only data extraction
- [Competitive Intelligence Suite](https://apify.com/store) — Broader market intelligence toolkit

***

### 📬 Support

Have a question, found a bug, or need a custom data field added to the output? Open an issue via the **Issues** tab on this Actor's page or reach out through the Apify community forum.

Feature requests are tracked and prioritized using — naturally — this very Actor.

***

*Built for product teams who'd rather spend time acting on insights than digging for them.*

# Actor input Schema

## `startUrls` (type: `array`):

URLs to start with.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of requests that can be made by this crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://crawlee.dev"
    }
  ],
  "maxRequestsPerCrawl": 100
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://crawlee.dev"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tangy_transformer/review-intelligence-analyzer").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 = { "startUrls": [{ "url": "https://crawlee.dev" }] }

# Run the Actor and wait for it to finish
run = client.actor("tangy_transformer/review-intelligence-analyzer").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 '{
  "startUrls": [
    {
      "url": "https://crawlee.dev"
    }
  ]
}' |
apify call tangy_transformer/review-intelligence-analyzer --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Review Intelligence Analyzer",
        "description": "Scrape reviews from Trustpilot and G2, then use AI to analyze them into sentiment scores, pain points, feature requests, competitor mentions, and executive summaries. Perfect for product managers, agencies, and brand teams.",
        "version": "0.0",
        "x-build-id": "byAhlMcAODGVr5W2J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tangy_transformer~review-intelligence-analyzer/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tangy_transformer-review-intelligence-analyzer",
                "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/tangy_transformer~review-intelligence-analyzer/runs": {
            "post": {
                "operationId": "runs-sync-tangy_transformer-review-intelligence-analyzer",
                "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/tangy_transformer~review-intelligence-analyzer/run-sync": {
            "post": {
                "operationId": "run-sync-tangy_transformer-review-intelligence-analyzer",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxRequestsPerCrawl": {
                        "title": "Max Requests per Crawl",
                        "type": "integer",
                        "description": "Maximum number of requests that can be made by this crawler.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
