# USDA Organic Integrity Scraper (`crawlerbros/usda-organic-integrity-scraper`) Actor

Scrape the official USDA Organic INTEGRITY Database of certified organic operations worldwide. Search by operation name, certifier, product scope, certification status, state/province, or country, or look up an operation by NOP Operation ID. No login required.

- **URL**: https://apify.com/crawlerbros/usda-organic-integrity-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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 Scraper

Scrape the official **USDA Organic INTEGRITY Database** — the authoritative registry of certified organic operations worldwide. Search by operation name, certifier, product scope (Crops / Livestock / Handling / Wild Crops), certification status, state/province, or country, or look up a specific operation directly by its NOP Operation ID. Covers USDA-NOP and every recognized international equivalency program (EU, Canada, Japan, Switzerland, South Korea, Taiwan, UK). No login, no API key required.

### What this actor does

- **Two modes:** `search` (filter/browse) and `byOperationId` (exact lookup)
- **Global coverage:** 35 accreditation programs — USDA-NOP plus 26 EU member states and 8 other national equivalency programs
- **Rich filters:** operation name, certifier, certifier client ID, contact last name, product scope, per-scope status, overall certification status, business type, state/province, country, county, ZIP/postal code, certificate number, certified-product keyword, exact product name, status effective-date range
- **Full certification detail** — per-scope status, effective dates, and the exact certified product listing for each of Crops, Livestock, Wild Crops, and Handling
- **Certificate document link** — direct link to the operation's official PDF organic certificate when the certifier publishes one
- **Empty fields are omitted** — an operation with no Handling certification simply has no Handling scope entry, never a placeholder

### Output per operation

- `program`, `certifierName`, `certifierWebsite`, `certifierEmail`
- `operationId` — unique NOP Operation ID
- `operationName`, `otherFormerNames`
- `clientId`, `contactFirstName`, `contactLastName`
- `operationStatus`, `statusEffectiveDate`, `nopAnniversaryDate`
- `scopes[]` — one entry per certified scope: `scope`, `status`, `effectiveDate`, `certifiedProducts`, `additionalCertifiedProducts`, `certificateNumbers`
- `certifiedScopes[]` — convenience list of currently-certified scope names
- `physicalAddress` / `mailingAddress` — `street1`, `street2`, `city`, `state`, `country`, `zip`, `county`, `countyCode`
- `physicalAddressCity`, `physicalAddressState`, `physicalAddressCountry`, `physicalAddressCounty` — flattened for quick filtering
- `phone`, `email`, `websiteUrl`
- `additionalInformation`
- `totalCertifiedAcres`
- `businessTypes[]` — e.g. Broker, Distributor, Retail Food Establishment, Grower Group
- `dataAsOfDate` — when the certifier last updated this record
- `certificateUrl` — direct link to the operation's official PDF organic certificate (when published)
- `sourceUrl` — link to the operation's public record on organic.ams.usda.gov
- `recordType: "operation"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` (filter/browse) or `byOperationId` (exact lookup) |
| `operationName` | string | `Organic Valley` | Free-text operation name search (mode=search) |
| `structuredNameSearch` | boolean | `true` | Use USDA's word-aware name matching instead of raw substring |
| `operationIds` | array | – | NOP Operation IDs to look up (mode=byOperationId, max 20) |
| `certifierName` | string | – | Filter by certifying agent name |
| `certifierClientId` | string | – | Filter by the exact Client ID the certifier assigned to the operation |
| `contactLastName` | string | – | Filter by the operation's primary contact's last name |
| `program` | string | `USDA-NOP` | Accreditation program (35 options — USDA, EU member states, Canada, Japan, etc.) |
| `city` / `state` / `country` / `county` | string | – | Physical-address location filters |
| `zipcode` | string | – | ZIP/postal code filter |
| `certificateNumber` | string | – | Exact certificate number |
| `certifiedProductsKeyword` | string | – | Keyword (substring) search across certified product listings |
| `exactProductName` | string | – | Exact certified product name match (not a substring) |
| `scope` | array | any | Crops / Handling / Livestock / Wild Crops |
| `scopeStatus` | array | any | Per-scope status (Certified / Surrendered / Suspended / Not Certified/Specified) — a finer-grained dimension than `operationStatus` |
| `operationStatus` | array | `["Certified"]` | OVERALL operation status: Certified / Surrendered / Suspended / Revoked |
| `businessType` | array | any | 15 service/business-type options |
| `statusEffectiveDateFrom` / `statusEffectiveDateTo` | string | – | MM/DD/YYYY date range |
| `maxItems` | int | `50` | Hard cap on emitted records (1–20000) |

#### Example: certified coffee handlers in Colombia

```json
{
  "mode": "search",
  "certifiedProductsKeyword": "coffee",
  "scope": ["Handling"],
  "country": "Colombia",
  "maxItems": 100
}
````

#### Example: exact operation lookup by NOP ID

```json
{
  "mode": "byOperationId",
  "operationIds": ["5561000796", "4920007838"]
}
```

#### Example: all certified dairies in Wisconsin

```json
{
  "mode": "search",
  "state": "Wisconsin",
  "businessType": ["Dairy"],
  "scope": ["Livestock"]
}
```

#### Example: look up an operation by its certifier's client ID

```json
{
  "mode": "search",
  "certifierClientId": "OT-007554"
}
```

#### Example: EU-accredited operations in France

```json
{
  "mode": "search",
  "program": "EU France",
  "operationStatus": ["Certified"],
  "maxItems": 200
}
```

### Use cases

- **Supply chain verification** — confirm a supplier's organic certification status and scope before onboarding
- **Import/export compliance** — check international equivalency-program coverage for cross-border organic trade
- **Market research** — map certified organic operations by region, product category, or certifier
- **Due diligence** — verify certificate validity and certifier accreditation for a specific operation
- **Journalism / academic research** — analyze trends in organic certification, surrenders, and revocations

### FAQ

**What is the data source?**
The USDA Organic INTEGRITY Database (organic.ams.usda.gov/integrity), the official public registry of every operation certified under the USDA National Organic Program and its recognized international equivalency arrangements.

**Is this affiliated with the USDA?**
No. This is an independent, third-party actor built on USDA's public search tool.

**Why do some operations have no certificate URL?**
Not all certifiers use USDA's Certificate Module. When a certifier hasn't published a digital certificate, `certificateUrl` is simply omitted rather than showing a broken link.

**Why does an operation sometimes show no address?**
USDA requires at least one of physical or mailing address, but some historical or international records only populate one — the other is omitted rather than fabricated.

**Should I combine `certifierName`/`state`/`country`/`county`/`scope`/`scopeStatus`/`businessType` with another filter?**
Yes, for best results. Those filters are matched against each candidate record rather than the live site's own pickers, so pairing them with `operationName`, `certifiedProductsKeyword`, or `operationStatus` keeps the underlying search well-scoped and returns results faster. Using any of them completely alone still works, but scans a larger sample of certified operations to find matches.

**Why do `businessType: ["Farm"]` or `businessType: ["Livestock"]` never return results?**
USDA's own export file doesn't include a column for those two specific business types (13 of the 15 types do have one), so they can't be verified in the output. Combine a different `businessType` value, or omit it and check the operation's `additionalInformation`/certified products for farm/livestock context instead.

**Why does `scopeStatus: ["Not Certified/Specified"]` never return results?**
A scope the operation was never certified for (e.g. an operation with no Livestock certification at all) has no row for that scope in USDA's export -- there's nothing to check "not certified" against. Use a different `scopeStatus` value, or just omit `scope`/`scopeStatus` to see every scope the operation does hold.

**What's the difference between `operationStatus` and `scopeStatus`?**
`operationStatus` is the operation's one overall certification status (Certified/Surrendered/Suspended/Revoked). `scopeStatus` is finer-grained: an operation can be overall "Certified" while one specific scope (e.g. its Livestock certification) was independently surrendered -- `scopeStatus` matches on that per-scope status instead.

**What's the difference between `certifiedProductsKeyword` and `exactProductName`?**
`certifiedProductsKeyword` is a substring match anywhere in an operation's certified-product listings (e.g. `coffee` matches "Coffee, Roasted"). `exactProductName` requires the certified product name to match exactly.

**What's the difference between `program` and `scope`?**
`program` is the accreditation regime (which government/standard certified the operation, e.g. USDA-NOP or EU France). `scope` is the product category the certification covers (Crops, Livestock, Handling, or Wild Crops).

**How fresh is the data?**
The database is updated continuously by certifiers. Each record's `dataAsOfDate` shows when that certifier last submitted an update.

**Are there rate limits or an API key?**
No. The Organic INTEGRITY Database is a fully public consumer tool with no authentication.

# Actor input Schema

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

What to fetch.

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

Free-text search on the operation's business name, including other/former names (mode=search).

## `structuredNameSearch` (type: `boolean`):

Use USDA's structured (word-aware) name matching instead of a raw substring match.

## `operationIds` (type: `array`):

Exact 10-digit NOP Operation IDs to look up. Example: `5561000796`. Capped at 20 IDs per run.

## `certifierName` (type: `string`):

Filter to a specific certifying agent by name, e.g. `CCOF`, `Control Union`, `Ecocert`.

## `certifierClientId` (type: `string`):

Filter by the operation's exact Client ID as assigned by its certifier (shown on the certifier's own records, e.g. `OT-007554`).

## `contactLastName` (type: `string`):

Filter by the operation's primary contact's last name.

## `program` (type: `string`):

Which national/regional organic program accredited the certifier.

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

Filter by the operation's physical-address city.

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

Filter by the operation's physical-address state or province, e.g. `California`, `Ontario`.

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

Filter by the operation's physical-address country, e.g. `United States of America (the)`, `Mexico`, `China`.

## `county` (type: `string`):

Filter by the operation's physical-address county, e.g. `Tulare County`. Mostly populated for US operations.

## `zipcode` (type: `string`):

Filter by the operation's physical-address ZIP/postal code.

## `certificateNumber` (type: `string`):

Filter by an exact certificate number issued by the certifier.

## `certifiedProductsKeyword` (type: `string`):

Free-text keyword search across all certified product listings, e.g. `coffee`, `apples`, `dairy`.

## `exactProductName` (type: `string`):

Restrict to operations certified for this exact product name (not a substring match, unlike `certifiedProductsKeyword`), e.g. `Coffee`.

## `scope` (type: `array`):

Restrict to operations certified in one or more of these product scopes. Leave empty for all scopes.

## `operationStatus` (type: `array`):

Restrict to operations with one or more of these OVERALL operation certification statuses. Leave empty to default to Certified only.

## `scopeStatus` (type: `array`):

Restrict to operations having at least one certified scope (Crops/Handling/Livestock/Wild Crops) with one of these PER-SCOPE statuses -- a different, finer-grained dimension than `operationStatus`. Leave empty for all. Note: `Not Certified/Specified` can never be verified from the export (an uncertified scope has no row at all) and will always return zero matches.

## `businessType` (type: `array`):

Restrict to operations offering one or more of these services/business types. Leave empty for all.

## `statusEffectiveDateFrom` (type: `string`):

Drop operations whose certification status became effective before this date.

## `statusEffectiveDateTo` (type: `string`):

Drop operations whose certification status became effective after this date.

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

Hard cap on emitted records (mode=search). USDA caps a single export at 20000 rows.

## Actor input object example

```json
{
  "mode": "search",
  "operationName": "Organic Valley",
  "structuredNameSearch": true,
  "operationIds": [],
  "program": "USDA-NOP",
  "scope": [],
  "operationStatus": [
    "Certified"
  ],
  "scopeStatus": [],
  "businessType": [],
  "maxItems": 50
}
```

# Actor output Schema

## `operations` (type: `string`):

Dataset containing all scraped USDA Organic INTEGRITY operations.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "search",
    "operationName": "Organic Valley",
    "structuredNameSearch": true,
    "operationIds": [],
    "program": "USDA-NOP",
    "scope": [],
    "operationStatus": [
        "Certified"
    ],
    "scopeStatus": [],
    "businessType": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/usda-organic-integrity-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "search",
    "operationName": "Organic Valley",
    "structuredNameSearch": True,
    "operationIds": [],
    "program": "USDA-NOP",
    "scope": [],
    "operationStatus": ["Certified"],
    "scopeStatus": [],
    "businessType": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/usda-organic-integrity-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "operationName": "Organic Valley",
  "structuredNameSearch": true,
  "operationIds": [],
  "program": "USDA-NOP",
  "scope": [],
  "operationStatus": [
    "Certified"
  ],
  "scopeStatus": [],
  "businessType": [],
  "maxItems": 50
}' |
apify call crawlerbros/usda-organic-integrity-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USDA Organic Integrity Scraper",
        "description": "Scrape the official USDA Organic INTEGRITY Database of certified organic operations worldwide. Search by operation name, certifier, product scope, certification status, state/province, or country, or look up an operation by NOP Operation ID. No login required.",
        "version": "1.0",
        "x-build-id": "lKzoNDgRC1IWaEizd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~usda-organic-integrity-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-usda-organic-integrity-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~usda-organic-integrity-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-usda-organic-integrity-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~usda-organic-integrity-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-usda-organic-integrity-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byOperationId"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "operationName": {
                        "title": "Operation name",
                        "type": "string",
                        "description": "Free-text search on the operation's business name, including other/former names (mode=search).",
                        "default": "Organic Valley"
                    },
                    "structuredNameSearch": {
                        "title": "Structured name search",
                        "type": "boolean",
                        "description": "Use USDA's structured (word-aware) name matching instead of a raw substring match.",
                        "default": true
                    },
                    "operationIds": {
                        "title": "NOP Operation IDs (mode=byOperationId)",
                        "type": "array",
                        "description": "Exact 10-digit NOP Operation IDs to look up. Example: `5561000796`. Capped at 20 IDs per run.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "certifierName": {
                        "title": "Certifier",
                        "type": "string",
                        "description": "Filter to a specific certifying agent by name, e.g. `CCOF`, `Control Union`, `Ecocert`."
                    },
                    "certifierClientId": {
                        "title": "Certifier client ID",
                        "type": "string",
                        "description": "Filter by the operation's exact Client ID as assigned by its certifier (shown on the certifier's own records, e.g. `OT-007554`)."
                    },
                    "contactLastName": {
                        "title": "Contact last name",
                        "type": "string",
                        "description": "Filter by the operation's primary contact's last name."
                    },
                    "program": {
                        "title": "Accreditation program",
                        "enum": [
                            "USDA-NOP",
                            "USDA-MPI",
                            "USDA-PPIS",
                            "CFIA-COR",
                            "JAS",
                            "SWISS Organic",
                            "South Korea",
                            "Taiwan",
                            "UK",
                            "EU Austria",
                            "EU Belgium",
                            "EU Bulgaria",
                            "EU Croatia",
                            "EU Cyprus",
                            "EU Czechia",
                            "EU Denmark",
                            "EU Estonia",
                            "EU Finland",
                            "EU France",
                            "EU Germany",
                            "EU Greece",
                            "EU Hungary",
                            "EU Ireland",
                            "EU Italy",
                            "EU Latvia",
                            "EU Lithuania",
                            "EU Luxembourg",
                            "EU Netherlands",
                            "EU Poland",
                            "EU Portugal",
                            "EU Romania",
                            "EU Slovakia",
                            "EU Slovenia",
                            "EU Spain",
                            "EU Sweden"
                        ],
                        "type": "string",
                        "description": "Which national/regional organic program accredited the certifier.",
                        "default": "USDA-NOP"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Filter by the operation's physical-address city."
                    },
                    "state": {
                        "title": "State / Province",
                        "type": "string",
                        "description": "Filter by the operation's physical-address state or province, e.g. `California`, `Ontario`."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Filter by the operation's physical-address country, e.g. `United States of America (the)`, `Mexico`, `China`."
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Filter by the operation's physical-address county, e.g. `Tulare County`. Mostly populated for US operations."
                    },
                    "zipcode": {
                        "title": "ZIP / postal code",
                        "type": "string",
                        "description": "Filter by the operation's physical-address ZIP/postal code."
                    },
                    "certificateNumber": {
                        "title": "Certificate number",
                        "type": "string",
                        "description": "Filter by an exact certificate number issued by the certifier."
                    },
                    "certifiedProductsKeyword": {
                        "title": "Certified products keyword",
                        "type": "string",
                        "description": "Free-text keyword search across all certified product listings, e.g. `coffee`, `apples`, `dairy`."
                    },
                    "exactProductName": {
                        "title": "Exact product name",
                        "type": "string",
                        "description": "Restrict to operations certified for this exact product name (not a substring match, unlike `certifiedProductsKeyword`), e.g. `Coffee`."
                    },
                    "scope": {
                        "title": "Product category (scope)",
                        "type": "array",
                        "description": "Restrict to operations certified in one or more of these product scopes. Leave empty for all scopes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Crops",
                                "Handling",
                                "Livestock",
                                "Wild Crops"
                            ],
                            "enumTitles": [
                                "Crops",
                                "Handling",
                                "Livestock",
                                "Wild Crops"
                            ]
                        },
                        "default": []
                    },
                    "operationStatus": {
                        "title": "Certification status",
                        "type": "array",
                        "description": "Restrict to operations with one or more of these OVERALL operation certification statuses. Leave empty to default to Certified only.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Certified",
                                "Surrendered",
                                "Suspended",
                                "Revoked"
                            ],
                            "enumTitles": [
                                "Certified",
                                "Surrendered",
                                "Suspended",
                                "Revoked"
                            ]
                        },
                        "default": [
                            "Certified"
                        ]
                    },
                    "scopeStatus": {
                        "title": "Scope status",
                        "type": "array",
                        "description": "Restrict to operations having at least one certified scope (Crops/Handling/Livestock/Wild Crops) with one of these PER-SCOPE statuses -- a different, finer-grained dimension than `operationStatus`. Leave empty for all. Note: `Not Certified/Specified` can never be verified from the export (an uncertified scope has no row at all) and will always return zero matches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Certified",
                                "Surrendered",
                                "Suspended",
                                "Not Certified/Specified"
                            ],
                            "enumTitles": [
                                "Certified",
                                "Surrendered",
                                "Suspended",
                                "Not Certified/Specified"
                            ]
                        },
                        "default": []
                    },
                    "businessType": {
                        "title": "Business type",
                        "type": "array",
                        "description": "Restrict to operations offering one or more of these services/business types. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "Broker",
                                "Community Supported Agriculture (CSA)",
                                "Co-Packer",
                                "Dairy",
                                "Distributor",
                                "Farm",
                                "Grower Group",
                                "Livestock",
                                "Marketer/Trader",
                                "Poultry",
                                "Private Labeler",
                                "Restaurant",
                                "Retail Food Establishment",
                                "Slaughterhouse",
                                "Storage"
                            ],
                            "enumTitles": [
                                "Broker",
                                "Community Supported Agriculture (CSA)",
                                "Co-Packer",
                                "Dairy",
                                "Distributor",
                                "Farm",
                                "Grower Group",
                                "Livestock",
                                "Marketer/Trader",
                                "Poultry",
                                "Private Labeler",
                                "Restaurant",
                                "Retail Food Establishment",
                                "Slaughterhouse",
                                "Storage"
                            ]
                        },
                        "default": []
                    },
                    "statusEffectiveDateFrom": {
                        "title": "Status effective date from (MM/DD/YYYY)",
                        "type": "string",
                        "description": "Drop operations whose certification status became effective before this date."
                    },
                    "statusEffectiveDateTo": {
                        "title": "Status effective date to (MM/DD/YYYY)",
                        "type": "string",
                        "description": "Drop operations whose certification status became effective after this date."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Hard cap on emitted records (mode=search). USDA caps a single export at 20000 rows.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
