# Serchen Software Reviews Scraper (`automation-lab/serchen-software-reviews-scraper`) Actor

Scrape Serchen software categories for company profiles, ratings, review counts, descriptions, and optional public review excerpts.

- **URL**: https://apify.com/automation-lab/serchen-software-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 serchen company results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

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

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

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

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

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

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

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

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


# README

## Serchen Software Reviews Scraper

Scrape public Serchen software directory pages for company names, profile URLs, categories, ratings, review counts, descriptions, logos, sponsored flags, and optional profile details.

### What does Serchen Software Reviews Scraper do?

Serchen Software Reviews Scraper turns public Serchen category and company profile pages into structured datasets.

It is built for software-review, competitive-intelligence, and vendor-discovery workflows.

The actor reads Serchen category pages such as `crm-software` and follows pagination until your maximum company limit is reached.

It can also fetch company profile pages to enrich records with vendor website URLs, founded-year hints, pricing snippets, and recent public review excerpts when Serchen exposes them in page metadata.

### Who is it for?

- 🧭 SaaS founders mapping competitors in a software category.
- 📈 Growth teams finding vendors with strong review counts.
- 🧪 Product marketers comparing positioning copy across software directories.
- 🧾 Review operations teams monitoring public reputation signals.
- 🧰 Agencies building lead lists from Serchen categories.
- 🧑‍💻 Data teams feeding software-review data into BI, CRM, or enrichment pipelines.

### Why use it?

Serchen pages are useful but manual browsing is slow.

This actor captures repeated fields into JSON, CSV, Excel, XML, HTML, or API responses.

You can run a small category sample or a larger paginated scrape without building your own parser.

The output keeps source URLs and scrape timestamps so you can audit every row.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Software company or product name |
| `profileUrl` | Public Serchen company profile URL |
| `sourceUrl` | Category or profile URL where the row came from |
| `categoryName` | Category label visible on the card |
| `categoryUrl` | Serchen category URL |
| `rating` | Rating score when visible |
| `reviewCount` | Number of reviews shown by Serchen |
| `description` | Public listing/profile description |
| `logoUrl` | Public logo image URL when visible |
| `websiteUrl` | Vendor website URL when profile enrichment is enabled |
| `isSponsored` | Whether the Serchen card is marked as sponsored/spotlight |
| `position` | Position in the collected result stream |
| `page` | Category page number |
| `country` | Country metadata when visible on the profile |
| `foundedYear` | Founded year hint when visible on the profile |
| `pricing` | Short pricing snippet when detected |
| `recentReviews` | Optional bounded public review excerpts |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Serchen software reviews?

This actor uses pay-per-event pricing.

There is a small start event for each run and a per-result event for each saved Serchen company record.

Keep `maxItems` low for your first run.

Enable profile details only when you need richer data because it fetches one extra page per company.

### Input options

#### Start URLs

Use Serchen category or company URLs.

Examples:

```json
[
  { "url": "https://www.serchen.com/category/crm-software/" },
  { "url": "https://www.serchen.com/company/nutshell/" }
]
````

#### Category slugs

You can also provide category slugs such as:

```json
["crm-software", "accounting-software"]
```

The actor converts them to Serchen category URLs.

#### Maximum companies

`maxItems` controls the total number of dataset rows.

The prefill is intentionally small for safe first runs.

#### Fetch company profile details

Turn on `includeProfileDetails` to open each company profile.

This may add:

- 🌐 vendor website URL
- 🏢 founded-year hints
- 💬 review excerpts
- 💵 visible pricing snippets

#### Maximum review excerpts per company

`maxReviewsPerCompany` limits nested review excerpts.

Set it to `0` if you want profile enrichment without review snippets.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.serchen.com/category/crm-software/" }
  ],
  "maxItems": 20,
  "includeProfileDetails": false,
  "maxReviewsPerCompany": 3
}
```

### Example output

```json
{
  "name": "Zoho CRM",
  "profileUrl": "https://www.serchen.com/company/zoho-crm",
  "sourceUrl": "https://www.serchen.com/category/crm-software",
  "categoryName": "AI-powered sales automation software",
  "categoryUrl": "https://www.serchen.com/category/crm-software",
  "rating": 4.4,
  "reviewCount": 30,
  "description": "Zoho CRM is an AI-powered sales CRM that helps businesses grow...",
  "logoUrl": "https://www.serchen.com/api/company-logo?...",
  "websiteUrl": null,
  "isSponsored": true,
  "position": 2,
  "page": 1,
  "country": null,
  "foundedYear": null,
  "pricing": null,
  "recentReviews": [],
  "scrapedAt": "2026-06-06T08:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Paste one or more Serchen category URLs.
3. Set `maxItems`.
4. Decide whether profile enrichment is needed.
5. Click **Start**.
6. Export the dataset or consume it through the API.

### Tips for reliable results

- Start with one category and 25 companies.
- Use profile enrichment only after verifying the category output.
- Prefer category URLs over search pages for predictable pagination.
- Keep review excerpts bounded for easier downstream processing.
- Re-run periodically to monitor review-count changes.

### Integrations

Use the dataset in:

- 📊 Google Sheets or Excel exports for category maps.
- 🧩 Zapier or Make scenarios for CRM enrichment.
- 🧠 LLM workflows that summarize positioning and review signals.
- 🗄️ Data warehouses for recurring software-market tracking.
- 🔔 Monitoring workflows that alert when review counts change.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/serchen-software-reviews-scraper').call({
  startUrls: [{ url: 'https://www.serchen.com/category/crm-software/' }],
  maxItems: 25,
  includeProfileDetails: false
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/serchen-software-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.serchen.com/category/crm-software/'}],
    'maxItems': 25,
    'includeProfileDetails': False,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~serchen-software-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.serchen.com/category/crm-software/"}],"maxItems":25}'
```

### MCP usage

Use Apify MCP with Claude Code, Claude Desktop, or other MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/serchen-software-reviews-scraper
```

Claude Code setup:

```bash
claude mcp add apify-serchen "https://mcp.apify.com/?tools=automation-lab/serchen-software-reviews-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-serchen": {
      "url": "https://mcp.apify.com/?tools=automation-lab/serchen-software-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the Serchen CRM category and summarize the top-rated vendors."
- "Find Serchen software companies with at least 20 reviews."
- "Export a Serchen category dataset and group vendors by rating."

### Legality

This actor extracts public Serchen pages that are visible without an account.

Use the data responsibly.

Respect Serchen, applicable laws, privacy rules, and your downstream obligations.

Do not use scraped data for spam, harassment, or unlawful profiling.

### FAQ and troubleshooting

#### Why did I get fewer rows than `maxItems`?

The selected category may have fewer accessible company cards, or Serchen pagination may stop before your requested limit.

Try a broader category or a lower limit first.

#### Why are website URL and reviews empty?

Those fields require `includeProfileDetails: true`.

Category cards expose ratings and review counts, but profile metadata is fetched from each company profile.

#### Why is profile enrichment slower?

It fetches one additional profile page for every company.

Disable it when you only need names, ratings, review counts, and descriptions.

### Related scrapers

- https://apify.com/automation-lab/g2-scraper
- https://apify.com/automation-lab/capterra-reviews-scraper
- https://apify.com/automation-lab/trustpilot-reviews-scraper

### Limitations

Serchen can change its HTML structure at any time.

If a page becomes protected by a challenge or no longer exposes public HTML, the actor may need an update.

The actor does not log in and does not access private data.

### Changelog

#### 0.1

Initial build with category scraping, pagination, company profile URL extraction, ratings, review counts, descriptions, and optional profile enrichment.

### Support

If a Serchen category stops working, include the input URL, run ID, and what output you expected.

Small reproducible inputs help us fix site-structure changes faster.

# Actor input Schema

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

Serchen category URLs such as https://www.serchen.com/category/crm-software/ or company profile URLs such as https://www.serchen.com/company/nutshell/.

## `categorySlugs` (type: `array`):

Optional Serchen category slugs to scrape, for example crm-software or accounting-software. Used in addition to Start URLs.

## `maxItems` (type: `integer`):

Maximum number of software company records to save across all supplied pages.

## `includeProfileDetails` (type: `boolean`):

Open each company profile to enrich listings with website URL, founded year, pricing snippets, and recent review excerpts. This makes runs slower but adds richer data.

## `maxReviewsPerCompany` (type: `integer`):

When profile details are enabled, include up to this many review excerpts from each company profile.

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

Serchen commonly blocks datacenter traffic. The actor uses Apify Residential proxy by default; keep this enabled unless you know your network can access Serchen directly.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.serchen.com/category/crm-software/"
    }
  ],
  "categorySlugs": [
    "crm-software"
  ],
  "maxItems": 20,
  "includeProfileDetails": false,
  "maxReviewsPerCompany": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (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://www.serchen.com/category/crm-software/"
        }
    ],
    "categorySlugs": [
        "crm-software"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/serchen-software-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.serchen.com/category/crm-software/" }],
    "categorySlugs": ["crm-software"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/serchen-software-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.serchen.com/category/crm-software/"
    }
  ],
  "categorySlugs": [
    "crm-software"
  ]
}' |
apify call automation-lab/serchen-software-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Serchen Software Reviews Scraper",
        "description": "Scrape Serchen software categories for company profiles, ratings, review counts, descriptions, and optional public review excerpts.",
        "version": "0.1",
        "x-build-id": "oXmewZyyHbCsYWHBj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~serchen-software-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-serchen-software-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~serchen-software-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-serchen-software-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~serchen-software-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-serchen-software-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Serchen category URLs such as https://www.serchen.com/category/crm-software/ or company profile URLs such as https://www.serchen.com/company/nutshell/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "categorySlugs": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Serchen category slugs to scrape, for example crm-software or accounting-software. Used in addition to Start URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of software company records to save across all supplied pages.",
                        "default": 20
                    },
                    "includeProfileDetails": {
                        "title": "Fetch company profile details",
                        "type": "boolean",
                        "description": "Open each company profile to enrich listings with website URL, founded year, pricing snippets, and recent review excerpts. This makes runs slower but adds richer data.",
                        "default": false
                    },
                    "maxReviewsPerCompany": {
                        "title": "Maximum review excerpts per company",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "When profile details are enabled, include up to this many review excerpts from each company profile.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Serchen commonly blocks datacenter traffic. The actor uses Apify Residential proxy by default; keep this enabled unless you know your network can access Serchen directly.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
