# AliExpress \[Only $0.8💰] Products, Prices & Discounts Scraper (`memo23/aliexpress-scraper`) Actor

\[Only 💰$0.8/1k] AliExpress scraper — the cheapest way to extract products by keyword or URL. Get price, discount, sold count, rating, image, tags & store as clean JSON or CSV. Handles product, search, mobile & regional URLs, app deep links & share links. No login, English + USD.

- **URL**: https://apify.com/memo23/aliexpress-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 15 total users, 15 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.65 / 1,000 product scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## AliExpress Scraper — Products, Prices, Discounts & Ratings

Extract structured product data from **AliExpress** at scale — prices, discounts, sold counts, ratings, images and store details — by keyword or URL, from just **$0.8 / 1,000 results**. No login, no cookies, no browser. Clean JSON or CSV out.

![How it works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-aliexpress.png)

### Why use this AliExpress Scraper?

- **Search by keyword or paste any URL** — product pages, search/wholesale pages, mobile & regional domains, even AliExpress app deep links and short share links are all handled.
- **Rich data straight from search** — price, original price, discount %, sold count, rating, image and promo tags on every row, no detail fetch required.
- **Consistent English + USD output** — locale is pinned server-side, so prices and titles don't drift with proxy location.
- **Built for scale** — pagination (60 products/page), residential-proxy rotation, and automatic retry through AliExpress's anti-bot.
- **One clean row per product** — you pay per result, never for padding.

### Overview

AliExpress is one of the largest global marketplaces, with hundreds of millions of listings across electronics, fashion, home, tools and more. This scraper turns any AliExpress search or product URL into structured data you can use for **price monitoring, product research, dropshipping sourcing, competitor analysis, and market intelligence**.

It runs on a pure HTTP stack (no headless browser), reads the product data AliExpress embeds in its own search pages, and returns it as tidy JSON/CSV — fast and cheap.

### Supported inputs

| Input type | Example |
|---|---|
| Keyword search | `wireless earbuds`, `mechanical keyboard` |
| Product URL | `https://www.aliexpress.com/item/1005009437537145.html` |
| Search / wholesale URL | `https://www.aliexpress.com/w/wholesale-drone.html` |
| Mobile / regional domain | `https://m.aliexpress.com/item/...`, `https://de.aliexpress.com/item/...`, `aliexpress.us` |
| App deep link | `aliexpress://productDetail?productId=1005009437537145` |
| Short share link | `https://a.aliexpress.com/_mNxYzAb` |

All URL formats are auto-normalized to the canonical product/search URL.

### Use cases

- **Price monitoring & repricing** — track sale price, original price and discount over time.
- **Dropshipping product sourcing** — find high-sold, high-rated products and their stores.
- **Competitor & market research** — map what sells in a category, at what price, with what ratings.
- **Catalog building** — pull titles, images and prices for thousands of products by keyword.
- **Deal & trend discovery** — surface the biggest discounts and best-selling items in any niche.

### How it works

1. You provide keyword searches and/or AliExpress URLs.
2. The scraper builds canonical wholesale-search URLs and normalizes any pasted links (deep links, share links, mobile/regional domains) to the web form.
3. It fetches each search page through a residential proxy with a warmed, locale-pinned session, and reads the product list AliExpress embeds in the page.
4. Results are paginated (60 products per page) up to your **Max items** limit.
5. Optionally, each product's detail page is fetched for description, specs, the full image gallery and store info.
6. Every product is written to the dataset as one clean row.

### Input configuration

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Keywords to search on AliExpress. Each is paginated up to `maxItems`. |
| `startUrls` | array | Direct product / search / mobile / regional / deep-link / share-link URLs. |
| `scrapeDetails` | boolean | Fetch each product's item page for description, specs, images and store (slower, one request per product). Default `false`. |
| `maxItems` | integer | Hard cap on products returned. Default `100`. |
| `maxConcurrency` | integer | Parallel detail fetches (only when `scrapeDetails` is on). Default `8`. |
| `proxy` | object | Proxy config. **Residential is required** — AliExpress blocks datacenter IPs. |

### Output overview

Each product is one dataset row with price, discount, sales, rating, image, store and promo data. Search-level runs populate the core commerce fields; enable `scrapeDetails` to add description, specs, gallery and store.

### Output sample

```json
{
  "productId": "3256811844384040",
  "title": "2026 New TWS Wireless Earphones with Bluetooth 5.4 Gaming Headset Sport Earbuds with LED Display",
  "productUrl": "https://www.aliexpress.com/item/3256811844384040.html",
  "image": "https://ae-pic-a1.aliexpress-media.com/kf/S0e29ca8ecde64e12a58e4c939d28ce3eZ.jpg",
  "salePrice": "US $13.44",
  "salePriceValue": 13.44,
  "originalPrice": "US $41.13",
  "currency": "USD",
  "discountPct": 67,
  "soldCount": "1,000+ sold",
  "rating": 4.9,
  "reviewCount": null,
  "storeName": null,
  "storeUrl": null,
  "tags": ["New shoppers save $27.69", "Free shipping"],
  "sourceQuery": "wireless earbuds",
  "scrapedAt": "2026-07-21T11:19:02.413Z"
}
````

### Key output fields

| Field | Description |
|---|---|
| `productId` | AliExpress product ID |
| `title` | Product title |
| `productUrl` | Canonical product URL |
| `salePrice` / `salePriceValue` | Current price (formatted + numeric) |
| `originalPrice` | Pre-discount price |
| `currency` | Currency code (USD by default) |
| `discountPct` | Discount percentage |
| `soldCount` | Units sold (e.g. "1,000+ sold") |
| `rating` | Star rating (0–5) |
| `image` | Primary product image |
| `tags` | Promo / shipping badges |
| `storeName` / `storeUrl` | Seller store *(with `scrapeDetails`)* |
| `description` / `specs` / `images` | Detail fields *(with `scrapeDetails`)* |

### FAQ

**Do I need cookies or a login?** No. The scraper is fully no-login, no-cookies.

**Why are `storeName` and `reviewCount` null?** They aren't included in AliExpress search results — enable `scrapeDetails` to fetch them from each product page.

**Do I need residential proxies?** Yes. AliExpress blocks datacenter IPs; the actor ships with a working residential pool by default.

**What currency / language do I get?** English titles and USD prices by default — pinned server-side regardless of proxy location.

**How many products per search?** 60 per page; it paginates automatically up to your `maxItems`.

### Support

Found a bug or need a field added? Open an issue on the actor's **Issues** tab and it'll be looked at quickly.

### Additional services

Need this data enriched, on a schedule, or pushed to your warehouse/webhook? Reach out via the Issues tab — custom fields, monitoring runs and integrations are available.

### Explore more scrapers

Check the publisher profile for more e-commerce and marketplace scrapers, including AliExpress's sister marketplaces and other product catalogs.

### 🤖 For AI Agents & LLM Apps

This actor returns clean, flat JSON ideal for RAG pipelines and agent tool-calling: one product per row, stable field names, numeric price fields (`salePriceValue`, `discountPct`, `rating`) ready for filtering and ranking without post-processing. Point your agent at a keyword or a product URL and get structured commerce data back.

### ⚠️ Disclaimer

This scraper collects only publicly available data from AliExpress. It does not log in, bypass authentication, or access private data. You are responsible for using the scraped data in compliance with AliExpress's terms, applicable laws (including copyright and data-protection regulations), and for any downstream use. Use responsibly.

### SEO Keywords

AliExpress scraper, AliExpress API, AliExpress product scraper, AliExpress price scraper, scrape AliExpress, AliExpress data extraction, AliExpress product data, dropshipping scraper, AliExpress search scraper, AliExpress listings, product price monitoring, e-commerce scraper, AliExpress ratings, AliExpress sold count, AliExpress store scraper, marketplace scraper, AliExpress crawler, AliExpress JSON, AliExpress CSV export.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on AliExpress (e.g. "wireless earbuds", "mechanical keyboard"). Each becomes a wholesale search and is paginated (60 products per page) up to your Max items limit.

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

Direct AliExpress URLs. Accepts product pages (`/item/<id>.html`), search/wholesale pages (`/w/wholesale-...`), mobile & regional domains (`m.`, `de.`, `aliexpress.us`), app deep links (`aliexpress://...`) and short share links (`a.aliexpress.com/_xxx`). All are auto-normalized.

## `scrapeDetails` (type: `boolean`):

When enabled, each product's item page is fetched to add description, specifications, the full image gallery and store details. Adds one HTTP request per product — slower and costlier — so leave off if the search-level fields are enough.

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

Hard cap on the number of products returned across all queries and URLs. One search page yields up to 60 products; raise this to paginate deeper.

## `maxConcurrency` (type: `integer`):

Maximum number of detail pages fetched in parallel (only relevant when "Scrape product detail pages" is on).

## `proxy` (type: `object`):

Residential proxies are REQUIRED — AliExpress blocks datacenter IPs. The actor ships with a working residential pool by default; override here only if you have your own residential proxy.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [],
  "scrapeDetails": false,
  "maxItems": 100,
  "maxConcurrency": 8,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "startUrls": [],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/aliexpress-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 = {
    "searchQueries": ["wireless earbuds"],
    "startUrls": [],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/aliexpress-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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "startUrls": [],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/aliexpress-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AliExpress [Only $0.8💰] Products, Prices & Discounts Scraper",
        "description": "[Only 💰$0.8/1k] AliExpress scraper — the cheapest way to extract products by keyword or URL. Get price, discount, sold count, rating, image, tags & store as clean JSON or CSV. Handles product, search, mobile & regional URLs, app deep links & share links. No login, English + USD.",
        "version": "0.0",
        "x-build-id": "x18HYhYgah54oCIo9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~aliexpress-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-aliexpress-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/memo23~aliexpress-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-aliexpress-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/memo23~aliexpress-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-aliexpress-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search on AliExpress (e.g. \"wireless earbuds\", \"mechanical keyboard\"). Each becomes a wholesale search and is paginated (60 products per page) up to your Max items limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Direct AliExpress URLs. Accepts product pages (`/item/<id>.html`), search/wholesale pages (`/w/wholesale-...`), mobile & regional domains (`m.`, `de.`, `aliexpress.us`), app deep links (`aliexpress://...`) and short share links (`a.aliexpress.com/_xxx`). All are auto-normalized.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "scrapeDetails": {
                        "title": "Scrape product detail pages (description, specs, images, store)",
                        "type": "boolean",
                        "description": "When enabled, each product's item page is fetched to add description, specifications, the full image gallery and store details. Adds one HTTP request per product — slower and costlier — so leave off if the search-level fields are enough.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the number of products returned across all queries and URLs. One search page yields up to 60 products; raise this to paginate deeper.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of detail pages fetched in parallel (only relevant when \"Scrape product detail pages\" is on).",
                        "default": 8
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are REQUIRED — AliExpress blocks datacenter IPs. The actor ships with a working residential pool by default; override here only if you have your own residential proxy."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
