# Tech Stack Profiler (`crawlerbros/tech-stack-profiler`) Actor

Detect 200+ web technologies powering any domain with CMS, frameworks, analytics, CDN, eCommerce, payment, hosting, databases, search, security. Bulk-profile domains in parallel using open-source signatures. Free BuiltWith alternative. HTTP-only, no proxy, no API key.

- **URL**: https://apify.com/crawlerbros/tech-stack-profiler.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 21 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Tech Stack Profiler

Detect 330+ web technologies powering any domain — CMS, frameworks, analytics, CDN, eCommerce, payment processors, hosting, databases, search, security, AI assistants, Web3 wallets, customer-support tools, and more. Bulk-profile a list of domains in parallel using open-source web-tech signature patterns. Each detection surfaces the **signal types** that matched (headers / cookies / scripts / meta / html) so you can rank results by evidence strength. **Free BuiltWith alternative** — HTTP-only, no proxy, no cookies, no API key.

### What it does

You provide a list of domains; the actor:

1. Fetches `https://<domain>/` for each (in parallel, with configurable concurrency).
2. Matches every fetched page against a curated signature database covering CMS / Framework / Analytics / Tag Manager / Advertising / CDN / Hosting / Web Server / Programming Language / eCommerce / Payment / Customer Support / Marketing / A/B Testing / Font Script / Search / Security / Performance / Scheduling / Forms / Comments / Cookie Compliance.
3. Surfaces:
   - The full **`technologies`** list (`name`, `category`, `version` when detectable, `confidence`, `website`).
   - **Aggregated category labels** (`categoriesDetected`).
   - **Top-of-stack shortcuts** — `cmsName`, `frameworkName`, `cdnProvider`, `webServer`, `hostingProvider`, `analyticsTools`.
   - Optional **meta tags** (title, description, Open Graph, Twitter Cards).

Empty fields are omitted (no nulls). Failed fetches surface an `error` field with the exception type instead of crashing the run.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `domains` | array of strings (required) | `["apify.com"]` | List of domains. Accepts bare hostnames (`apify.com`) or full URLs (`https://apify.com/path`). |
| `concurrency` | integer | `5` (1–20) | Number of domains fetched in parallel. |
| `extractMetaTags` | boolean | `true` | Also pull page title, meta description, Open Graph + Twitter Card tags. |
| `categoryFilter` | array of enums | `[]` | Restrict detection to specific categories (`CMS`, `Framework`, `Analytics`, `CDN`, `Hosting`, `eCommerce`, `Payment Processor`, etc.). Empty = all. |
| `userAgent` | string (optional) | (Chrome 131) | Override the default User-Agent. Only needed if a target site filters by UA. |

#### Example input

```json
{
  "domains": ["apify.com", "shopify.com", "github.com"],
  "concurrency": 5,
  "extractMetaTags": true,
  "categoryFilter": []
}
````

### Output

One record per domain. Empty fields are omitted (no nulls).

```json
{
  "domain": "apify.com",
  "url": "https://apify.com/",
  "httpStatus": 200,
  "responseTimeMs": 425,
  "title": "Apify: Full-stack web scraping and data extraction platform",
  "description": "Cloud platform for web scraping…",
  "metaTags": {
    "title": "Apify: Full-stack web scraping and data extraction platform",
    "description": "Cloud platform for web scraping…",
    "ogTags": {
      "image": "https://apify.com/og-image.jpg",
      "type": "website"
    },
    "twitterTags": {
      "card": "summary_large_image"
    }
  },
  "technologies": [
    {"name": "Amazon CloudFront", "category": "CDN", "categories": ["CDN"], "confidence": 100, "signals": ["headers"], "website": "https://aws.amazon.com/cloudfront"},
    {"name": "Google Tag Manager", "category": "Tag Manager", "categories": ["Tag Manager"], "confidence": 100, "signals": ["html"], "website": "https://tagmanager.google.com"},
    {"name": "Next.js", "category": "JavaScript Framework", "categories": ["JavaScript Framework", "Framework"], "confidence": 100, "signals": ["headers", "html"], "website": "https://nextjs.org"}
  ],
  "technologyCount": 3,
  "categoriesDetected": ["Analytics", "CDN", "Framework"],
  "categoryCount": 3,
  "frameworkName": "Next.js",
  "cdnProvider": "Amazon CloudFront",
  "scrapedAt": "2024-12-16T14:23:11+00:00"
}
```

#### Output fields

- **`domain`** — normalised hostname (lowercase, no scheme, no www).
- **`url`** — final URL after redirect chain (e.g. `https://www.apify.com/` → `https://apify.com/`).
- **`httpStatus`** — HTTP status code returned (200 = success).
- **`responseTimeMs`** — round-trip fetch time in milliseconds.
- **`title`** / **`description`** — `<title>` and `<meta name="description">` (when `extractMetaTags: true`).
- **`metaTags`** — nested block with `title`, `description`, `ogTags`, `twitterTags` (when `extractMetaTags: true`).
- **`technologies`** — array of `{name, category, categories[], confidence, signals[], website, version?}`. Sorted alphabetically.
- **`signals[]`** — which evidence types matched the signature: any combination of `"headers"`, `"cookies"`, `"scripts"`, `"meta"`, `"html"`. A 2- or 3-signal hit is dramatically more reliable than a 1-signal hit.
- **`technologyCount`** — count of detected technologies.
- **`categoriesDetected`** — sorted list of grouped category labels (e.g. CMS, Framework, Analytics, CDN, Hosting, eCommerce, Payment).
- **`categoryCount`** — number of distinct categories.
- **`cmsName`** — first detected technology in the CMS category (e.g. `WordPress`, `Shopify`, `Webflow`).
- **`frameworkName`** — first detected technology in Framework / JavaScript Framework category (e.g. `Next.js`, `Nuxt.js`, `Astro`, `Gatsby`).
- **`cdnProvider`** — first detected technology in the CDN category (`Cloudflare`, `Amazon CloudFront`, `Fastly`, `Akamai`).
- **`webServer`** — first detected technology in Web Server category (`nginx`, `Apache`, `LiteSpeed`).
- **`hostingProvider`** — first detected technology in Hosting / PaaS category (`Vercel`, `Netlify`, `Heroku`).
- **`analyticsTools`** — every analytics tool detected (e.g. `["Google Analytics", "Hotjar"]`).
- **`error`** — fetch-failure reason (only when the request errored — DNS, timeout, TLS, etc.).
- **`scrapedAt`** — ISO-8601 UTC timestamp.

### Use cases

- **Lead enrichment** — fingerprint a list of company websites for CRM enrichment (which CMS / hosting / payment processor each uses).
- **Competitive research** — pull tech stacks for every competitor in a market in one run.
- **Sales targeting** — find every Shopify / WordPress / Webflow site in a domain list.
- **Migration audits** — confirm a site is still running the expected stack after a deploy.
- **Tech-stack market share** — sample thousands of domains to compute CMS/framework adoption rates.

### FAQ

**Does it need a proxy or cookies?**
No. The actor uses Chrome 131 TLS-fingerprint impersonation and connects directly from datacenter IPs. Any site behind aggressive bot protection (Cloudflare bot-fight on hard mode, etc.) may block; those records get `error` set and are skipped from detection.

**Is this BuiltWith?**
It's a free **alternative**. The signature set is curated from open-source web-tech patterns (originating from the [Wappalyzer](https://www.wappalyzer.com) project) and shipped inline (no external API calls). BuiltWith covers ~50,000 technologies in their paid product; this actor focuses on ~270 high-confidence common ones (the ones that actually matter for most use cases).

**Why are some technologies not detected?**
The actor only sees the **server-rendered HTML** + response headers. A pure client-side React app may render content via JS post-load, which the actor doesn't observe. For deep JS-execution-based detection, run a Playwright-based actor instead.

**How accurate is the version detection?**
Version strings are extracted opportunistically from `Server` headers, `meta generator` tags, and a few signature regexes. About 30–40% of detections include a `version`; the rest only have a `name`.

**Can I detect more technologies?**
The current signature set ships ~330 high-confidence patterns. Adding more is easy — extend `src/signatures.py`. The infrastructure already supports headers / cookies / scripts / meta / HTML matchers, version groups, and version fallback parsed from common script-URL conventions (e.g. `jquery-3.6.0.min.js` → `3.6.0`).

**What happens when a domain is unreachable?**
The actor emits one record with `error` populated (e.g. `error: "ConnectionError"`) and `technologies` omitted. The run keeps going for the rest of the domains.

**How is the input deduplicated?**
By normalised hostname (lowercase, no scheme/www/path/port). `https://apify.com/about` and `WWW.APIFY.COM` collapse to the same `apify.com` record.

**Why does my domain show only 1–2 technologies?**
Common causes: aggressive bot blocking (the actor only got an HTTP-challenge page), client-rendered single-page app (we only see the empty shell), or a static page that genuinely uses very few traceable technologies.

# Actor input Schema

## `domains` (type: `array`):

List of domains. Accepts bare hostnames (`apify.com`) or full URLs (`https://apify.com/about`). The actor extracts the registrable domain.

## `concurrency` (type: `integer`):

Number of domains fetched in parallel.

## `extractMetaTags` (type: `boolean`):

Also pull page title, meta description, Open Graph tags, and Twitter Cards.

## `categoryFilter` (type: `array`):

Restrict detection to specific categories. Empty = all categories.

## `userAgent` (type: `string`):

Override the default Chrome 131 User-Agent. Only needed if a target site filters on UA.

## Actor input object example

```json
{
  "domains": [
    "apify.com"
  ],
  "concurrency": 5,
  "extractMetaTags": true,
  "categoryFilter": []
}
```

# 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 = {
    "domains": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/tech-stack-profiler").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 = { "domains": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/tech-stack-profiler").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 '{
  "domains": [
    "apify.com"
  ]
}' |
apify call crawlerbros/tech-stack-profiler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tech Stack Profiler",
        "description": "Detect 200+ web technologies powering any domain with CMS, frameworks, analytics, CDN, eCommerce, payment, hosting, databases, search, security. Bulk-profile domains in parallel using open-source signatures. Free BuiltWith alternative. HTTP-only, no proxy, no API key.",
        "version": "0.1",
        "x-build-id": "tlVaNhTHWC3quOMh7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~tech-stack-profiler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-tech-stack-profiler",
                "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/crawlerbros~tech-stack-profiler/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-tech-stack-profiler",
                "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/crawlerbros~tech-stack-profiler/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-tech-stack-profiler",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "domains"
                ],
                "properties": {
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "List of domains. Accepts bare hostnames (`apify.com`) or full URLs (`https://apify.com/about`). The actor extracts the registrable domain.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of domains fetched in parallel.",
                        "default": 5
                    },
                    "extractMetaTags": {
                        "title": "Extract meta tags",
                        "type": "boolean",
                        "description": "Also pull page title, meta description, Open Graph tags, and Twitter Cards.",
                        "default": true
                    },
                    "categoryFilter": {
                        "title": "Category filter",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict detection to specific categories. Empty = all categories.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "CMS",
                                "Static Site Generator",
                                "Framework",
                                "JavaScript Framework",
                                "JavaScript Library",
                                "UI Framework",
                                "Analytics",
                                "Tag Manager",
                                "Advertising",
                                "CDN",
                                "Image CDN",
                                "Hosting",
                                "PaaS",
                                "Web Server",
                                "Programming Language",
                                "Database",
                                "Search Engine",
                                "Marketing Automation",
                                "Email Marketing",
                                "Customer Support",
                                "Live Chat",
                                "Payment Processor",
                                "eCommerce",
                                "A/B Testing",
                                "Personalization",
                                "Font Script",
                                "Forms",
                                "Scheduling",
                                "Comments",
                                "Cookie Compliance",
                                "Authentication",
                                "CRM",
                                "Reviews",
                                "Loyalty",
                                "Push Notifications",
                                "Translation",
                                "Maps",
                                "Charting Library",
                                "Rich Text Editor",
                                "Video",
                                "Security",
                                "Performance",
                                "Wallet",
                                "AI",
                                "Documentation",
                                "Progressive Web App"
                            ]
                        },
                        "default": []
                    },
                    "userAgent": {
                        "title": "User-Agent (optional)",
                        "type": "string",
                        "description": "Override the default Chrome 131 User-Agent. Only needed if a target site filters on UA."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```