# USDA Market News Scraper - Livestock, Grain & Commodity Prices (`parseforge/usda-market-news-scraper`) Actor

Scrape commodity market prices from USDA Market News. Get livestock, grain, fruit, vegetable, dairy, and poultry prices with regional breakdowns. Filter by commodity type, report date, and region. Covers daily, weekly, and monthly USDA price reports.

- **URL**: https://apify.com/parseforge/usda-market-news-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🌾 USDA Market News Scraper - Livestock, Grain & Commodity Prices

Whether you're a commodities trader tracking daily prices, a rancher monitoring livestock markets, or an analyst studying agricultural trends, this tool makes it easy to collect structured market data from the USDA Agricultural Marketing Service (AMS).

> **The USDA Market News Scraper collects official commodity price reports from the USDA AMS Market News system. Extract beef, cattle, pork, swine, lamb, and dairy price data with full report metadata, market locations, price ranges, trends, and historical data going back years.**

### ✨ What Does It Do

- 🐄 **Livestock prices** - collect beef, cattle, pork, swine, and lamb price reports from official USDA data
- 🥛 **Dairy data** - extract dairy market reports including cheese, butter, milk, and whey prices
- 📅 **Historical data** - fetch price data for any date range going back years
- 🏢 **Market locations** - get office names, cities, states, and market location details for every report
- 📈 **Trends & narratives** - capture market trend indicators and analyst narratives
- 🔍 **Keyword filtering** - search report titles for specific commodities like "boxed beef", "slaughter", or "hog"

### 🔧 Input

- **Max Items** - how many records to collect (free users get 10 items, paid users up to 1,000,000)
- **Report Type** - filter by commodity type: beef, cattle, pork, swine, lamb, dairy, or all
- **Keyword Filter** - filter report titles by keyword (e.g., "boxed beef", "slaughter", "hog")
- **Date From** - fetch data starting from this date (MM/DD/YYYY format)
- **Date To** - fetch data up to this date (MM/DD/YYYY format)

```json
{
    "reportType": "cattle",
    "keyword": "slaughter",
    "maxItems": 50,
    "dateFrom": "03/01/2026",
    "dateTo": "04/07/2026"
}
````

### 📊 Output

Each record includes report metadata, market location, pricing fields, and trend data. Download as JSON, CSV, or Excel.

| 📌 Field | 📄 Description |
|----------|---------------|
| 📋 reportTitle | Official USDA report title |
| 🏷️ slugName | Report slug identifier |
| 🔢 slugId | Numeric report ID |
| 🐄 marketType | Market type (e.g., Direct Livestock - LMR Beef) |
| 📊 marketTypeCategory | Market type category |
| 🏢 officeName | USDA office issuing the report |
| 🏙️ officeCity | Office city location |
| 🗺️ officeState | Office state location |
| 📍 marketLocationName | Market location name |
| 📅 reportDate | Date of the report data |
| 📅 publishedDate | Date the report was published |
| 📈 trend | Market trend indicator |
| 📝 narrative | Analyst market narrative |
| 🔄 isCorrection | Whether this is a correction to a prior report |

```json
{
    "reportTitle": "National Daily Direct Hog Prior Day Report - Slaughtered Swine",
    "slugName": "LM_HG200",
    "slugId": "3458",
    "marketType": "Direct Livestock - LMR Pork",
    "marketTypeCategory": "Pork",
    "officeName": "Des Moines",
    "officeCode": "DM",
    "officeCity": "Des Moines",
    "officeState": "IA",
    "marketLocationName": "National",
    "marketLocationCity": "",
    "marketLocationState": "",
    "reportDate": "04/04/2026",
    "publishedDate": "04/07/2026",
    "trend": null,
    "narrative": null,
    "isCorrection": null,
    "sections": ["Barrows and Gilts"],
    "purchase_type": "Negotiated (carcass basis)",
    "head_count": "2,187",
    "price_low": "88.00",
    "price_high": "90.00",
    "weighted_average": "89.25",
    "scrapedAt": "2026-04-07T12:00:00.000Z"
}
```

### 💎 Why Choose the USDA Market News Scraper?

| Feature | Our Tool | Manual USDA Portal |
|---------|----------|-------------------|
| Batch collection | ✅ Up to 1M records | ❌ Browse one report at a time |
| Multiple commodities | ✅ Beef, cattle, pork, lamb, dairy | ⚠️ Navigate each separately |
| Historical data | ✅ Custom date ranges | ⚠️ Limited date filtering |
| Structured output | ✅ JSON, CSV, Excel | ❌ PDF/HTML reports only |
| Automated scheduling | ✅ Daily/weekly monitoring | ❌ Manual visits |
| Keyword search | ✅ Filter by report title | ⚠️ Browse through catalog |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - choose your report type, add keyword filters, and set a date range
3. **Run It** - click "Start" and get structured commodity price data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 📈 **Commodities traders** - monitor daily livestock prices and spot price movements across markets
- 🐄 **Ranchers & feedlots** - track cattle and hog prices to time sales and purchases
- 🥛 **Dairy processors** - follow cheese, butter, and milk price reports for procurement decisions
- 📊 **Market analysts** - build historical price datasets for trend analysis and forecasting models
- 🏦 **Financial institutions** - collect commodity price data for risk assessment and derivatives pricing
- 🏛️ **Policy researchers** - analyze agricultural market trends across regions and time periods

### ❓ FAQ

🌾 **What is USDA Market News?**
USDA Market News is the official reporting service of the Agricultural Marketing Service (AMS). It publishes daily and weekly reports on livestock, dairy, grain, and other commodity prices from markets across the United States.

🐄 **What report types are available?**
The scraper supports beef, cattle, pork, swine, lamb, and dairy reports. Use "all" to fetch every available report type. Over 149 official USDA reports are available.

📅 **How far back does historical data go?**
The USDA AMS API provides historical data going back several years. Use the Date From and Date To fields to specify your desired range.

⏱️ **How long does a run take?**
Fetching 500 records typically takes about 5-10 seconds. The scraper paginates through USDA API results automatically with 500 rows per page.

📊 **What pricing fields are included?**
Pricing fields vary by report type but commonly include price\_low, price\_high, weighted\_average, head\_count, lot\_count, and other commodity-specific fields like carcass weight, yield grade, and quality grade.

### 🔗 Integrate USDA Market News Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate commodity price monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when prices hit your thresholds
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get daily price updates in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export price data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more market data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| GSA eLibrary Scraper | Collect government contract data from GSA | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| Federal Register Scraper | Collect regulatory notices and rules | [Link](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| USASpending Scraper | Gather federal spending and award data | [Link](https://apify.com/parseforge/usaspending-scraper) |

**Pro Tip:** 💡 Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the USDA, the Agricultural Marketing Service, or any government agency. It accesses only publicly available data through the official USDA AMS Market News API.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `reportType` (type: `string`):

Filter reports by commodity type. Use 'all' to fetch all available market types.

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

Filter report titles by keyword (e.g., 'boxed beef', 'slaughter', 'hog', 'dairy'). Case-insensitive.

## `dateFrom` (type: `string`):

Fetch data starting from this date (MM/DD/YYYY format, e.g., '03/01/2026'). Defaults to most recent data.

## `dateTo` (type: `string`):

Fetch data up to this date (MM/DD/YYYY format, e.g., '04/07/2026'). Defaults to today.

## Actor input object example

```json
{
  "maxItems": 10,
  "reportType": "cattle"
}
```

# Actor output Schema

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

Overview of market news report records

## `fullData` (type: `string`):

Complete dataset with all scraped market news fields

# 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 = {
    "maxItems": 10,
    "reportType": "cattle"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/usda-market-news-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 = {
    "maxItems": 10,
    "reportType": "cattle",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/usda-market-news-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 '{
  "maxItems": 10,
  "reportType": "cattle"
}' |
apify call parseforge/usda-market-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USDA Market News Scraper - Livestock, Grain & Commodity Prices",
        "description": "Scrape commodity market prices from USDA Market News. Get livestock, grain, fruit, vegetable, dairy, and poultry prices with regional breakdowns. Filter by commodity type, report date, and region. Covers daily, weekly, and monthly USDA price reports.",
        "version": "0.0",
        "x-build-id": "bhmrKnpkKO90MCxv5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~usda-market-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-usda-market-news-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/parseforge~usda-market-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-usda-market-news-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/parseforge~usda-market-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-usda-market-news-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "reportType": {
                        "title": "Report Type",
                        "enum": [
                            "all",
                            "beef",
                            "cattle",
                            "pork",
                            "swine",
                            "lamb",
                            "dairy"
                        ],
                        "type": "string",
                        "description": "Filter reports by commodity type. Use 'all' to fetch all available market types.",
                        "default": "all"
                    },
                    "keyword": {
                        "title": "Keyword Filter",
                        "type": "string",
                        "description": "Filter report titles by keyword (e.g., 'boxed beef', 'slaughter', 'hog', 'dairy'). Case-insensitive."
                    },
                    "dateFrom": {
                        "title": "Date From",
                        "type": "string",
                        "description": "Fetch data starting from this date (MM/DD/YYYY format, e.g., '03/01/2026'). Defaults to most recent data."
                    },
                    "dateTo": {
                        "title": "Date To",
                        "type": "string",
                        "description": "Fetch data up to this date (MM/DD/YYYY format, e.g., '04/07/2026'). Defaults to today."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
