# SAM.gov Set-Aside Contract Radar - Federal Opportunity Finder (`bigjoecoding/sam-gov-set-aside-contract-radar`) Actor

Free SAM.gov API tool that finds federal contract opportunities by NAICS code and small business set-aside (WOSB, SDVOSB, 8a, HUBZone). Pay per event.

- **URL**: https://apify.com/bigjoecoding/sam-gov-set-aside-contract-radar.md
- **Developed by:** [Joseph Curry](https://apify.com/bigjoecoding) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 matched opportunity delivereds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does SAM.gov Set-Aside Contract Radar do?

**SAM.gov Set-Aside Contract Radar** is a SAM.gov API tool that searches the federal government's live **Contract Opportunities** database and returns a clean, structured shortlist of opportunities matching your **NAICS code(s)**, **set-aside type(s)** (WOSB, SDVOSB, 8(a), HUBZone, Total Small Business), **posted-date window**, and **true place of performance**, with a plain, mechanical "why this matched" note on every result. Try it free on Apify: scheduling, API access, dataset export, and run monitoring are included at no extra cost. Set it to run daily or weekly and stop manually searching [SAM.gov](https://sam.gov) by hand.

### Why use this SAM.gov contract opportunity finder?

SAM.gov is free to search, but searching it well takes real time: juggling NAICS codes, set-aside filters, and a results page that never explains *why* a listing matched your profile. This Actor is built for govcon business development: small business owners, federal contracting consultants, capture managers, and BD teams who want a recurring, done-for-you scan of new federal contract opportunities instead of manually refreshing SAM.gov every morning.

**This filters by TRUE place of performance, not just the contracting office.** Many tools, including SAM.gov's own search UI if used carelessly, filter geography by the contracting office's mailing address instead of where the work actually happens. This Actor was built specifically to avoid that mistake. See "How the place-of-performance filter works" below.

#### Who this is for

- **Small business owners in govcon** tracking set-aside eligible work (WOSB, SDVOSB, 8(a), HUBZone) without paying for an enterprise opportunity-tracking platform.
- **Capture managers and BD teams** who want a recurring, scheduled feed of new opportunities by NAICS code instead of a daily manual SAM.gov search.
- **Federal contracting consultants** building a lead list for multiple clients, each with a different NAICS/set-aside profile.
- **Developers and no-code builders** who want structured JSON/CSV opportunity data to pipe into a CRM, spreadsheet, or Slack alert.

### How to use SAM.gov Set-Aside Contract Radar

1. **Get your own free SAM.gov API key.** Sign in at [sam.gov](https://sam.gov), then go to Workspace > Profile > Account Details > Request API Key. This Actor requires **your own** key; it never uses a shared key, since a shared key would hit SAM.gov's daily rate limit almost immediately once more than a few buyers ran this Actor.
2. Open the Input tab, paste your key into **Your SAM.gov API key**, add your NAICS code(s), and optionally set a set-aside filter, keywords, place-of-performance state, and date window.
3. Click **Start**. Results appear in the Dataset tab as the search completes, usually in a few seconds.
4. (Optional) Schedule this Actor to run daily or weekly from the Apify Console so new opportunities land automatically, with no manual re-run required.

### Input

- **Your SAM.gov API key** (required, secret): your own free key, never shared or logged.
- **NAICS codes** (required): one or more 6-digit codes, e.g. `541511`. Max 10 per run (one SAM.gov request per code).
- **Set-aside codes** (optional): e.g. `SBA`, `WOSB`, `SDVOSBC`, `8A`, `HZC`. Leave empty for all set-asides.
- **Title keywords** (optional): only include opportunities whose title contains at least one keyword.
- **Place-of-performance state** (optional): a 2-letter state code, e.g. `GA`.
- **Posted-date window (days)** (default 14): how far back to search.
- **Minimum days until deadline** (default 3): skip opportunities you have no realistic time to act on.

### Output

Each matched opportunity is a dataset item:

```json
{
  "title": "Cloud Migration Support Services",
  "solicitationNumber": "70FA25Q0001",
  "agency": "GENERAL SERVICES ADMINISTRATION.FAS.REGION 5",
  "naicsCode": "541511",
  "setAside": "Total Small Business Set-Aside",
  "postedDate": "2026-07-10",
  "responseDeadline": "2026-08-05",
  "placeOfPerformance": "Chicago, IL",
  "samGovLink": "https://sam.gov/opp/.../view",
  "whyMatched": "NAICS 541511 is in your profile; set-aside is Total Small Business Set-Aside."
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A run summary (profile, date range covered, and the standing disclaimer below) is also written to the run's Key-Value Store.

#### Data table

| Field | Description |
|---|---|
| `title` | Opportunity title as posted on SAM.gov |
| `solicitationNumber` | Official solicitation number |
| `agency` | Full contracting agency path |
| `naicsCode` | NAICS code on the posting |
| `setAside` | Set-aside type, or "None / full and open" |
| `postedDate` | When the opportunity was posted |
| `responseDeadline` | Response deadline |
| `placeOfPerformance` | City/state, or a flagged note if not specified in the posting |
| `samGovLink` | Direct link to the live SAM.gov listing |
| `whyMatched` | Mechanical, factual explanation of which filter(s) it hit |

### How the place-of-performance filter works

SAM.gov's own search API has a `state` parameter that sounds like it filters by where the work happens. It doesn't. It filters by the **contracting office's** address state. This Actor never sends that parameter. Instead, it reads each opportunity's actual place-of-performance field and filters **client-side** against the real work location. Opportunities with no place of performance listed are **included, not silently dropped**, with a flag note telling you to verify on SAM.gov, because a missing field could mean nationwide or remote work, not necessarily "wrong location."

### How much does this SAM.gov opportunity search cost?

This Actor uses **Pay-Per-Event pricing**: you only pay for what it actually does, with no monthly rental fee and no subscription.

| Event | Price | When it's charged |
|---|---|---|
| Search completed | $0.05 | Once per run, regardless of result count (including honest zero-result runs) |
| Matched opportunity delivered | $0.02 | Once per opportunity actually written to your dataset |

A typical run (1 to 5 NAICS codes, 10 to 30 matches) costs roughly **$0.25 to $0.65**. Apify's own small platform-usage charge for the first 5 seconds of every run is subsidized by Apify by default.

### Tips for getting the best results

- Keep your NAICS code list short if your SAM.gov account has a daily request limit; this Actor makes one request per code.
- Use the place-of-performance state filter if you only want to see work in your own state; leave it blank to see all locations plus flagged "not specified" postings.
- Combine set-aside codes with keywords to narrow a broad NAICS code down to the specific type of work you bid on.
- Schedule this Actor from the Apify Console for a recurring feed instead of running it manually.

### FAQ, disclaimers, and support

**Is this bid advice, eligibility advice, or a guarantee I'll win anything?**
No. This is a shortlist of public SAM.gov data for your own review, not bid-writing help, not set-aside eligibility advice, and not a win guarantee. Whether to pursue any opportunity, and whether you qualify for a listed set-aside, is your call (or your advisor's) after you verify details directly on SAM.gov.

**Why not just use SAM.gov's free saved-search alerts?**
You can, and SAM.gov's own alerts are a fine tool for ongoing monitoring. This Actor adds a mechanical "why this matched" explanation per result, a client-side place-of-performance fix SAM.gov's own filters don't give you, structured JSON/CSV output for downstream tools like a CRM or spreadsheet, and Apify scheduling and API access on top.

**Do I need my own SAM.gov account?**
Yes, you need a free SAM.gov API key (see "How to use" above). This Actor never uses a shared key, so your searches are never slowed down by other buyers' usage.

**What if nothing matches my profile?**
Reported honestly, not padded with loosely related results. Try widening the posted-date window, adding NAICS codes, or removing a keyword or set-aside filter.

**How current is the data?**
As current as SAM.gov's public database at the time the Actor runs. Postings can be amended or closed at any time; always confirm details on SAM.gov before acting.

**How is this different from other SAM.gov scrapers on Apify Store?**
This Actor's two distinguishing features are the client-side true place-of-performance filter (most tools filter by contracting office address instead) and a mechanical, factual "why matched" note on every result, so you're never guessing why an opportunity showed up in your feed.

Questions or issues? Use the Actor's Issues tab on Apify Store.

# Actor input Schema

## `samGovApiKey` (type: `string`):

REQUIRED. Your own free SAM.gov Public API Key -- get one at sam.gov > Workspace > Profile > Account Details > Request API Key. This Actor never uses a shared key; each buyer's own key is used so nobody hits a shared rate limit.

## `naicsCodes` (type: `array`):

One or more 6-digit NAICS codes describing the work you do, e.g. \["541511", "541512"]. This Actor makes one SAM.gov request per code (max 10 per run) -- keep your list short if your personal API key has a daily request limit.

## `setAsideCodes` (type: `array`):

Only include opportunities matching these set-aside types. Leave empty to include all set-asides (and full-and-open). Common codes: SBA (Total Small Business), WOSB (Woman-Owned Small Business), SDVOSBC (Service-Disabled Veteran-Owned Small Business), 8A, HZC (HUBZone).

## `keywords` (type: `array`):

Only include opportunities whose title contains at least one of these keywords (case-insensitive). Leave empty to skip keyword filtering.

## `placeOfPerformanceState` (type: `string`):

Two-letter US state code, e.g. "GA". Filters to opportunities whose actual place of performance is in this state. IMPORTANT: this is enforced by reading each opportunity's real place-of-performance field, not SAM.gov's own 'state' search parameter -- that parameter filters by the CONTRACTING OFFICE's address, not where the work happens, so it is never used here. Opportunities with no place-of-performance listed are included and flagged, not silently dropped.

## `postedDaysBack` (type: `integer`):

How many days back to search for newly posted opportunities. SAM.gov limits any single search window to 1 year.

## `minResponseDeadlineDays` (type: `integer`):

Skip opportunities whose response deadline is sooner than this many days from today -- avoids surfacing opportunities you have no realistic time to act on.

## Actor input object example

```json
{
  "naicsCodes": [
    "541511"
  ],
  "setAsideCodes": [],
  "keywords": [],
  "placeOfPerformanceState": "",
  "postedDaysBack": 14,
  "minResponseDeadlineDays": 3
}
```

# 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 = {
    "naicsCodes": [
        "541511"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigjoecoding/sam-gov-set-aside-contract-radar").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 = { "naicsCodes": ["541511"] }

# Run the Actor and wait for it to finish
run = client.actor("bigjoecoding/sam-gov-set-aside-contract-radar").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 '{
  "naicsCodes": [
    "541511"
  ]
}' |
apify call bigjoecoding/sam-gov-set-aside-contract-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bigjoecoding/sam-gov-set-aside-contract-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SAM.gov Set-Aside Contract Radar - Federal Opportunity Finder",
        "description": "Free SAM.gov API tool that finds federal contract opportunities by NAICS code and small business set-aside (WOSB, SDVOSB, 8a, HUBZone). Pay per event.",
        "version": "0.1",
        "x-build-id": "fMIVsLS46bpnPx4yV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bigjoecoding~sam-gov-set-aside-contract-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bigjoecoding-sam-gov-set-aside-contract-radar",
                "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/bigjoecoding~sam-gov-set-aside-contract-radar/runs": {
            "post": {
                "operationId": "runs-sync-bigjoecoding-sam-gov-set-aside-contract-radar",
                "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/bigjoecoding~sam-gov-set-aside-contract-radar/run-sync": {
            "post": {
                "operationId": "run-sync-bigjoecoding-sam-gov-set-aside-contract-radar",
                "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": [
                    "samGovApiKey",
                    "naicsCodes"
                ],
                "properties": {
                    "samGovApiKey": {
                        "title": "Your SAM.gov API key",
                        "type": "string",
                        "description": "REQUIRED. Your own free SAM.gov Public API Key -- get one at sam.gov > Workspace > Profile > Account Details > Request API Key. This Actor never uses a shared key; each buyer's own key is used so nobody hits a shared rate limit."
                    },
                    "naicsCodes": {
                        "title": "NAICS codes",
                        "type": "array",
                        "description": "One or more 6-digit NAICS codes describing the work you do, e.g. [\"541511\", \"541512\"]. This Actor makes one SAM.gov request per code (max 10 per run) -- keep your list short if your personal API key has a daily request limit.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "setAsideCodes": {
                        "title": "Set-aside codes (optional)",
                        "type": "array",
                        "description": "Only include opportunities matching these set-aside types. Leave empty to include all set-asides (and full-and-open). Common codes: SBA (Total Small Business), WOSB (Woman-Owned Small Business), SDVOSBC (Service-Disabled Veteran-Owned Small Business), 8A, HZC (HUBZone).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Title keywords (optional)",
                        "type": "array",
                        "description": "Only include opportunities whose title contains at least one of these keywords (case-insensitive). Leave empty to skip keyword filtering.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeOfPerformanceState": {
                        "title": "Place-of-performance state (optional)",
                        "type": "string",
                        "description": "Two-letter US state code, e.g. \"GA\". Filters to opportunities whose actual place of performance is in this state. IMPORTANT: this is enforced by reading each opportunity's real place-of-performance field, not SAM.gov's own 'state' search parameter -- that parameter filters by the CONTRACTING OFFICE's address, not where the work happens, so it is never used here. Opportunities with no place-of-performance listed are included and flagged, not silently dropped.",
                        "default": ""
                    },
                    "postedDaysBack": {
                        "title": "Posted-date window (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How many days back to search for newly posted opportunities. SAM.gov limits any single search window to 1 year.",
                        "default": 14
                    },
                    "minResponseDeadlineDays": {
                        "title": "Minimum days until deadline",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip opportunities whose response deadline is sooner than this many days from today -- avoids surfacing opportunities you have no realistic time to act on.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
