# Australia ABN Business Register Scraper (`crawlerbros/australia-abn-business-register-scraper`) Actor

Search the Australian Business Register (ABN Lookup) by business name, ABN, or ACN. Get entity name, ABN status, entity type, GST registration status, state, postcode, trading names, and business names - for KYB, vendor verification, and sales-lead enrichment.

- **URL**: https://apify.com/crawlerbros/australia-abn-business-register-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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

## Australia ABN Business Register Scraper

Search the Australian Business Register (ABN Lookup, `abr.business.gov.au`) — Australia's official government registry of businesses. Look up any Australian business by name, ABN, or ACN and get its entity name, ABN status, entity type, GST registration status, state, postcode, trading names, and business names. No login, no API key, no proxy required.

### What this actor does

- **Search by business/entity name** — free-text search across entity names, business names, and trading names, with optional state and postcode filters
- **Lookup by ABN** — get the full current-details record for a specific Australian Business Number
- **Lookup by ACN** — get the full current-details record for a specific Australian Company Number (automatically resolved to its owning ABN)
- **Entity category filter** — restrict a name search to Deductible Gift Recipients (DGR) or organisations holding charity tax concessions, the same options as the register's own "Advanced search"
- **GST filter** — optionally restrict ABN/ACN lookups to GST-registered businesses only
- **Full pagination** — name searches walk every available results page (the register serves up to 200 matches per search), not just the first page
- **Empty fields are omitted** — every record only contains fields the register actually has data for

### Output per business

#### Name search (mode = `searchByName`)

- `entityName` — the matched name (entity, business, or trading name)
- `abn` — formatted ABN (`53 228 428 578`), `abnDigits` — unformatted 11 digits
- `abnStatus` — `Active` (name search only ever returns currently active ABNs)
- `nameType` — `Entity Name`, `Business Name`, or `Trading Name`
- `state`, `postcode` — registered location
- `abnUrl` — link to the full ABN Lookup detail page

#### ABN / ACN lookup (mode = `searchByAbn` / `searchByAcn`)

All of the above, plus:

- `abnStatusFromDate` — date the current ABN status took effect
- `entityType`, `entityTypeId` — e.g. `Australian Private Company`, `Individual/Sole Trader`
- `gstStatus` — `Registered` or `Not registered`, `gstFromDate` if registered
- `mainBusinessLocation` — raw location string when state/postcode can't be split out
- `tradingNames[]` — `{name, from}` — historical trading names (ABR stopped tracking these in 2012)
- `businessNames[]` — `{name, from, asicUrl}` — current ASIC-registered business names
- `dgrStatus` — deductible-gift-recipient status text
- `abnLastUpdated`, `recordExtracted` — register housekeeping dates

Every record also includes `recordType: "business"` and `scrapedAt`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `searchByName` | `searchByName` / `searchByAbn` / `searchByAcn` |
| `searchText` | string | `Telstra` | Name to search (mode=searchByName) |
| `nameSearchScope` | string | `all` | `all` / `entityName` / `businessName` / `tradingName` |
| `abn` | string | – | ABN, 11 digits (mode=searchByAbn) |
| `acn` | string | – | ACN, 9 digits (mode=searchByAcn) |
| `states` | array | `[]` | Filter to these states/territories (mode=searchByName) |
| `postcode` | string | – | Filter to this 4-digit postcode (mode=searchByName) |
| `entityCategory` | string | `all` | `all` / `dgr` (Deductible Gift Recipients) / `charity` (charity tax concession holders) — mode=searchByName |
| `gstRegisteredOnly` | boolean | `false` | Only emit GST-registered businesses (mode=searchByAbn/searchByAcn) |
| `maxItems` | integer | `50` | Hard cap on emitted records (1–200); `searchByName` pages through the register's full result set (up to 200) to reach it |

#### Example: search by name, restricted to Victoria

```json
{
  "mode": "searchByName",
  "searchText": "Telstra",
  "states": ["VIC"],
  "maxItems": 20
}
````

#### Example: lookup by ABN

```json
{
  "mode": "searchByAbn",
  "abn": "88 000 014 675"
}
```

#### Example: lookup by ACN

```json
{
  "mode": "searchByAcn",
  "acn": "000 014 675"
}
```

#### Example: search for charities/DGRs by name

```json
{
  "mode": "searchByName",
  "searchText": "Red Cross",
  "entityCategory": "charity",
  "maxItems": 20
}
```

### Use cases

- **KYB / vendor verification** — confirm an Australian counterparty's ABN is active and check its registered entity type before onboarding
- **Sales-lead enrichment** — attach ABN, entity type, GST status, and location to a list of Australian company names
- **Compliance checks** — verify GST registration status for invoicing/tax purposes
- **Company research** — pull trading names and registered business names for a target entity
- **Due diligence** — cross-check ABN status (active/cancelled) before signing a contract

### FAQ

**What's the ABN Lookup / Australian Business Register?** The free, public government registry run by the Australian Taxation Office where every Australian business with an ABN is listed. See [abr.business.gov.au](https://abr.business.gov.au).

**What's the difference between an ABN and an ACN?** An ABN (Australian Business Number, 11 digits) identifies any entity dealing with the Australian tax system — companies, sole traders, trusts, partnerships. An ACN (Australian Company Number, 9 digits) is issued only to registered companies by ASIC; a company's ABN is derived from its ACN plus a 2-digit checksum prefix. Looking up an ACN in this actor automatically resolves it to the matching ABN record.

**Why does `searchByName` only return `Active` statuses?** The register's name-search index only covers currently active ABNs; it's the same behaviour as the public ABN Lookup website's default search.

**Why are `entityType` values so specific (e.g. "Commonwealth Government Discretionary Trading Trust")?** These are the ATO's own ~140 official entity-type classifications, passed through verbatim from the register.

**Why is `tradingNames` sometimes empty for company ABNs?** The ABR stopped collecting trading names in May 2012; only trading names registered before then are still shown. Businesses now use ASIC's national Business Names Register instead — that data appears in `businessNames[]`.

**How fresh is the data?** The register is updated by the ATO continuously; the actor scrapes the live page on every run.

**What does `entityCategory` actually filter?** It matches the ABN Lookup's own "Advanced search" radio options: `dgr` restricts to entities endorsed as Deductible Gift Recipients, `charity` restricts to entities with an active charity tax concession endorsement (income tax exemption and/or FBT/GST charity concessions). Both are official ATO endorsement categories, not derived data.

**Why can `searchByName` return more than one page's worth of results?** The register shows 40 rows per page and caps a single search at 200 total matches; the actor walks every available page (up to `maxItems`) instead of stopping after the first page, so a broad query like a common brand name returns its full available result set.

# Actor input Schema

## `mode` (type: `string`):

What to look up.

## `searchText` (type: `string`):

Free-text business, entity, or trading name to search for.

## `nameSearchScope` (type: `string`):

Which name fields to match against. `All names` searches entity, business, and trading names together.

## `abn` (type: `string`):

Australian Business Number, 11 digits (spaces/dashes are ignored), e.g. `88 000 014 675`.

## `acn` (type: `string`):

Australian Company Number, 9 digits (spaces/dashes are ignored), e.g. `000 014 675`.

## `states` (type: `array`):

Restrict search results to these Australian states/territories. Leave empty for all states.

## `postcode` (type: `string`):

Restrict search results to this 4-digit Australian postcode.

## `entityCategory` (type: `string`):

Restrict the name search to a special ATO-endorsed category instead of all active ABNs: Deductible Gift Recipients (DGR) or organisations with charity tax concessions. Matches the register's own "Advanced search" radio options.

## `gstRegisteredOnly` (type: `boolean`):

Only emit the record if the business is currently registered for GST. Applies only to mode=searchByAbn and mode=searchByAcn (GST status isn't shown on name-search result rows).

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

Hard cap on emitted records (mode=searchByName can return many matches; ABN/ACN lookups return at most 1).

## Actor input object example

```json
{
  "mode": "searchByName",
  "searchText": "Telstra",
  "nameSearchScope": "all",
  "states": [],
  "entityCategory": "all",
  "gstRegisteredOnly": false,
  "maxItems": 50
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped ABN Lookup records.

# 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 = {
    "mode": "searchByName",
    "searchText": "Telstra",
    "nameSearchScope": "all",
    "states": [],
    "entityCategory": "all",
    "gstRegisteredOnly": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/australia-abn-business-register-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 = {
    "mode": "searchByName",
    "searchText": "Telstra",
    "nameSearchScope": "all",
    "states": [],
    "entityCategory": "all",
    "gstRegisteredOnly": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/australia-abn-business-register-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 '{
  "mode": "searchByName",
  "searchText": "Telstra",
  "nameSearchScope": "all",
  "states": [],
  "entityCategory": "all",
  "gstRegisteredOnly": false,
  "maxItems": 50
}' |
apify call crawlerbros/australia-abn-business-register-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Australia ABN Business Register Scraper",
        "description": "Search the Australian Business Register (ABN Lookup) by business name, ABN, or ACN. Get entity name, ABN status, entity type, GST registration status, state, postcode, trading names, and business names - for KYB, vendor verification, and sales-lead enrichment.",
        "version": "1.0",
        "x-build-id": "JzBzKpemrtEcYewXj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~australia-abn-business-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-australia-abn-business-register-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/crawlerbros~australia-abn-business-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-australia-abn-business-register-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/crawlerbros~australia-abn-business-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-australia-abn-business-register-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "searchByName",
                            "searchByAbn",
                            "searchByAcn"
                        ],
                        "type": "string",
                        "description": "What to look up.",
                        "default": "searchByName"
                    },
                    "searchText": {
                        "title": "Business/entity name (mode=searchByName)",
                        "type": "string",
                        "description": "Free-text business, entity, or trading name to search for.",
                        "default": "Telstra"
                    },
                    "nameSearchScope": {
                        "title": "Name search scope (mode=searchByName)",
                        "enum": [
                            "all",
                            "entityName",
                            "businessName",
                            "tradingName"
                        ],
                        "type": "string",
                        "description": "Which name fields to match against. `All names` searches entity, business, and trading names together.",
                        "default": "all"
                    },
                    "abn": {
                        "title": "ABN (mode=searchByAbn)",
                        "type": "string",
                        "description": "Australian Business Number, 11 digits (spaces/dashes are ignored), e.g. `88 000 014 675`."
                    },
                    "acn": {
                        "title": "ACN (mode=searchByAcn)",
                        "type": "string",
                        "description": "Australian Company Number, 9 digits (spaces/dashes are ignored), e.g. `000 014 675`."
                    },
                    "states": {
                        "title": "Filter by state/territory (mode=searchByName)",
                        "type": "array",
                        "description": "Restrict search results to these Australian states/territories. Leave empty for all states.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "ACT",
                                "NSW",
                                "NT",
                                "QLD",
                                "SA",
                                "TAS",
                                "VIC",
                                "WA"
                            ],
                            "enumTitles": [
                                "Australian Capital Territory",
                                "New South Wales",
                                "Northern Territory",
                                "Queensland",
                                "South Australia",
                                "Tasmania",
                                "Victoria",
                                "Western Australia"
                            ]
                        },
                        "default": []
                    },
                    "postcode": {
                        "title": "Filter by postcode (mode=searchByName)",
                        "type": "string",
                        "description": "Restrict search results to this 4-digit Australian postcode."
                    },
                    "entityCategory": {
                        "title": "Entity category filter (mode=searchByName)",
                        "enum": [
                            "all",
                            "dgr",
                            "charity"
                        ],
                        "type": "string",
                        "description": "Restrict the name search to a special ATO-endorsed category instead of all active ABNs: Deductible Gift Recipients (DGR) or organisations with charity tax concessions. Matches the register's own \"Advanced search\" radio options.",
                        "default": "all"
                    },
                    "gstRegisteredOnly": {
                        "title": "GST-registered only",
                        "type": "boolean",
                        "description": "Only emit the record if the business is currently registered for GST. Applies only to mode=searchByAbn and mode=searchByAcn (GST status isn't shown on name-search result rows).",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on emitted records (mode=searchByName can return many matches; ABN/ACN lookups return at most 1).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
