# US Treasury Fiscal Data Scraper (`compute-edge/treasury-fiscal-scraper`) Actor

Extract US Treasury financial data via the Fiscal Data API. Access national debt, interest rates, exchange rates, gold reserves, revenue collections, and securities data. Supports date filtering and pagination.

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

## Pricing

from $2.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.

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

## US Treasury Fiscal Data Scraper

Extract **US government financial data** from the official **Treasury Fiscal Data API**. Access total public debt outstanding, average interest rates on Treasury securities, daily Treasury statements, exchange rates, gold reserve holdings, revenue collections, and securities outstanding — all from a single Actor with no API key required.

This Actor wraps the Treasury's public Fiscal Data API and provides full support for **date range filtering**, **field-level sorting**, **automatic pagination**, and **rate limit handling**. Output is delivered as clean JSON ready for dashboards, financial models, and data pipelines.

### Key Features

| Feature | Description |
|---------|-------------|
| **7 datasets** | National debt, interest rates, daily statements, exchange rates, gold reserves, revenue, securities |
| **Date range filtering** | Query any historical period with start/end dates |
| **Automatic pagination** | Handles large result sets transparently (up to 1M records) |
| **Flexible sorting** | Sort by any field, ascending or descending |
| **Rate limit handling** | Automatic retry with exponential backoff |
| **No API key required** | Uses the free public Treasury API |

### How to Scrape US Treasury Fiscal Data

1. **Go to this Actor's page** on the Apify Store
2. **Click "Start"** to open the input configuration form
3. **Select a Dataset** — choose from 7 Treasury fiscal datasets
4. **Set date range** (optional) — enter start and end dates in YYYY-MM-DD format
5. **Set sort field** (optional) — default is `record_date`
6. **Set Max Results** — default: 1000, set to 0 for unlimited
7. **Click "Start"** to run the Actor
8. **Download your data** in JSON, CSV, or Excel from the Dataset tab

### Input Example

```json
{
    "dataset": "debt_to_penny",
    "startDate": "2024-01-01",
    "endDate": "2024-12-31",
    "sortField": "record_date",
    "sortDescending": true,
    "maxResults": 500
}
````

### Output Example

```json
{
    "recordDate": "2024-12-31",
    "debtHeldByPublicAmt": "28908004857168.12",
    "intragovtHoldingsAmt": "7265207091498.63",
    "totPubDebtOutstdgAmt": "36173211948666.75",
    "source": "Total Public Debt Outstanding"
}
```

### Available Datasets

| Dataset | Description |
|---------|-------------|
| **Total Public Debt Outstanding** | Daily national debt totals (debt held by public + intragovernmental holdings) |
| **Average Interest Rates** | Monthly average interest rates on Treasury securities by type |
| **Daily Treasury Statement** | Daily operating cash balance of the US government |
| **Exchange Rates** | Treasury exchange rates for foreign currencies |
| **Gold Reserve** | US gold reserve holdings and valuation |
| **Revenue Collections** | Federal tax revenue collections by category |
| **Securities Outstanding** | Outstanding Treasury securities by type and maturity |

### Pricing

This Actor uses **pay-per-result** pricing:

| Event | Price |
|-------|-------|
| Actor Start | $0.00005 |
| Per result | $0.002 |

A typical run of 500 records costs approximately $1.00 in Actor fees plus minimal Apify compute costs.

### Use Cases

- **Financial analysis** — Track national debt trends, interest rate movements, and government revenue
- **Macroeconomic research** — Feed Treasury data into economic models and forecasting tools
- **Currency analysis** — Monitor Treasury exchange rates for forex research
- **Government accountability** — Track spending, debt, and revenue patterns over time
- **Data journalism** — Build visualizations of national debt and fiscal trends
- **RAG/LLM pipelines** — Structured fiscal data ready for AI-powered financial analysis

### FAQ

#### Is it legal to scrape Treasury fiscal data?

Yes. This Actor uses the official Treasury Fiscal Data API, which is a free public government data service. The data is in the public domain and freely available for any use. No authentication is required.

#### How Much Does It Cost to Scrape Treasury Fiscal Data?

See the pricing table above. At $0.002 per result, fetching a year of daily debt data (~250 records) costs approximately $0.50 in Actor fees plus minimal Apify compute costs.

#### Can I export Treasury data to Excel or CSV?

Yes. Apify supports exporting results in JSON, CSV, Excel, XML, and other formats directly from the Dataset tab after a run completes.

#### How often is the Treasury data updated?

Most datasets are updated daily (debt, daily statements) or monthly (interest rates, revenue). You can schedule this Actor to run at any interval to keep your data current.

#### How far back does the data go?

Data availability varies by dataset. Total Public Debt Outstanding goes back to 1993. Average Interest Rates data is available from 2001. Exchange rate data spans several decades.

### Other Scrapers by SeatSignal

- [SEC EDGAR Scraper](https://apify.com/seatsignal/sec-edgar-scraper) — Extract SEC filings, company data, and financial statements
- [Federal Audit Scraper](https://apify.com/seatsignal/federal-audit-scraper) — Extract federal audit and grant data from the Federal Audit Clearinghouse
- [EIA Energy Data Scraper](https://apify.com/seatsignal/eia-energy-scraper) — Extract petroleum, natural gas, and electricity data
- [SBIR Awards Scraper](https://apify.com/seatsignal/sbir-awards-scraper) — Extract government grant and contract award data
- [HUD Fair Market Rents Scraper](https://apify.com/seatsignal/hud-fair-market-rents-scraper) — Extract HUD housing affordability data

### Legal Disclaimer

This Actor accesses publicly available data from the Treasury Fiscal Data API (fiscaldata.treasury.gov). The data is provided by the U.S. Department of the Treasury for public use. This Actor does not bypass any authentication or access controls. Users are responsible for ensuring their use of the data complies with applicable laws and regulations.

For questions or support, please open an issue on this Actor's page.

# Actor input Schema

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

Which Treasury fiscal dataset to query.

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

Filter records from this date (YYYY-MM-DD format). Leave empty for no lower bound.

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

Filter records up to this date (YYYY-MM-DD format). Leave empty for no upper bound.

## `sortField` (type: `string`):

Field name to sort results by. Most datasets have 'record\_date' as the primary date field.

## `sortDescending` (type: `boolean`):

Sort results in descending order (newest first). Set to false for ascending (oldest first).

## `maxResults` (type: `integer`):

Maximum number of records to return. Set to 0 for unlimited (all available records).

## Actor input object example

```json
{
  "dataset": "debt_to_penny",
  "startDate": "",
  "endDate": "",
  "sortField": "record_date",
  "sortDescending": true,
  "maxResults": 1000
}
```

# Actor output Schema

## `dataset` (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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Treasury Fiscal Data Scraper",
        "description": "Extract US Treasury financial data via the Fiscal Data API. Access national debt, interest rates, exchange rates, gold reserves, revenue collections, and securities data. Supports date filtering and pagination.",
        "version": "0.1",
        "x-build-id": "qehFpt56ipBsV6eXE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~treasury-fiscal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-treasury-fiscal-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/compute-edge~treasury-fiscal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-treasury-fiscal-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/compute-edge~treasury-fiscal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-treasury-fiscal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "dataset"
                ],
                "properties": {
                    "dataset": {
                        "title": "Dataset",
                        "enum": [
                            "avg_interest_rates",
                            "debt_to_penny",
                            "dts_table_1",
                            "rates_of_exchange",
                            "gold_reserve",
                            "revenue_collections",
                            "securities_outstanding"
                        ],
                        "type": "string",
                        "description": "Which Treasury fiscal dataset to query.",
                        "default": "debt_to_penny"
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Filter records from this date (YYYY-MM-DD format). Leave empty for no lower bound.",
                        "default": ""
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "Filter records up to this date (YYYY-MM-DD format). Leave empty for no upper bound.",
                        "default": ""
                    },
                    "sortField": {
                        "title": "Sort Field",
                        "type": "string",
                        "description": "Field name to sort results by. Most datasets have 'record_date' as the primary date field.",
                        "default": "record_date"
                    },
                    "sortDescending": {
                        "title": "Sort Descending",
                        "type": "boolean",
                        "description": "Sort results in descending order (newest first). Set to false for ascending (oldest first).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum number of records to return. Set to 0 for unlimited (all available records).",
                        "default": 1000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
