# Clio App Directory Scraper (`automation-lab/clio-app-directory-scraper`) Actor

Extract Clio App Directory integrations, vendor websites, categories, products, pricing labels, logos, screenshots, and app descriptions.

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

## Pricing

Pay per event

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

## Clio App Directory Scraper

Extract structured data from the public Clio App Directory for legaltech lead generation, integration research, partner monitoring, and competitive intelligence.

The actor crawls Clio directory pages and app profile pages, then exports app names, Clio listing URLs, vendor websites, categories, descriptions, supported Clio products, availability, pricing labels, logos, screenshots, and timestamps.

### What does Clio App Directory Scraper do?

Clio App Directory Scraper turns the public Clio integration marketplace into a clean dataset.

It can:

- 🧩 Crawl Clio App Directory pagination.
- 🔎 Start from category URLs or direct app listing URLs.
- 🏷️ Extract categories such as Intake, Marketing, Accounting, Text, and AI and Automation.
- 🌐 Capture vendor website links from app detail pages.
- 🖼️ Collect logo and screenshot URLs for app profiles.
- ⚖️ Export legaltech-specific details such as Clio products and regional availability.
- 📦 Save every result as a structured Apify dataset item.

### Who is it for?

This actor is useful for teams that need a repeatable view of the Clio integration ecosystem.

Typical users include:

- Legaltech vendors building partnership or competitor lists.
- Law-firm operations teams comparing Clio-compatible apps.
- CRM enrichment teams adding vendor websites and categories.
- Agencies researching marketing, intake, payment, and automation vendors.
- Product managers monitoring new integrations and directory positioning.
- Data teams that need a dependable export instead of manual copy-paste.

### Why use this actor?

The Clio directory is easy to browse manually, but hard to analyze at scale.

This actor helps when you need:

- A spreadsheet-ready list of Clio ecosystem vendors.
- Current app listing URLs and profile metadata.
- Category-specific lead lists.
- Vendor websites for enrichment or outreach.
- Periodic monitoring of app positioning and new integrations.
- A lightweight HTTP scraper that does not require a browser or login.

### Data extracted

Each dataset item represents one Clio app listing.

| Field | Description |
| --- | --- |
| `name` | App or integration name |
| `listingUrl` | Public Clio app profile URL |
| `tagline` | Short directory tagline when available |
| `description` | Detail-page benefits or meta description |
| `categories` | Directory categories shown for the app |
| `vendorName` | Vendor hostname derived from the outbound link |
| `vendorWebsite` | Vendor website or get-started URL |
| `clioProducts` | Clio products supported by the integration |
| `availability` | Region availability text |
| `pricingText` | Pricing label shown by Clio, when present |
| `isFree` | Whether the listing is labeled free |
| `isCertified` | Whether a Clio certification badge is detected |
| `logoUrl` | App logo URL |
| `screenshots` | Screenshot or video URLs from the profile |
| `sourceUrl` | Page used as the source for the result |
| `scrapedAt` | ISO timestamp for the extraction |

### How much does it cost to scrape Clio App Directory apps?

This actor uses pay-per-event pricing.

Current pricing is:

- Run start: `$0.005`
- App item: tiered per saved Clio app, with BRONZE at `$0.000054693` per item and volume discounts down to `$0.000015314` per item on DIAMOND

Production prices are calculated from real Apify cloud runs so users pay for successful extraction rather than idle compute.

### Input

The most common input is the public directory homepage:

```json
{
  "startUrls": [{ "url": "https://www.clio.com/app-directory/" }],
  "maxItems": 25,
  "includeDetails": true
}
````

### Input fields

#### `startUrls`

Use Clio directory URLs, pagination URLs, category URLs, or direct app profile URLs.

Examples:

- `https://www.clio.com/app-directory/`
- `https://www.clio.com/app-directory/page/2/`
- `https://www.clio.com/app-directory/case-status/`
- `https://www.clio.com/app-directory/?categories=automation`

#### `maxItems`

Maximum number of app records to save.

Use a small value for quick testing and a larger value for a full directory crawl.

#### `includeDetails`

When enabled, the actor visits each app profile page for vendor website, categories, screenshots, products, and long descriptions.

Disable it when you only need fast directory-card data.

#### `category`

Optional text filter matched against extracted categories after detail pages are loaded.

#### `keyword`

Optional text filter matched against app name, tagline, description, vendor, and categories.

### Output example

```json
{
  "name": "Case Status",
  "listingUrl": "https://www.clio.com/app-directory/case-status/",
  "tagline": "Mobile Client Portal & Communication Platform for Law Firms",
  "categories": ["AI AND AUTOMATION", "TEXT"],
  "vendorName": "casestatus.com",
  "vendorWebsite": "https://www.casestatus.com/clio",
  "clioProducts": ["CLIO MANAGE"],
  "availability": "Available in the United States",
  "logoUrl": "https://www.clio.com/wp-content/uploads/2018/02/cs_icon.png",
  "scrapedAt": "2026-06-26T03:22:16.439Z"
}
```

### How to run

1. Open the actor on Apify.
2. Keep the prefilled Clio directory URL or add your own Clio category/listing URLs.
3. Choose `maxItems`.
4. Keep `includeDetails` enabled for the richest data.
5. Start the run.
6. Export the dataset as JSON, CSV, Excel, or through the API.

### Tips for best results

- Use `includeDetails: true` when you need vendor websites.
- Use direct app profile URLs for one-off enrichment.
- Use category URLs when you want a focused legaltech segment.
- Use `keyword` to keep only apps matching a buyer theme such as intake, payments, automation, or marketing.
- Schedule recurring runs to monitor new Clio ecosystem entries.

### Integrations

You can connect the output to:

- Google Sheets for partnership research.
- Airtable for vendor tracking.
- HubSpot or Salesforce for CRM enrichment.
- Notion for legaltech competitive-intelligence notebooks.
- Clay or custom enrichment pipelines for outbound workflows.
- Webhooks for change-monitoring jobs.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/clio-app-directory-scraper').call({
  startUrls: [{ url: 'https://www.clio.com/app-directory/' }],
  maxItems: 25,
  includeDetails: true,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/clio-app-directory-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.clio.com/app-directory/'}],
    'maxItems': 25,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~clio-app-directory-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.clio.com/app-directory/"}],"maxItems":25,"includeDetails":true}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP.

MCP tool URL:

`https://mcp.apify.com/?tools=automation-lab/clio-app-directory-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/clio-app-directory-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/clio-app-directory-scraper"
    }
  }
}
```

Example prompts:

- "Scrape the Clio App Directory and summarize vendors in the Intake category."
- "Find Clio apps with vendor websites and create a table of partnership targets."
- "Monitor the Clio directory for apps related to AI and automation."

### Legality

The actor extracts publicly available Clio directory pages.

You are responsible for using the exported data lawfully and in line with applicable terms, privacy rules, and outreach regulations.

Avoid spam, excessive requests, or uses that would violate platform or data-protection requirements.

### Troubleshooting

#### Why do some fields appear empty?

Some Clio listings do not expose every field. For example, a listing may not have a pricing label, screenshots, or a visible vendor website.

#### Why did my keyword return fewer results than expected?

The keyword filter is applied to extracted text. Try a broader keyword, remove the filter, or enable `includeDetails` so more page text is available.

#### Can I scrape only one app?

Yes. Put the direct Clio app listing URL in `startUrls` and set `maxItems` to `1`.

### FAQ

#### Does this actor need a Clio account?

No. It uses public directory pages and does not require login credentials.

#### Does it use a browser?

No. The actor is HTTP-first and parses server-rendered HTML with Cheerio.

#### Can I schedule it?

Yes. Schedule recurring Apify runs to monitor new Clio integrations or changes in categories and vendor links.

#### Can I export to CSV?

Yes. Apify datasets can be exported as CSV, JSON, Excel, XML, RSS, or HTML.

### Related scrapers

Explore other automation-lab actors for marketplace, app ecosystem, company, and lead-generation workflows:

- https://apify.com/automation-lab/zapier-scraper
- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/company-domain-to-linkedin-url-resolver

### Changelog

Initial version extracts Clio app directory listings and detail-page metadata with a lightweight Cheerio crawler.

### Notes

The target site is public and currently returns server-rendered HTML, so browser fallback is not required.

### Support

If a page layout changes or a field disappears, open an Apify issue with the run URL and example input.

# Actor input Schema

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

Clio App Directory listing pages, category URLs, pagination URLs, or direct app listing URLs.

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

Maximum Clio app listings to save. Keep this low for quick tests; raise it to crawl more directory pages.

## `includeDetails` (type: `boolean`):

Open each Clio app profile to extract vendor website, full description, categories, Clio products, availability, and screenshots.

## `category` (type: `string`):

Optional category text filter after details are loaded, for example AI and Automation, Text, Accounting, or Intake.

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

Optional keyword filter matched against app name, tagline, description, vendor, and categories.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.clio.com/app-directory/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}
```

# 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.clio.com/app-directory/"
        }
    ],
    "maxItems": 20,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/clio-app-directory-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.clio.com/app-directory/" }],
    "maxItems": 20,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/clio-app-directory-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.clio.com/app-directory/"
    }
  ],
  "maxItems": 20,
  "includeDetails": true
}' |
apify call automation-lab/clio-app-directory-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Clio App Directory Scraper",
        "description": "Extract Clio App Directory integrations, vendor websites, categories, products, pricing labels, logos, screenshots, and app descriptions.",
        "version": "0.1",
        "x-build-id": "KIBgov4JUtnVpX7lX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~clio-app-directory-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-clio-app-directory-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~clio-app-directory-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-clio-app-directory-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~clio-app-directory-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-clio-app-directory-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": "Clio App Directory listing pages, category URLs, pagination URLs, or direct app listing URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Clio app listings to save. Keep this low for quick tests; raise it to crawl more directory pages.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Visit app detail pages",
                        "type": "boolean",
                        "description": "Open each Clio app profile to extract vendor website, full description, categories, Clio products, availability, and screenshots.",
                        "default": true
                    },
                    "category": {
                        "title": "Category contains",
                        "type": "string",
                        "description": "Optional category text filter after details are loaded, for example AI and Automation, Text, Accounting, or Intake."
                    },
                    "keyword": {
                        "title": "Keyword contains",
                        "type": "string",
                        "description": "Optional keyword filter matched against app name, tagline, description, vendor, and categories."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```