# Oregon Secretary of State Business Search Scraper (`crawlerbros/oregon-sos-scraper`) Actor

Search Oregon's official business registry by business name, registry number, entity type, or city. Get entity type, status, formation date, registered agent, and business address.

- **URL**: https://apify.com/crawlerbros/oregon-sos-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **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/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

## Oregon Secretary of State Business Search Scraper

Search **Oregon's official business registry** — every active business entity registered with the Oregon Secretary of State Corporation Division. Look up a business by name, exact registry number, entity type, or city, and get entity type, formation date, registered agent, and business/mailing addresses. HTTP-only via Oregon's own public Open Data JSON API. No auth, no proxy, no cookies.

### What this actor does

- **Four modes:** `search` (by business name), `byRegistryNumber` (exact lookup), `byEntityType` (browse by legal structure), `byCity` (browse by principal-office city)
- **21 entity types covered:** LLCs, corporations, nonprofits, partnerships, cooperatives, assumed business names, and more
- **Filters:** entity type, city, jurisdiction of formation, registration-date range — combinable across every mode
- **Registered agent details:** name and full mailing address for every entity
- **Empty fields are omitted** — every record only contains fields Oregon actually published for that business

### Output per business entity

- `registryNumber` — the business's unique Oregon registry number
- `businessName` — registered legal/assumed name
- `entityType` — legal structure (e.g. `DOMESTIC LIMITED LIABILITY COMPANY`)
- `status` — always `ACTIVE` (only active businesses are indexed by this source)
- `jurisdiction` — state/country of formation (`OR` for domestic entities, the home state for foreign entities)
- `formationDate` — date the business was first registered (`YYYY-MM-DD`)
- `businessAddress`, `businessCity`, `businessState`, `businessZip` — principal place of business
- `mailingAddress` — mailing address on file (when different from the business address)
- `registeredAgentName`, `registeredAgentAddress` — the entity's registered agent
- `registeredAgentRegistryNumber` — the agent's own Oregon registry number, when the agent is itself a registered business (e.g. a commercial registered-agent service)
- `authorizedRepresentativeName` — for foreign (out-of-state) entities that list one
- `officialLookupUrl` — Oregon's own canonical per-business deep link into the SOS's interactive registry lookup application, keyed to this exact registry number
- `recordType`: `"entity"`, `sourceUrl`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byRegistryNumber` / `byEntityType` / `byCity` |
| `businessName` | string | `nike` | Business name to search for (mode=search) |
| `matchMode` | string | `contains` | `contains` / `beginsWith` / `exact` name matching (mode=search) |
| `registryNumber` | string | – | Exact Oregon registry number (mode=byRegistryNumber) |
| `entityType` | string | – | Filter/browse by legal structure (mode=byEntityType or filter) |
| `city` | string | – | Filter/browse by principal-office city (mode=byCity or filter) |
| `jurisdiction` | string | – | Filter by state/country of formation (e.g. `OR`, `CA`, `DE`) |
| `registryDateFrom` | string | – | Only businesses registered on/after this date (`YYYY-MM-DD`) |
| `registryDateTo` | string | – | Only businesses registered on/before this date (`YYYY-MM-DD`) |
| `maxItems` | int | `25` | Hard cap on emitted records (1–500) |

#### Example: search by business name

```json
{
  "mode": "search",
  "businessName": "nike",
  "matchMode": "contains",
  "maxItems": 25
}
````

#### Example: exact lookup by registry number

```json
{
  "mode": "byRegistryNumber",
  "registryNumber": "8739914"
}
```

#### Example: browse all cooperatives registered since 2024

```json
{
  "mode": "byEntityType",
  "entityType": "COOPERATIVE",
  "registryDateFrom": "2024-01-01",
  "maxItems": 100
}
```

#### Example: find Delaware-formed corporations registered as foreign entities in Oregon

```json
{
  "mode": "byEntityType",
  "entityType": "FOREIGN BUSINESS CORPORATION",
  "jurisdiction": "DE",
  "maxItems": 50
}
```

#### Example: browse businesses in a specific city

```json
{
  "mode": "byCity",
  "city": "Bend",
  "entityType": "DOMESTIC LIMITED LIABILITY COMPANY",
  "maxItems": 50
}
```

### Use cases

- **Sales & lead generation** — build prospect lists of newly registered Oregon businesses by city or entity type
- **Compliance & due diligence** — verify a counterparty's Oregon registry status, registered agent, and formation date
- **Registered-agent research** — find which businesses share a given registered agent
- **Market research** — track new business formation trends by city, entity type, or date range
- **Legal & filing services** — cross-reference client entity data against the official registry

### FAQ

**What is the data source?**
This actor reads Oregon's official Open Data Portal (`data.oregon.gov`), specifically the Secretary of State Corporation Division's "Active Businesses - ALL" dataset. This is the same data the SOS's own business-search page links to for bulk/programmatic lookups, published and maintained directly by the State of Oregon.

**Why does every record show `status: "ACTIVE"`?**
The upstream dataset only publishes currently active businesses. Dissolved, revoked, or withdrawn entities are not included, so every record returned is, by definition, active as of the last data refresh.

**How fresh is the data?**
Oregon's Open Data Portal refreshes this dataset on an ongoing basis as filings are processed — typically within days of a new registration.

**Why do some entities have no `mailingAddress` or `authorizedRepresentativeName`?**
Not every business files every address type. Domestic entities rarely have an `authorizedRepresentativeName` (that field applies mainly to foreign/out-of-state entities), and a mailing address is only shown when the business filed one separately from its principal address.

**What does `jurisdiction` filter on?**
The entity's state/country of formation, as published in Oregon's own registry (e.g. `OR` for domestic entities, `CA`/`DE`/`WA` etc. for foreign entities formed elsewhere and registered to do business in Oregon). It's a case-insensitive exact match against Oregon's own jurisdiction code and combines with `mode`, `entityType`, `city`, and the date-range filters.

**What counts as a match for `matchMode`?**
`contains` matches the business name anywhere in the string, `beginsWith` matches only from the start, and `exact` requires the full name to match exactly (case-insensitive in all three cases).

**What is `officialLookupUrl`?**
It's the exact per-business deep link Oregon's own dataset publishes for the record, pointing at the SOS's interactive `egov.sos.state.or.us` lookup application. Note that host has been intermittently unreachable (see "Data Source" below) — the URL is still included as the authoritative reference/citation for the record even when the page itself can't be loaded directly.

**Is this affiliated with the Oregon Secretary of State?**
No. This is an independent, third-party actor that reads Oregon's public Open Data API. It is not operated by or affiliated with the State of Oregon.

**Can I look up historical/inactive businesses?**
Not with this actor — the upstream open-data source only publishes active registrations.

### Data Source

**Decision: Oregon's official Open Data Portal, not the interactive `egov.sos.state.or.us` search form.**

At build time, the interactive business-search application at `egov.sos.state.or.us` was found to be unreachable — connection attempts on port 443 timed out consistently across multiple independent networks and multiple retries, while the host's own domain (`sos.oregon.gov`) and its official Open Data Portal (`data.oregon.gov`) responded normally. Rather than replace Oregon with a different state, this actor uses Oregon's own official redistribution channel for the exact same registry data: the Secretary of State Corporation Division's "Active Businesses - ALL" dataset on `data.oregon.gov`, which is linked directly from `sos.oregon.gov`'s own "Search Active Business Registration Records" page as the recommended way to search/export active-business records. This is Oregon's own government data, not a third-party mirror, and it returns the identical underlying records (name, registry number, entity type, formation date, registered agent, addresses) that the interactive form would show.

# Actor input Schema

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

Which axis of Oregon's business registry to search.

## `businessName` (type: `string`):

Business/entity name to search for.

## `matchMode` (type: `string`):

How `businessName` is matched against the registry.

## `registryNumber` (type: `string`):

The business's Oregon registry number (numeric, e.g. `8739914`).

## `entityType` (type: `string`):

Filter to a specific Oregon entity type.

## `city` (type: `string`):

Business's principal-office city (e.g. `PORTLAND`, `BEND`, `SALEM`). Case-insensitive exact match.

## `jurisdiction` (type: `string`):

Filter by the entity's state/country of formation (e.g. `OR` for domestic entities, `CA`, `DE`, `WA` for foreign entities registered from elsewhere). Case-insensitive exact match against Oregon's own jurisdiction code.

## `registryDateFrom` (type: `string`):

Only include businesses first registered on or after this date (`YYYY-MM-DD`).

## `registryDateTo` (type: `string`):

Only include businesses first registered on or before this date (`YYYY-MM-DD`).

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

Hard cap on emitted business records.

## Actor input object example

```json
{
  "mode": "search",
  "businessName": "nike",
  "matchMode": "contains",
  "maxItems": 25
}
```

# Actor output Schema

## `entities` (type: `string`):

Dataset containing all scraped Oregon business entities.

# 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": "search",
    "businessName": "nike",
    "matchMode": "contains",
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/oregon-sos-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": "search",
    "businessName": "nike",
    "matchMode": "contains",
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/oregon-sos-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": "search",
  "businessName": "nike",
  "matchMode": "contains",
  "maxItems": 25
}' |
apify call crawlerbros/oregon-sos-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Oregon Secretary of State Business Search Scraper",
        "description": "Search Oregon's official business registry by business name, registry number, entity type, or city. Get entity type, status, formation date, registered agent, and business address.",
        "version": "1.0",
        "x-build-id": "8Qd5jZihSqq4Xsbuh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~oregon-sos-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-oregon-sos-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~oregon-sos-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-oregon-sos-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~oregon-sos-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-oregon-sos-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": "Search mode",
                        "enum": [
                            "search",
                            "byRegistryNumber",
                            "byEntityType",
                            "byCity"
                        ],
                        "type": "string",
                        "description": "Which axis of Oregon's business registry to search.",
                        "default": "search"
                    },
                    "businessName": {
                        "title": "Business name (mode=search)",
                        "type": "string",
                        "description": "Business/entity name to search for.",
                        "default": "nike"
                    },
                    "matchMode": {
                        "title": "Name match mode (mode=search)",
                        "enum": [
                            "contains",
                            "beginsWith",
                            "exact"
                        ],
                        "type": "string",
                        "description": "How `businessName` is matched against the registry.",
                        "default": "contains"
                    },
                    "registryNumber": {
                        "title": "Registry number (mode=byRegistryNumber)",
                        "type": "string",
                        "description": "The business's Oregon registry number (numeric, e.g. `8739914`)."
                    },
                    "entityType": {
                        "title": "Entity type (mode=byEntityType, or filter on other modes)",
                        "enum": [
                            "DOMESTIC LIMITED LIABILITY COMPANY",
                            "ASSUMED BUSINESS NAME",
                            "DOMESTIC BUSINESS CORPORATION",
                            "DOMESTIC NONPROFIT CORPORATION",
                            "FOREIGN LIMITED LIABILITY COMPANY",
                            "FOREIGN BUSINESS CORPORATION",
                            "DOMESTIC PROFESSIONAL CORPORATION",
                            "FOREIGN NONPROFIT CORPORATION",
                            "DOMESTIC LIMITED PARTNERSHIP",
                            "FOREIGN PROFESSIONAL CORPORATION",
                            "FOREIGN LIMITED PARTNERSHIP",
                            "COOPERATIVE",
                            "DOMESTIC REGISTERED LIMITED LIABILITY PARTNERSHIP",
                            "FOREIGN REGISTERED LIMITED LIABILITY PARTNERSHIP",
                            "DISTRICT IMPROVEMENT NONPROFIT",
                            "FOREIGN BUSINESS TRUST",
                            "DOMESTIC BUSINESS TRUST",
                            "RESERVED NAME",
                            "ACT OF GOVERNMENT",
                            "DISTRICT IMPROVEMENT PROFIT",
                            "REGISTERED NAME"
                        ],
                        "type": "string",
                        "description": "Filter to a specific Oregon entity type."
                    },
                    "city": {
                        "title": "City (mode=byCity, or filter on other modes)",
                        "type": "string",
                        "description": "Business's principal-office city (e.g. `PORTLAND`, `BEND`, `SALEM`). Case-insensitive exact match."
                    },
                    "jurisdiction": {
                        "title": "Jurisdiction of formation (filter)",
                        "type": "string",
                        "description": "Filter by the entity's state/country of formation (e.g. `OR` for domestic entities, `CA`, `DE`, `WA` for foreign entities registered from elsewhere). Case-insensitive exact match against Oregon's own jurisdiction code."
                    },
                    "registryDateFrom": {
                        "title": "Registered on/after (filter)",
                        "type": "string",
                        "description": "Only include businesses first registered on or after this date (`YYYY-MM-DD`)."
                    },
                    "registryDateTo": {
                        "title": "Registered on/before (filter)",
                        "type": "string",
                        "description": "Only include businesses first registered on or before this date (`YYYY-MM-DD`)."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted business records.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
