# USPTO Patent Scraper (`devilscrapes/uspto-patents-scraper`) Actor

Search US issued patents via the official USPTO Patents Public Search API — patent number, title, abstract, inventors, assignee, classifications, priority, filing, and grant dates — bulk export to JSON or CSV. Free, no key, no login.

- **URL**: https://apify.com/devilscrapes/uspto-patents-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## USPTO Patent Scraper

**💰 $3.00 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We do the dirty work so your dataset stays clean._ 😈

Search US issued patents via the official Patents Public Search API. Returns patent number, title, abstract, inventors, assignee, CPC/IPC classifications, priority date, filing date, and grant date — clean typed rows, ready to export.

</div>

---

### 🎯 What this scrapes

The USPTO Patents Public Search API (`developer.uspto.gov/ds-api/patents`) is technically free but punishing — quirky XML responses, an under-documented throttle, and a query syntax (`TI/<text>`, `AN/<assignee>`, `IN/<inventor>`) that bites first-timers. This Actor wraps the search endpoint, handles pagination safely, and writes one structured row per patent. No account, no key, no quota to manage on your end.

Every request runs through our fingerprint-rotating HTTP stack so the API sees consistent, well-behaved traffic — the kind that keeps your runs off the block-list.

### 🔥 Features

- 🛡️ **Browser fingerprint rotation** — `curl-cffi` replays real Chrome / Firefox / Safari TLS handshakes. The target sees a real browser, not a Python script.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP whenever the endpoint pushes back.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts per page; `Retry-After` headers are honoured.
- 🧱 **Rate-limit-aware pacing** — we slow down before the API cuts us off, not after.
- 🧊 **Clean, typed dataset rows** — Pydantic-validated fields, ISO-8601 timestamps, stable IDs. Export to JSON, CSV, or Excel straight from Apify Console.
- 💰 **Pay-Per-Event pricing** — you pay only when results land in your dataset. No data, no charge (only the small `actor-start` warm-up fee).

### 💡 Use cases

- **IP-landscape monitoring** — schedule weekly runs against a competitor's assignee name and diff the output to catch new filings before they publish in trade press.
- **Freedom-to-operate (FTO) research** — query by CPC class to surface all patents relevant to a new product before you build.
- **Patent assignee scraper workflow** — pull a company's full portfolio, pivot by inventor, assignee, or classification, and feed downstream analysis pipelines.
- **Inventor tracking** — follow a key researcher or prolific inventor across employers and publication windows.
- **M&A / acquisition diligence** — quantify and categorise a target's patent assets in minutes instead of hours inside expensive IP databases.
- **Academic patent-statistics research** — feed a corpus of patent abstracts, classification codes, and grant dates into NLP / citation-analysis workflows.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. Fill in the input form — `searchQuery` is the only required field; all others have sensible defaults.
3. Click **Start**. Results stream into the run's dataset in real time.
4. When the run finishes, open **Storage → Dataset** to export as JSON, CSV, or Excel — or pull rows via the Apify API.

**Query syntax tips:**

- `TI/(neural network)` — title field only
- `AN/Apple` — assignee name
- `IN/Hinton` — inventor surname
- Combine with `AND` / `OR`: `TI/(transformer) AND AN/Google`

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `searchQuery` | `string` | **yes** | `neural network training` | Free-text or field-qualified query. Use `TI/`, `AN/`, `IN/` qualifiers to narrow scope. |
| `maxResults` | `integer` | no | `30` | Total patents to return across all pages. Max 2 000 per run. |
| `sortBy` | `string` | no | `relevance` | `relevance`, `publication_date_desc`, or `publication_date_asc`. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": false}` | Apify Proxy configuration. Direct calls work fine; enable proxy if you hit rate limits. |

#### Example input

```json
{
  "searchQuery": "TI/(neural network)",
  "maxResults": 3,
  "sortBy": "publication_date_desc",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### 📤 Output

Every row is one dataset item.

| Field | Type | Notes |
|---|---|---|
| `patent_number` | `string` | Patent or publication number (without country prefix). |
| `publication_id` | `string` | Internal Patents Public Search publication ID. |
| `title` | `string` | Patent title. |
| `abstract` | `string \| null` | Patent abstract text. |
| `inventors` | `array` | Inventor names. |
| `assignees` | `array` | Assignee organisations. |
| `applicants` | `array` | Applicants listed on the filing. |
| `cpc_classifications` | `array` | CPC classification codes. |
| `ipc_classifications` | `array` | IPC classification codes. |
| `publication_date` | `string \| null` | Publication date (YYYY-MM-DD). |
| `grant_date` | `string \| null` | Grant date if granted. |
| `filing_date` | `string \| null` | Filing date. |
| `priority_date` | `string \| null` | Priority date. |
| `kind_code` | `string \| null` | Kind code (B1, A1, etc.). |
| `patent_url` | `string` | USPTO Patents Public Search URL for the full document. |
| `scraped_at` | `string` | ISO-8601 timestamp when this row was recorded. |

#### Example output

```json
{
  "patent_number": "11,948,025",
  "title": "System and method for training neural networks",
  "abstract": "A method for training a neural network comprising...",
  "inventors": ["Jane Smith", "John Doe"],
  "assignees": ["Example Corp"],
  "cpc_classifications": ["G06N 3/08", "G06N 20/00"],
  "publication_date": "2024-04-02",
  "grant_date": "2024-04-02",
  "filing_date": "2021-09-15",
  "priority_date": "2021-09-15",
  "kind_code": "B2",
  "patent_url": "https://ppubs.uspto.gov/pubwebapp/external.html?db=USPAT&docId=11948025",
  "scraped_at": "2026-06-01T12:00:00Z"
}
```

### 💰 Pricing

Pay-Per-Event — you pay only when these events fire:

| Event | USD | What it is |
|---|---:|---|
| `actor-start` | $0.005 | One-off warm-up charge per run |
| `result` | $0.003 | Per dataset item written |

Example: 1 000 results at the rates above ≈ **$3.00**. No subscription, no minimum — Apify gives every new account $5 of free credit to start. Commercial IP databases charge $10 000+/seat/year for the same underlying public data.

### 🚧 Limitations

- **Result ordering** is controlled by USPTO Patents Public Search internally; we pass your `sortBy` preference but the ranking algorithm is theirs.
- **Inventor address details** (city, state) and **full claims text** require follow-up document calls and are not included in this Actor. The `patent_url` field links directly to the full patent document.
- **Patent family members** (foreign equivalents, continuations) are not surfaced — USPTO's cross-reference data requires a separate API call sequence.
- **Publication cadence** — the USPTO typically publishes new grants on Tuesdays; new filings appear in the Patents Public Search API within approximately one week of publication. This is not a real-time stream.
- **Legal disclaimer** — this tool retrieves public patent metadata for research purposes. It is not a substitute for professional patent counsel. Always consult a registered patent attorney for FTO opinions, invalidity analysis, or litigation strategy.

### ❓ FAQ

**What is the USPTO Patents Public Search API?**

The Patents Public Search API (`developer.uspto.gov/ds-api/patents`) is the USPTO's free, publicly documented REST endpoint for querying the full US patent corpus — issued patents back to 1976 and published applications from 2001. This Actor handles the pagination, query encoding, and field normalisation so you get clean rows instead of raw XML.

**Is a patent search API key required?**

No. The USPTO Patents Public Search API is open — no registration, no key, no quota letter. We still run our fingerprint-rotation and backoff stack to keep your runs clean and consistent.

**Is the data real-time?**

USPTO publishes new grants weekly (typically Tuesday issue dates). New patent applications appear in the search index within approximately one week of their publication date. For monitoring workflows, daily or weekly scheduled runs are appropriate.

**Can I get full patent claims or drawings?**

We surface the `patent_url` field — click it to view the full document in the USPTO Patents Public Search viewer. Full-text claims extraction and drawing download are roadmap items. For bulk full-text needs, the USPTO also publishes weekly XML bulk data files.

**What query syntax does the Actor support?**

The actor passes your `searchQuery` directly to the Patents Public Search API. Field qualifiers: `TI/` (title), `AB/` (abstract), `AN/` (assignee name), `IN/` (inventor name), `CPC/` (CPC class). Boolean operators: `AND`, `OR`, `NOT`. Proximity: `ADJ`. See the [USPTO query guide](https://ppubs.uspto.gov/pubwebapp/static/pages/ppubsbasicsearchhelp.html) for the full reference.

**Does this cover WIPO or EPO patents?**

No — this Actor covers US patents and published applications only. WIPO (PCT applications) and EPO patents require separate endpoints. We can build dedicated Actors for those on request.

**Why is `assignees` sometimes empty?**

Pre-grant publications (kind code `A1`) often don't carry an assignee — the assignment may not be recorded until grant. Check `applicants` as a fallback; it is populated on most pre-grant records.

**How does the pricing compare to PatSnap or Derwent?**

Commercial IP platforms start at roughly $10 000/seat/year. This Actor charges $3.00 per 1 000 results, billed only for what lands in your dataset. It's a wrapper around the same publicly available USPTO data — not a replacement for the analytics layers those platforms provide, but orders of magnitude cheaper for raw patent data retrieval.

### 💬 Your feedback

Spotted a bug, hit an edge case, or need a new field (inventor address, claim text, family members)? Open an issue on the Actor's **Issues** tab in Apify Console — we ship fixes weekly and read every report.

***

<div align="center">

Built by **[Devil Scrapes](https://apify.com/DevilScrapes)** 😈 — a small fleet of
opinionated public-data Actors. Honest pricing, real engineering, zero fine print.

</div>

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text query — searched across title, abstract, claims by default. Use field qualifiers: <code>TI/\<text></code>, <code>AN/\<assignee></code>, <code>IN/\<inventor></code>.

## `maxResults` (type: `integer`):

Total patents to return across pages.

## `sortBy` (type: `string`):

Result ordering — relevance, newest publish, or oldest publish.

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

Optional. USPTO is OK with direct calls.

## Actor input object example

```json
{
  "searchQuery": "TI/(self attention) AND AN/Apple",
  "maxResults": 30,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "searchQuery": "neural network training",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/uspto-patents-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 = {
    "searchQuery": "neural network training",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/uspto-patents-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 '{
  "searchQuery": "neural network training",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call devilscrapes/uspto-patents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USPTO Patent Scraper",
        "description": "Search US issued patents via the official USPTO Patents Public Search API — patent number, title, abstract, inventors, assignee, classifications, priority, filing, and grant dates — bulk export to JSON or CSV. Free, no key, no login.",
        "version": "0.4",
        "x-build-id": "PgMdI96tuHQmDYf2p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~uspto-patents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-uspto-patents-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/devilscrapes~uspto-patents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-uspto-patents-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/devilscrapes~uspto-patents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-uspto-patents-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query — searched across title, abstract, claims by default. Use field qualifiers: <code>TI/&lt;text&gt;</code>, <code>AN/&lt;assignee&gt;</code>, <code>IN/&lt;inventor&gt;</code>."
                    },
                    "maxResults": {
                        "title": "Max patents",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Total patents to return across pages.",
                        "default": 30
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "publication_date_desc",
                            "publication_date_asc"
                        ],
                        "type": "string",
                        "description": "Result ordering — relevance, newest publish, or oldest publish.",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. USPTO is OK with direct calls.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```