# USDA Organic Integrity Database Scraper (`automation-lab/usda-organic-integrity-database-scraper`) Actor

🔎 Scrape USDA Organic INTEGRITY certified operations, certification status, products, certifiers, locations, and profile details.

- **URL**: https://apify.com/automation-lab/usda-organic-integrity-database-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **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

## USDA Organic Integrity Database Scraper

Extract certified organic operation records from the official USDA Organic INTEGRITY Database.

### What does USDA Organic Integrity Database Scraper do?

USDA Organic Integrity Database Scraper searches the public USDA Organic INTEGRITY directory and returns structured records for certified organic farms, handlers, processors, import/export partners, and related operations.

It can collect operation names, NOP IDs, certifiers, certification status, scopes, certified products, countries, states, cities, profile URLs, and optional profile details such as contacts, emails, phone numbers, addresses, status effective dates, and certified acres.

### Who is it for?

#### Procurement and sourcing teams

- 🛒 Organic ingredient buyers checking supplier certification status
- 🧪 Food brands sourcing certified organic farms, handlers, and processors
- 🚢 Import/export teams monitoring cross-border organic suppliers

#### Compliance and audit teams

- ✅ Certification and compliance teams validating USDA-NOP records
- 📋 Auditors preparing evidence packs for vendor due diligence
- 🧾 Vendor onboarding teams that need repeatable certification checks

#### Research and market intelligence teams

- 🔎 Market researchers mapping certified organic operations by country or product
- 📊 Category managers comparing certified supply by ingredient, region, or certifier
- 🧭 Consultants building organic market landscapes from official public records

### Why use this scraper?

The USDA directory is public but optimized for manual search. This actor turns those public results into a machine-readable dataset that can be exported to CSV, Excel, JSON, Google Sheets, databases, BI tools, and compliance workflows.

### Data source

The actor uses the official USDA Organic INTEGRITY Database at `https://organic.ams.usda.gov/integrity/`.

### What data can you extract?

| Field | Description |
| --- | --- |
| `operationName` | Certified operation, farm, business, or facility name |
| `operationId` / `nopId` | USDA NOP operation identifier |
| `certifierId` | USDA certifier identifier from the profile URL |
| `program` | USDA program, usually USDA-NOP |
| `status` | Certification status, such as Certified |
| `scopes` | Crops, handling, livestock, or wild crops |
| `certifiedProducts` | Certified product summary from USDA |
| `certifier` | Accredited certifier name/code |
| `city`, `stateProvince`, `country` | Location fields shown in the public directory |
| `statusEffectiveDate` | Certification status effective date when profile details are enabled |
| `nopAnniversaryDate` | NOP anniversary date when profile details are enabled |
| `totalCertifiedAcres` | Acres listed on the operation profile |
| `contactName`, `phone`, `email`, `website` | Public contact details when present |
| `physicalAddress`, `mailingAddress` | Public profile addresses when present |
| `profileUrl` | USDA operation profile URL |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to scrape USDA Organic Integrity data?

This actor uses pay-per-event pricing. You pay a small run start fee and a per-operation fee for records saved to the dataset. Final live Store prices are visible on the Apify actor page before you run it.

Current pricing model:

| Event | Price |
| --- | ---: |
| Run started | $0.005 per run |
| Item extracted | tiered per saved operation record |

Current per-record tier examples:

| Plan tier | Price per operation |
| --- | ---: |
| FREE | $0.00035091 |
| BRONZE | $0.00030514 |
| SILVER | $0.00023801 |
| GOLD | $0.00018309 |
| PLATINUM | $0.00012206 |
| DIAMOND | $0.00008544 |

Example costs before Apify platform fees:

- 50 operation records on BRONZE: about $0.0203 (`$0.005 + 50 × $0.00030514`)
- 500 operation records on BRONZE: about $0.1576 (`$0.005 + 500 × $0.00030514`)
- 1,000 operation records on BRONZE: about $0.3101 (`$0.005 + 1,000 × $0.00030514`)

For low-cost first tests, keep `maxItems` small and leave `includeDetails` disabled. Enable profile details when you need contacts, status dates, acres, and addresses.

### How to use

1. Open the actor on Apify.
2. Enter a product, operation name, certifier, country, state, or city.
3. Set `maxItems` to the number of operation records you need.
4. Enable `includeDetails` if you need contact and address fields.
5. Run the actor.
6. Export the dataset as CSV, Excel, JSON, or through the Apify API.

### Input options

#### Search filters

Use any combination of:

- `keyword`
- `operationName`
- `product`
- `certifier`
- `city`
- `state`
- `country`

#### Direct profile URLs

Use `startUrls` when you already have USDA operation profile URLs and only need structured detail extraction.

#### Limits and enrichment

- `maxItems`: maximum records to save
- `includeDetails`: opens profile pages for richer data

### Example input: mango suppliers in Mexico

```json
{
  "product": "mango",
  "country": "Mexico",
  "maxItems": 50,
  "includeDetails": true
}
````

### Example input: wheat operations

```json
{
  "product": "wheat",
  "maxItems": 100,
  "includeDetails": false
}
```

### Example input: direct profile enrichment

```json
{
  "startUrls": [
    { "url": "https://organic.ams.usda.gov/integrity/CP/OPP?cid=87&nopid=6903966799&ret=Home&retName=Home" }
  ],
  "maxItems": 1,
  "includeDetails": true
}
```

### Output example

```json
{
  "operationName": "\"GALLARCAS\" SPR DE RL",
  "operationId": "8699694577",
  "nopId": "8699694577",
  "certifierId": "12",
  "program": "USDA-NOP",
  "status": "Certified",
  "scopes": ["HANDLING"],
  "certifiedProducts": "HANDLING: Other: MANGO",
  "certifier": "[BAC] BioAgriCert",
  "city": "San Pedro Tapanatepec",
  "stateProvince": "San Pedro Tapanatepec",
  "country": "Mexico",
  "profileUrl": "https://organic.ams.usda.gov/integrity/CP/OPP?...",
  "scrapedAt": "2026-07-03T04:23:04.332Z"
}
```

### Tips for best results

- Start with a product and country for sourcing workflows.
- Use `includeDetails: true` only when you need contact fields.
- Use direct profile URLs for repeat monitoring of known suppliers.
- Increase `maxItems` gradually after confirming the filter returns relevant records.
- Export to CSV for spreadsheet review or JSON for automated pipelines.

### Common workflows

#### Supplier verification

Search by operation name or direct profile URL, then export status, certifier, NOP ID, and status effective date.

#### Organic ingredient sourcing

Search by product and country to find certified suppliers for ingredients such as mango, wheat, coffee, cotton, oilseed, or livestock products.

#### Certifier portfolio analysis

Filter by certifier to build a dataset of public operations associated with an accredited certifier.

#### Compliance monitoring

Schedule recurring runs for direct profile URLs and compare status or contact fields over time.

### Integrations

Use Apify integrations to send results to:

- Google Sheets for procurement review
- Make or Zapier for supplier onboarding workflows
- Webhooks for compliance alerts
- Cloud storage for audit evidence
- Databases and BI dashboards for market research

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/usda-organic-integrity-database-scraper').call({
  product: 'mango',
  country: 'Mexico',
  maxItems: 50,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/usda-organic-integrity-database-scraper').call(run_input={
    'product': 'mango',
    'country': 'Mexico',
    'maxItems': 50,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~usda-organic-integrity-database-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"product":"mango","country":"Mexico","maxItems":50,"includeDetails":true}'
```

### MCP usage

Connect this actor to AI tools through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/usda-organic-integrity-database-scraper`

Claude Code setup:

```bash
claude mcp add apify-usda-organic --transport http "https://mcp.apify.com/?tools=automation-lab/usda-organic-integrity-database-scraper"
```

MCP JSON config:

```json
{
  "mcpServers": {
    "apify-usda-organic": {
      "url": "https://mcp.apify.com/?tools=automation-lab/usda-organic-integrity-database-scraper"
    }
  }
}
```

Example prompts:

- "Find certified organic mango operations in Mexico and summarize the certifiers."
- "Check whether these USDA Organic INTEGRITY profile URLs are still certified."
- "Create a sourcing shortlist from certified organic wheat operations."

### Legality

#### Is it legal to scrape USDA Organic INTEGRITY?

This actor extracts publicly available information from an official government directory. You are responsible for using the data lawfully and respecting applicable privacy, compliance, and procurement rules.

### Limitations

- The USDA site is a Blazor application, so runs use a browser and are slower than pure API actors.
- Some profile fields are optional and may be missing from public records.
- Search filters depend on the public directory behavior; the actor also applies local filtering to improve output relevance.

### FAQ

#### Can I scrape contacts from USDA Organic INTEGRITY?

Yes. Enable `includeDetails` to open each public operation profile and extract contact, address, phone, email, website, and certification-date fields when USDA publishes them.

### Troubleshooting

#### Why did I get fewer records than `maxItems`?

The public directory may contain fewer matching records than your filters request. Try broadening product, country, certifier, or operation filters.

#### Why are contact fields empty?

Enable `includeDetails`. Some USDA operation profiles still do not publish every contact field.

#### Why is my first run slow?

The actor launches a browser because the USDA directory renders results through Blazor. Disable profile details for faster list-only searches.

### Related scrapers

This actor is part of a public-records and compliance data workflow. Depending on your use case, pair USDA Organic INTEGRITY data with related Apify actors for:

- company and supplier discovery
- website enrichment and contact lookup
- regulatory or government-record monitoring
- procurement list building
- recurring compliance checks

Recommended next steps:

- Use a website/contact finder actor after this scraper when you need supplier web domains or public emails beyond the USDA profile fields.
- Use business-directory or search-result scrapers to enrich certified operation names with additional public web presence.
- Use scheduling and webhooks on Apify to monitor a known list of USDA Organic INTEGRITY profile URLs over time.

Related automation-lab actors that pair well with USDA Organic INTEGRITY workflows:

- [SAM.gov Entity Exclusions Scraper](https://apify.com/automation-lab/sam-gov-entity-exclusions-scraper) — screen certified operations against federal exclusion records.
- [FPDS Federal Contracts Scraper](https://apify.com/automation-lab/fpds-federal-contracts-scraper) — connect organic suppliers with federal procurement awards and vendors.
- [Bulk Company Domain Finder](https://apify.com/automation-lab/company-domain-finder) — enrich operation names with likely company websites for outreach or vendor records.
- [ARES Czech Business Registry Scraper](https://apify.com/automation-lab/ares-czech-business-registry-scraper) — combine certified operation data with company registry checks for cross-border supplier due diligence.

### Support

If you need a field from the USDA Organic INTEGRITY profile that is not included yet, open an issue on the actor page with an example profile URL.

# Actor input Schema

## `keyword` (type: `string`):

Operation name, farm/business keyword, or product term to search in USDA Organic INTEGRITY.

## `operationName` (type: `string`):

Specific certified organic operation, farm, or business name. Overrides Keyword for the operation-name filter.

## `product` (type: `string`):

Certified product text such as mango, wheat, livestock, coffee, or cotton.

## `certifier` (type: `string`):

Certifier name/code filter, for example QAI, CCOF, EKOAGROS, or BioAgriCert.

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

City filter exactly as used by the USDA directory.

## `state` (type: `string`):

State or province filter.

## `country` (type: `string`):

Country filter, for example United States, Mexico, Turkey, or Kazakhstan.

## `startUrls` (type: `array`):

Optional USDA Organic INTEGRITY operation profile URLs (CP/OPP) to enrich directly instead of running a search.

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

Maximum operation records to save. Keep this low for first tests; increase for monitoring or compliance exports.

## `includeDetails` (type: `boolean`):

Open each operation profile to add contact, phone, email, acres, anniversary date, effective date, and addresses. Slower but richer.

## Actor input object example

```json
{
  "keyword": "mango",
  "product": "mango",
  "country": "Mexico",
  "startUrls": [
    {
      "url": "https://organic.ams.usda.gov/integrity/CP/OPP?cid=87&nopid=6903966799&ret=Home&retName=Home"
    }
  ],
  "maxItems": 20,
  "includeDetails": false
}
```

# 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 = {
    "keyword": "mango",
    "product": "mango",
    "country": "Mexico",
    "startUrls": [
        {
            "url": "https://organic.ams.usda.gov/integrity/CP/OPP?cid=87&nopid=6903966799&ret=Home&retName=Home"
        }
    ],
    "maxItems": 20,
    "includeDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/usda-organic-integrity-database-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 = {
    "keyword": "mango",
    "product": "mango",
    "country": "Mexico",
    "startUrls": [{ "url": "https://organic.ams.usda.gov/integrity/CP/OPP?cid=87&nopid=6903966799&ret=Home&retName=Home" }],
    "maxItems": 20,
    "includeDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/usda-organic-integrity-database-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 '{
  "keyword": "mango",
  "product": "mango",
  "country": "Mexico",
  "startUrls": [
    {
      "url": "https://organic.ams.usda.gov/integrity/CP/OPP?cid=87&nopid=6903966799&ret=Home&retName=Home"
    }
  ],
  "maxItems": 20,
  "includeDetails": false
}' |
apify call automation-lab/usda-organic-integrity-database-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/usda-organic-integrity-database-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USDA Organic Integrity Database Scraper",
        "description": "🔎 Scrape USDA Organic INTEGRITY certified operations, certification status, products, certifiers, locations, and profile details.",
        "version": "0.1",
        "x-build-id": "Dh0zMk2QjHjaRM9cm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~usda-organic-integrity-database-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-usda-organic-integrity-database-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~usda-organic-integrity-database-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-usda-organic-integrity-database-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~usda-organic-integrity-database-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-usda-organic-integrity-database-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": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Operation name, farm/business keyword, or product term to search in USDA Organic INTEGRITY."
                    },
                    "operationName": {
                        "title": "Operation name",
                        "type": "string",
                        "description": "Specific certified organic operation, farm, or business name. Overrides Keyword for the operation-name filter."
                    },
                    "product": {
                        "title": "Certified product",
                        "type": "string",
                        "description": "Certified product text such as mango, wheat, livestock, coffee, or cotton."
                    },
                    "certifier": {
                        "title": "Certifier",
                        "type": "string",
                        "description": "Certifier name/code filter, for example QAI, CCOF, EKOAGROS, or BioAgriCert."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City filter exactly as used by the USDA directory."
                    },
                    "state": {
                        "title": "State / province",
                        "type": "string",
                        "description": "State or province filter."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country filter, for example United States, Mexico, Turkey, or Kazakhstan."
                    },
                    "startUrls": {
                        "title": "Direct operation profile URLs",
                        "type": "array",
                        "description": "Optional USDA Organic INTEGRITY operation profile URLs (CP/OPP) to enrich directly instead of running a search.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum operations",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum operation records to save. Keep this low for first tests; increase for monitoring or compliance exports.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Open profile details",
                        "type": "boolean",
                        "description": "Open each operation profile to add contact, phone, email, acres, anniversary date, effective date, and addresses. Slower but richer.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```