# Georgia Real Estate License Lookup Scraper (`automation-lab/georgia-real-estate-license-lookup-scraper`) Actor

Search Georgia Real Estate Commission public license records for agents, brokers, firms, appraisers, schools, and instructors.

- **URL**: https://apify.com/automation-lab/georgia-real-estate-license-lookup-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 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.
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

## Georgia Real Estate License Lookup Scraper

Find Georgia real estate license records from the Georgia Real Estate Commission public search system. This actor turns the public GREC search form into a clean dataset for compliance checks, recruiting lists, broker operations, and real-estate vendor workflows.

### What does Georgia Real Estate License Lookup Scraper do?

The actor searches the public Georgia Real Estate Commission licensing portal and saves matching license records to an Apify dataset.

It can search by:

- Last name or multiple last names
- License / authorization number
- City
- Firm or organization name
- Real estate professional, appraiser, company, school, or instructor category

### Who is it for?

This scraper is useful for teams that need structured Georgia license data without manually copying rows from a web form.

- Brokerages checking agent status
- Real estate recruiters sourcing licensed agents
- Mortgage and insurance vendors verifying professional licenses
- Proptech teams enriching lead lists
- Compliance teams doing KYC or due-diligence checks
- Data teams monitoring GREC records over time

### Why use this actor?

Manual license lookup is slow when you need more than one record. This actor handles the session cookie and ASP.NET verification token, submits the search, parses the result table, and exports normalized records.

### Data source

The source is the public Georgia Real Estate Commission search page:

`https://ata.grec.state.ga.us/Account/Search`

The actor does not require a login. It only extracts records shown in the public search results.

### What data can you extract?

| Field | Description |
| --- | --- |
| `fullName` | Licensee, firm, school, or organization display name |
| `licenseNumber` | Georgia authorization / license number |
| `licenseType` | GREC license type code such as broker or salesperson |
| `licenseStatus` | Public license status |
| `renewalDueDate` | Renewal due date shown by GREC |
| `firmName` | Associated firm/status bucket |
| `firmRole` | Role or firm code from the results table |
| `entityType` | Search category used for the record |
| `historyUrl` | GREC history/certification URL when available |
| `scrapedAt` | Timestamp for the scrape |

### How much does it cost to scrape Georgia real estate license records?

This actor uses pay-per-event pricing:

- A small start fee per run
- A per-record charge for each license record saved

The default input is intentionally small so first runs stay cheap. Increase `maxItems` for larger lead-list or compliance exports.

### How to use it

1. Open the actor on Apify.
2. Enter a last name, license number, city, or organization name.
3. Choose the entity type.
4. Set the maximum number of license records.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, or via API.

### Input options

#### Search filters

Use at least one filter:

- `lastName`
- `lastNames`
- `licenseNumber`
- `city`
- `organizationName`

#### Entity type

Choose one of:

- Real estate professional
- Appraiser
- Company / firm
- School
- Instructor

#### Run options

- `maxItems` stops the run after a selected number of records.
- `includeInactive` keeps inactive, lapsed, revoked, deceased, and other non-active records. Turn it off for active-only lead workflows.

### Example input

```json
{
  "lastName": "Smith",
  "entityType": "realEstateProfessional",
  "maxItems": 25,
  "includeInactive": true
}
````

### Example output

```json
{
  "fullName": "A SMITH",
  "licenseNumber": "80374",
  "licenseType": "BRKR",
  "licenseStatus": "REVOKED",
  "renewalDueDate": "01/01/1900",
  "firmName": "REVOCATIONS",
  "firmRole": "ABKR",
  "entityType": "realEstateProfessional",
  "city": null,
  "searchLastName": "Smith",
  "searchOrganizationName": null,
  "historyUrl": "https://ata.grec.state.ga.us/Account/ViewHistoryCertification?pAuthorizationNumber=80374&pAuthorizationType=BRKR",
  "sourceUrl": "https://ata.grec.state.ga.us/Account/Search",
  "scrapedAt": "2026-07-02T00:00:00.000Z"
}
```

### Tips for better results

- Use license number for exact verification.
- Use `lastNames` with several common names for larger lead lists.
- Use city filters when recruiting in a local Georgia market.
- Keep `includeInactive` enabled for compliance review.
- Disable `includeInactive` when you only want active lead records.

### Common workflows

#### License verification

Search by license number and export the single matching record.

#### Agent recruiting

Search by last name or city, then filter active records in your spreadsheet or CRM.

#### Brokerage compliance

Run recurring checks for agents or firms and compare status changes over time.

#### Vendor enrichment

Match existing names or license numbers against the public GREC record.

### Integrations

You can send the dataset to:

- Google Sheets
- Airtable
- HubSpot or Salesforce via Make/Zapier
- Internal compliance dashboards
- Data warehouses such as BigQuery or Snowflake

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/georgia-real-estate-license-lookup-scraper').call({
  lastName: 'Smith',
  entityType: 'realEstateProfessional',
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/georgia-real-estate-license-lookup-scraper').call(run_input={
    'licenseNumber': '430104',
    'entityType': 'realEstateProfessional',
    'maxItems': 5,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~georgia-real-estate-license-lookup-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"lastName":"Smith","entityType":"realEstateProfessional","maxItems":25}'
```

### MCP usage

Use this actor from Claude Desktop or Claude Code through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/georgia-real-estate-license-lookup-scraper`

Claude Code setup:

```bash
claude mcp add apify-georgia-license --url "https://mcp.apify.com/?tools=automation-lab/georgia-real-estate-license-lookup-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-georgia-license": {
      "url": "https://mcp.apify.com/?tools=automation-lab/georgia-real-estate-license-lookup-scraper"
    }
  }
}
```

Example prompts:

- "Look up Georgia real estate license number 430104."
- "Find Georgia real estate professionals named Smith and return active licenses."
- "Create a CSV of Georgia broker records from this GREC search."

### Data quality notes

The actor saves exactly the public result rows returned by GREC. Some old records may contain placeholder dates such as `01/01/1900`, because that is how the source displays them.

### Limitations

- The actor does not parse PDF history certificates in the default run.
- The actor exposes history URLs so users can open source documents when needed.
- The source is a public government web form and may change without notice.

### Legality

The actor accesses public search results. You are responsible for using the data lawfully, respecting applicable privacy, marketing, and compliance rules, and following Apify's terms and the source site's policies.

### FAQ

#### Is it legal to scrape Georgia real estate license data?

The actor accesses public GREC search results and does not bypass login-only content. Use the data responsibly and follow applicable compliance, privacy, and marketing rules.

#### Does this actor download history PDFs?

No. It returns the public history URL when GREC exposes one, so you can open or archive source documents only when needed.

### Troubleshooting

#### I got no records

Try a broader filter, check spelling, or enable inactive records. The GREC site may return no rows for narrow combinations.

#### Why are some statuses lapsed or revoked?

GREC includes historical and inactive records. Use `includeInactive: false` if you only want active-looking records.

### Related scrapers

Explore other Automation Lab actors for lead generation and compliance workflows:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/business-lead-scraper

### Support

If the source page changes or you need extra fields, open an issue on the Apify actor page with your input and expected output.

### Changelog

Initial version extracts GREC search result rows for public Georgia real estate license lookup workflows.

# Actor input Schema

## `lastName` (type: `string`):

Licensee last name for real estate professional, appraiser, or instructor searches.

## `lastNames` (type: `array`):

Optional batch of last names to search sequentially in one run. Use this for larger recruiting or compliance exports.

## `licenseNumber` (type: `string`):

Georgia authorization / license number. Use this for exact lookup workflows.

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

Optional city filter as accepted by the GREC public search form.

## `organizationName` (type: `string`):

Use for company, school, or organization-oriented searches.

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

Which GREC public search category to query.

## `firmType` (type: `string`):

Subtype used only when Entity type is Company / firm.

## `schoolType` (type: `string`):

Subtype used only when Entity type is School.

## `instructorType` (type: `string`):

Subtype used only when Entity type is Instructor.

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

Stop after this many matching records have been saved to the dataset.

## `includeInactive` (type: `boolean`):

Keep lapsed, revoked, deceased, and other non-active license records. Turn off for active-only lead lists.

## Actor input object example

```json
{
  "lastName": "Smith",
  "lastNames": [
    "Smith",
    "Brown",
    "Johnson"
  ],
  "entityType": "realEstateProfessional",
  "firmType": "realEstateFirm",
  "schoolType": "realEstateSchool",
  "instructorType": "realEstateInstructor",
  "maxItems": 20,
  "includeInactive": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "lastName": "Smith",
    "lastNames": [
        "Smith",
        "Brown",
        "Johnson"
    ],
    "entityType": "realEstateProfessional",
    "maxItems": 20,
    "includeInactive": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/georgia-real-estate-license-lookup-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 = {
    "lastName": "Smith",
    "lastNames": [
        "Smith",
        "Brown",
        "Johnson",
    ],
    "entityType": "realEstateProfessional",
    "maxItems": 20,
    "includeInactive": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/georgia-real-estate-license-lookup-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 '{
  "lastName": "Smith",
  "lastNames": [
    "Smith",
    "Brown",
    "Johnson"
  ],
  "entityType": "realEstateProfessional",
  "maxItems": 20,
  "includeInactive": true
}' |
apify call automation-lab/georgia-real-estate-license-lookup-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/georgia-real-estate-license-lookup-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Georgia Real Estate License Lookup Scraper",
        "description": "Search Georgia Real Estate Commission public license records for agents, brokers, firms, appraisers, schools, and instructors.",
        "version": "0.1",
        "x-build-id": "8l6XgEu1G95Dk943D"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~georgia-real-estate-license-lookup-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-georgia-real-estate-license-lookup-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/automation-lab~georgia-real-estate-license-lookup-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-georgia-real-estate-license-lookup-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/automation-lab~georgia-real-estate-license-lookup-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-georgia-real-estate-license-lookup-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "lastName": {
                        "title": "Last name",
                        "type": "string",
                        "description": "Licensee last name for real estate professional, appraiser, or instructor searches."
                    },
                    "lastNames": {
                        "title": "Multiple last names",
                        "type": "array",
                        "description": "Optional batch of last names to search sequentially in one run. Use this for larger recruiting or compliance exports.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "licenseNumber": {
                        "title": "License number",
                        "type": "string",
                        "description": "Georgia authorization / license number. Use this for exact lookup workflows."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional city filter as accepted by the GREC public search form."
                    },
                    "organizationName": {
                        "title": "Firm, school, or organization name",
                        "type": "string",
                        "description": "Use for company, school, or organization-oriented searches."
                    },
                    "entityType": {
                        "title": "Entity type",
                        "enum": [
                            "realEstateProfessional",
                            "appraiser",
                            "company",
                            "school",
                            "instructor"
                        ],
                        "type": "string",
                        "description": "Which GREC public search category to query.",
                        "default": "realEstateProfessional"
                    },
                    "firmType": {
                        "title": "Firm type",
                        "enum": [
                            "realEstateFirm",
                            "appraisalManagementCompany"
                        ],
                        "type": "string",
                        "description": "Subtype used only when Entity type is Company / firm.",
                        "default": "realEstateFirm"
                    },
                    "schoolType": {
                        "title": "School type",
                        "enum": [
                            "realEstateSchool",
                            "appraisalSchool"
                        ],
                        "type": "string",
                        "description": "Subtype used only when Entity type is School.",
                        "default": "realEstateSchool"
                    },
                    "instructorType": {
                        "title": "Instructor type",
                        "enum": [
                            "realEstateInstructor",
                            "appraisalInstructor"
                        ],
                        "type": "string",
                        "description": "Subtype used only when Entity type is Instructor.",
                        "default": "realEstateInstructor"
                    },
                    "maxItems": {
                        "title": "Maximum license records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many matching records have been saved to the dataset.",
                        "default": 20
                    },
                    "includeInactive": {
                        "title": "Include inactive / lapsed records",
                        "type": "boolean",
                        "description": "Keep lapsed, revoked, deceased, and other non-active license records. Turn off for active-only lead lists.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
