# TreasuryDirect Scraper | US Treasury Securities Data (`parseforge/treasury-direct-scraper`) Actor

Extract TreasuryDirect securities auction data: CUSIP, security type, issue and maturity dates, interest rate, and high yield. Filter by type and date range. Useful for fixed income analysts, fintech apps, and researchers tracking US Treasury debt markets.

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

## Pricing

from $19.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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏦 TreasuryDirect Scraper

> 🚀 **Export US Treasury securities data in seconds.** Savings bonds, T-bills, notes, bonds, sales, transfers, and outstanding balances, straight to CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-25 · **📊 multi-field** records · **Full historical coverage** · **TreasuryDirect & Bureau of the Fiscal Service**

The US Treasury publishes a rich set of marketable and non-marketable securities datasets via the Fiscal Data API. This actor wraps those endpoints, returning per-record data on sales, transfers, outstanding amounts, and savings bonds.

Coverage spans the full historical record published by Treasury, with multi-fiscal-year reporting and per-security-type breakdowns.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Finance teams | Treasury market analysis |
| Researchers | Public debt research |
| Journalists | Federal debt reporting |
| Investors | Track savings bond programs |

### 📋 What the TreasuryDirect Scraper does

- Calls Treasury Fiscal Data API for selected dataset
- Supports date filtering and pagination
- Returns raw record fields plus scrapedAt timestamp

> 💡 **Why it matters:** Treasury debt data, accessible without manual portal queries.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

<table>
<thead><tr><th>Field</th><th>Type</th><th>Description</th></tr></thead>
<tbody>
<tr><td>dataset</td><td>enum</td><td>Choose securities_sales, securities_transfers, securities_outstanding, savings_bonds_pieces_amounts_owned</td></tr>
<tr><td>maxItems</td><td>integer</td><td>Cap on rows</td></tr>
<tr><td>startDate</td><td>string</td><td>YYYY-MM-DD</td></tr>
<tr><td>endDate</td><td>string</td><td>YYYY-MM-DD</td></tr>
</tbody>
</table>

```json
{ "dataset": "securities_sales", "maxItems": 50 }
````

```json
{ "dataset": "securities_outstanding", "startDate": "2024-01-01", "endDate": "2024-12-31" }
```

> ⚠️ **Good to Know:** Each dataset has different fields. Sample the first run with maxItems=3 to inspect the schema.

### 📊 Output

Each record includes the raw fields from the chosen Fiscal Data dataset plus `scrapedAt` and `error`.

### ✨ Why choose this Actor

- Official Treasury Fiscal Data API
- No auth required
- Historical depth back to dataset inception

### 📈 How it compares to alternatives

| Approach | Cost | Speed | Maintenance |
|---|---|---|---|
| This actor | Pay per result | Fast | None |
| Fiscal Data portal manual | Free | Slow | High |
| Custom scripts | Free | Fast | Custom code |

### 🚀 How to use

1. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open the actor
3. Pick a dataset and optional date range
4. Run
5. Download dataset as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Treasury research

Sales and outstanding amounts by security type.

#### Compliance

Auditing federal debt issuance over time.

#### Investor relations

Reporting on Series I/EE bond programs.

#### Macro analysts

Quantifying Treasury supply.

### 🔌 Automating TreasuryDirect Scraper

Make, Zapier, Slack, Airbyte, GitHub Actions, Google Drive.

### 🌟 Beyond business use cases

#### Research

Public finance studies.

#### Personal

Track your savings bond program.

#### Non-profit

Government accountability work.

#### Experimentation

Train models on Treasury issuance.

### 🤖 Ask an AI assistant about this scraper

ChatGPT, Claude, Perplexity, or Copilot can explain the datasets.

### ❓ Frequently Asked Questions

**Q: What is Fiscal Data?** A: The Bureau of the Fiscal Service open data portal.
**Q: Do I need API keys?** A: No.
**Q: Which datasets are supported?** A: Sales, transfers, outstanding, savings bonds.
**Q: What is the data lag?** A: Datasets are updated monthly.
**Q: Are auction results included?** A: They are exposed by separate auction datasets.
**Q: How far back?** A: Dataset-dependent.
**Q: Can I filter by security type?** A: Use start/end dates here; filter further downstream.
**Q: What currency?** A: USD.
**Q: How is data normalised?** A: Raw fields are passed through.
**Q: Are there real-time prices?** A: Treasury Fiscal Data is statistical, not market quotes.

### 🔌 Integrate with any app

Make, Zapier, Slack, Airbyte, GitHub Actions, Google Sheets, Webhooks.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [USAspending Contracts Scraper](https://apify.com/parseforge/usaspending-contracts-scraper) | Federal awards data |
| [BLS CPI Data Scraper](https://apify.com/parseforge/bls-cpi-data-scraper) | Consumer Price Index series |
| [FDIC Bank Scraper](https://apify.com/parseforge/fdic-bank-scraper) | FDIC institution data |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the US Treasury. Only publicly available data collected.

# Actor input Schema

## `dataset` (type: `string`):

Treasury Fiscal Data dataset to pull

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

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

## `startDate` (type: `string`):

Optional record\_date lower bound.

## `endDate` (type: `string`):

Optional record\_date upper bound.

## Actor input object example

```json
{
  "dataset": "securities_sales",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/treasury-direct-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/treasury-direct-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
}' |
apify call parseforge/treasury-direct-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TreasuryDirect Scraper | US Treasury Securities Data",
        "description": "Extract TreasuryDirect securities auction data: CUSIP, security type, issue and maturity dates, interest rate, and high yield. Filter by type and date range. Useful for fixed income analysts, fintech apps, and researchers tracking US Treasury debt markets.",
        "version": "0.1",
        "x-build-id": "R3sBJvqk1j6viNA6M"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~treasury-direct-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-treasury-direct-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~treasury-direct-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-treasury-direct-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~treasury-direct-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-treasury-direct-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": {
                    "dataset": {
                        "title": "Dataset",
                        "enum": [
                            "securities_sales",
                            "securities_transfers",
                            "securities_outstanding",
                            "savings_bonds_pieces_amounts_owned"
                        ],
                        "type": "string",
                        "description": "Treasury Fiscal Data dataset to pull",
                        "default": "securities_sales"
                    },
                    "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"
                    },
                    "startDate": {
                        "title": "Start Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional record_date lower bound."
                    },
                    "endDate": {
                        "title": "End Date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Optional record_date upper bound."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```