# USDA Cash Grain Bids Scraper (`automation-lab/usda-cash-grain-bids-scraper`) Actor

🌾 Extract location-level USDA cash grain bids, basis, delivery terms, and futures settlements from official public AMS Market News PDF reports.

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

## USDA Cash Grain Bids Scraper

Turn public USDA AMS cash grain report PDFs into structured cash bids and futures settlements.

The Actor downloads official Market News reports directly from USDA, parses location-level bid tables, and exports analysis-ready JSON, CSV, Excel, or API data.

Use it for scheduled regional price snapshots, grain procurement research, elevator comparisons, basis tracking, and agritech data pipelines.

- 🌽 Capture commodity, grade, facility, region, location, basis, and cash price.
- 📈 Separate futures settlements by exchange and contract month.
- 🗓️ Preserve report date and final/preliminary status.
- 🚚 Keep freight and delivery terms attached to each bid.
- 🔗 Trace every row to its official USDA PDF.
- ⚡ Use direct HTTP without a browser, login, or proxy.

### What does USDA Cash Grain Bids Scraper do?

USDA Cash Grain Bids Scraper reads public PDF reports from USDA Agricultural Marketing Service Market News.

It recognizes report context before parsing each row. That context includes the commodity grade, facility class, region, report date, and report finality.

The primary dataset contains normalized cash bids. A second dataset contains futures settlements found in the same report.

Instead of downloading a PDF and manually copying tables, you receive typed records ready for filtering, comparison, storage, or alerts.

### Who is it for?

#### Grain buyers and merchandisers

Compare current bids across locations and delivery periods before contacting an elevator or processor.

#### Farms and producer groups

Schedule a daily report run and retain price history for marketing decisions.

#### Commodity analysts

Join cash prices and basis observations with futures settlements in a notebook, warehouse, or BI tool.

#### Agritech developers

Add USDA report extraction to a product without maintaining PDF download and parsing infrastructure.

#### Data teams

Export repeatable regional snapshots to JSON, CSV, Excel, Google Sheets, or a database.

### Why use this Actor?

- **Official source:** downloads PDFs from `ams.usda.gov` only.
- **Focused output:** captures cash grain fields rather than returning raw documents.
- **Two clean datasets:** cash bids and futures settlements are not mixed into incompatible rows.
- **Bounded runs:** `maxReports` and `maxRows` prevent accidental large jobs.
- **Traceable records:** report URL, slug, title, date, finality, and scrape time are preserved.
- **Scheduling friendly:** stable slugs can be rerun as USDA updates the current report.
- **Explicit failures:** unsupported layouts are reported instead of producing invented values.

### What USDA grain data can I extract?

| Field | Meaning |
|---|---|
| `reportDate` | Date stated by USDA in the report |
| `finality` | Final or preliminary report status |
| `commodity` | Corn, soybeans, wheat, or another reported grain |
| `grade` | USDA grade such as US #2 |
| `facilityClass` | Country elevators, mills, or processors |
| `region` | Report section region |
| `location` | Bid location and state |
| `saleType` | Bid, offer, or ask when present |
| `protein` | Protein classification when reported |
| `basis` | Numeric basis value |
| `basisUnit` | Cents or dollars per bushel from the table header |
| `basisContractSymbol` | Futures month symbol attached to basis |
| `basisChange` | Reported basis movement |
| `cashPricePerBushel` | Cash price in dollars per bushel |
| `priceChange` | Reported cash price movement |
| `averagePrice` | Average shown in the source row |
| `yearAgoPrice` | Prior-year comparison when present |
| `freight` | Delivered, FOB, or CIF code |
| `delivery` | Current or named delivery month |
| `reportUrl` | Official source PDF |

The futures dataset includes exchange, commodity, contract month, and settlement cents per bushel.

### How to scrape USDA cash grain bids

1. Open the Actor input page.
2. Keep the prefilled `ams_3156` report slug or add another USDA AMS report slug.
3. Optionally paste exact USDA `/mnreports/{slug}.pdf` URLs.
4. Choose the maximum number of reports and output rows.
5. Enable cash bids, futures settlements, or both.
6. Click **Start**.
7. Export cash bids from the default dataset.
8. Select the futures settlements dataset from the run Storage tab when needed.

The prefilled run processes one public report and finishes well within the normal Actor timeout.

### Input parameters

#### `reportSlugs`

An array of USDA PDF filenames without `.pdf`.

Example: `ams_3156` resolves to:

`https://www.ams.usda.gov/mnreports/ams_3156.pdf`

#### `reportUrls`

Optional direct USDA AMS PDF URLs.

Only HTTPS URLs on `ams.usda.gov` or `www.ams.usda.gov` under `/mnreports/` are accepted.

#### `maxReports`

Maximum unique reports to download, from 1 to 25.

#### `maxRows`

Maximum combined records saved in one run, from 1 to 10,000.

#### Output switches

Use `includeCashBids` and `includeFuturesSettlements` to select datasets. At least one must be enabled.

### Input example

```json
{
  "reportSlugs": ["ams_3156"],
  "reportUrls": [],
  "maxReports": 1,
  "maxRows": 100,
  "includeCashBids": true,
  "includeFuturesSettlements": true
}
````

Duplicate slugs and URLs are removed before download.

### Output example: cash bid

```json
{
  "recordType": "cash_bid",
  "reportTitle": "North Carolina Cash Grain Bids",
  "reportDate": "2026-07-14",
  "finality": "Final",
  "commodity": "Yellow Corn",
  "grade": "US #2",
  "facilityClass": "Country Elevators - Conventional",
  "region": "Southeast",
  "location": "Autryville, NC",
  "saleType": "Bid",
  "basis": 5,
  "basisUnit": "¢/Bu",
  "basisContractSymbol": "U",
  "cashPricePerBushel": 4.435,
  "priceChangeDirection": "UP",
  "priceChange": 0.0075,
  "averagePrice": 4.435,
  "yearAgoPrice": 4.0525,
  "freight": "DLVD-T",
  "delivery": "Current",
  "reportUrl": "https://www.ams.usda.gov/mnreports/ams_3156.pdf"
}
```

Optional fields are omitted when USDA does not publish a value for that row.

### Output example: futures settlement

```json
{
  "recordType": "futures_settlement",
  "reportTitle": "North Carolina Cash Grain Bids",
  "reportDate": "2026-07-14",
  "finality": "Final",
  "exchange": "CBOT",
  "commodity": "Corn",
  "contractMonth": "Jul 26",
  "settlementCentsPerBushel": 433.75,
  "reportUrl": "https://www.ams.usda.gov/mnreports/ams_3156.pdf"
}
```

Cash bids are in the default dataset. Futures settlements are in the `futuresSettlements` dataset.

### How much does it cost to extract USDA cash grain bids?

The Actor uses pay-per-event pricing:

- one small start charge per run;
- one result charge for each saved cash bid or futures settlement;
- lower per-record prices on higher Apify subscription tiers.

The exact live prices appear on the Actor pricing tab before you start a run.

Use `maxRows` to set a hard spending boundary. A prefilled run is intentionally limited to 100 records.

Direct PDF extraction avoids browser and proxy costs, helping keep scheduled monitoring economical.

### Scheduling daily grain price snapshots

Create an Apify schedule using the stable report slug and run it after the report's normal publication time.

Store each run in your destination warehouse or append it to a named historical dataset.

Use `reportDate`, `location`, `commodity`, `delivery`, and `cashPricePerBushel` as comparison keys.

Do not assume every PDF changes every day. Compare report date and finality before sending alerts.

### Tips for reliable extraction

- 🌾 Start with one known report slug before adding a batch.
- 🔢 Set `maxRows` high enough for both selected datasets.
- 🗓️ Keep `reportDate` rather than treating scrape time as the market date.
- 📄 Use direct report URLs when another system already discovers the PDF.
- 🚨 Inspect `REPORT_ERRORS` when some reports fail but others succeed.
- 🔁 Schedule stable slugs instead of hard-coding dated download filenames.
- ✅ Validate bid details with the local grain buyer before trading decisions.

### Integrations and workflow patterns

#### Google Sheets

Send each completed default dataset to a sheet for procurement teams. Create a second export for futures settlements.

#### Webhooks and alerts

Use an Actor run webhook to start a comparison workflow. Alert only after matching the same location, commodity, and delivery period.

#### Data warehouses

Load cash bids into a fact table keyed by report date and source dimensions. Keep futures settlements in a separate table.

#### Make and Zapier

Trigger the Actor on a schedule, filter changed bids, and send selected records to email, Slack, or a CRM.

#### Apify datasets

Use dataset API exports for JSON, CSV, Excel, XML, or JSONL consumption.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/usda-cash-grain-bids-scraper').call({
  reportSlugs: ['ams_3156'],
  maxReports: 1,
  maxRows: 100,
  includeCashBids: true,
  includeFuturesSettlements: true,
});

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

The default dataset contains cash bids.

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/usda-cash-grain-bids-scraper').call(run_input={
    'reportSlugs': ['ams_3156'],
    'maxReports': 1,
    'maxRows': 100,
    'includeCashBids': True,
    'includeFuturesSettlements': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Use the run storage metadata to resolve the aliased futures dataset.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~usda-cash-grain-bids-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "reportSlugs": ["ams_3156"],
    "maxReports": 1,
    "maxRows": 100,
    "includeCashBids": true,
    "includeFuturesSettlements": true
  }'
```

Poll the returned run ID, then download its dataset items through the Dataset API.

### Use with Apify MCP

Connect Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/usda-cash-grain-bids-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this server configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/usda-cash-grain-bids-scraper"
    }
  }
}
```

Example prompts:

- “Run the USDA cash grain bids scraper for `ams_3156` and show current corn bids.”
- “Compare soybean cash prices by North Carolina location.”
- “Export futures settlement records from the latest report.”

### Error handling and diagnostics

Invalid hosts, non-PDF URLs, and malformed slugs fail input processing with a clear message.

HTTP and parser errors are logged per report. When a batch contains both good and bad reports, good output is retained and failures are written to `REPORT_ERRORS`.

A run that saves no useful record fails. This prevents silent empty snapshots from entering monitoring pipelines.

The downloader retries transient request failures twice and uses a 45-second request timeout.

### Limitations

USDA publishes multiple report layouts. Version 1 is verified against the current North Carolina Cash Grain Bids report family represented by `ams_3156`.

Other report layouts may require parser support even when they are valid USDA PDFs.

The Actor does not call the authenticated USDA MARS JSON API.

It does not predict prices, recommend trades, or guarantee that a posted bid remains available.

PDF values can be corrected by USDA after publication. Retain report date, finality, and source URL.

### Legality: public USDA grain reports

The Actor accesses public United States government report PDFs without bypassing login or technical access controls.

Users remain responsible for their downstream use, retention, and interpretation of the data.

Respect USDA source notices and attribution requirements. Do not present extracted values as real-time executable quotes.

For commercial decisions, confirm prices and terms with the elevator, mill, processor, or grain buyer.

### FAQ

#### Does it need an USDA API key?

No. Version 1 reads anonymous public USDA AMS report PDFs.

#### Can I provide the full PDF URL?

Yes, if it is an HTTPS `ams.usda.gov/mnreports/{slug}.pdf` URL.

#### Why are cash bids and futures settlements separate?

They are different entities with different fields and analysis workflows. Separate datasets make exports cleaner.

#### Why did a valid report produce an unsupported-layout error?

USDA report templates vary. Share the public report slug when requesting support so a layout adapter can be added.

#### Why is a row missing average or year-ago price?

Those fields are optional because not every source row publishes every comparison value.

#### Does “Final” mean the bid is still available?

No. It is the report's status, not a guarantee of an executable quote.

#### How do I control run size?

Set both `maxReports` and `maxRows`. The Actor stops saving when the combined row limit is reached.

### Related scrapers

- [CFTC Commitments of Traders Scraper](https://apify.com/automation-lab/cftc-commitments-of-traders-scraper) for positioning data published by the CFTC.

Related Actors cover different official financial and commodity datasets. Choose this Actor when the required output is USDA AMS cash grain bids from public reports.

### Support

When reporting a parsing issue, include the public USDA report slug, run ID, and expected row.

Do not include private credentials or confidential trading information.

Logs identify the failed report and preserve successful output from other reports in the same batch.

# Actor input Schema

## `reportSlugs` (type: `array`):

Enter the final PDF filename without .pdf, for example ams\_3156.

## `reportUrls` (type: `array`):

Optional direct https://www.ams.usda.gov/mnreports/{slug}.pdf URLs. Duplicates are removed.

## `maxReports` (type: `integer`):

Stop after this many unique PDFs.

## `maxRows` (type: `integer`):

Maximum combined cash-bid and futures-settlement records per run.

## `includeCashBids` (type: `boolean`):

Save normalized location-level cash bid rows.

## `includeFuturesSettlements` (type: `boolean`):

Save exchange settlement rows by commodity and contract month.

## Actor input object example

```json
{
  "reportSlugs": [
    "ams_3156"
  ],
  "reportUrls": [],
  "maxReports": 1,
  "maxRows": 20,
  "includeCashBids": true,
  "includeFuturesSettlements": true
}
```

# Actor output Schema

## `cashBids` (type: `string`):

No description

## `futuresSettlements` (type: `string`):

No description

## `reportErrors` (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 = {
    "reportSlugs": [
        "ams_3156"
    ],
    "maxReports": 1,
    "maxRows": 20,
    "includeCashBids": true,
    "includeFuturesSettlements": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/usda-cash-grain-bids-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 = {
    "reportSlugs": ["ams_3156"],
    "maxReports": 1,
    "maxRows": 20,
    "includeCashBids": True,
    "includeFuturesSettlements": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/usda-cash-grain-bids-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 '{
  "reportSlugs": [
    "ams_3156"
  ],
  "maxReports": 1,
  "maxRows": 20,
  "includeCashBids": true,
  "includeFuturesSettlements": true
}' |
apify call automation-lab/usda-cash-grain-bids-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USDA Cash Grain Bids Scraper",
        "description": "🌾 Extract location-level USDA cash grain bids, basis, delivery terms, and futures settlements from official public AMS Market News PDF reports.",
        "version": "0.1",
        "x-build-id": "B61NxRIOVMtHOpJzS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~usda-cash-grain-bids-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-usda-cash-grain-bids-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-cash-grain-bids-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-usda-cash-grain-bids-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-cash-grain-bids-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-usda-cash-grain-bids-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": {
                    "reportSlugs": {
                        "title": "🌾 USDA report slugs",
                        "type": "array",
                        "description": "Enter the final PDF filename without .pdf, for example ams_3156.",
                        "default": [
                            "ams_3156"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "reportUrls": {
                        "title": "🔗 USDA report PDF URLs",
                        "type": "array",
                        "description": "Optional direct https://www.ams.usda.gov/mnreports/{slug}.pdf URLs. Duplicates are removed.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReports": {
                        "title": "Maximum reports",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Stop after this many unique PDFs.",
                        "default": 1
                    },
                    "maxRows": {
                        "title": "Maximum output rows",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum combined cash-bid and futures-settlement records per run.",
                        "default": 100
                    },
                    "includeCashBids": {
                        "title": "Include cash bids",
                        "type": "boolean",
                        "description": "Save normalized location-level cash bid rows.",
                        "default": true
                    },
                    "includeFuturesSettlements": {
                        "title": "Include futures settlements",
                        "type": "boolean",
                        "description": "Save exchange settlement rows by commodity and contract month.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
