# Delaware State Checkbook - Every State Payment (`j0401/de-checkbook`) Actor

Every payment Delaware's state government made (public open data, 13.5M payment lines, FY2018-today): paying department and division, vendor, expenditure category, fund type, check number and date, and amount. Filter by vendor, department, category, fund or date.

- **URL**: https://apify.com/j0401/de-checkbook.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 delaware state payment records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Delaware State Checkbook - Every State Payment

Every payment the State of Delaware has made, straight from the State's own
accounting system. **13.5 million payment lines**, from the start of fiscal
year 2018 to the last closed accounting period.

### Low cost

**From $0.00005 per record, down to $0.00003 at Gold.** Pay only for the
records you actually receive - the whole register stays queryable, you are
never billed for the scan behind it.

### What you get

One row per check or electronic payment, with the money side of state
government attached to it:

- **Who was paid** - vendor name, exactly as the accounting system holds it
- **Who paid** - the department and the division inside it
- **What for** - the expenditure category, from the State's own chart
- **Out of what** - fund type: General, Special, Federal or Capital
- **When** - check date, plus the fiscal year and period it was charged to
- **How much** - the amount in dollars

That is the full chain: department -> division -> vendor -> category -> fund ->
amount, per payment.

### Filter it

- **Vendor** - `vendor="Grainger"` finds every payment to that supplier.
- **Department and division** - `department="Education"`,
  `division="Christina School District"`.
- **Category** - `category="Medical Services"`, `category="Equipment"`.
- **Fund type** - General, Special, Federal, Capital.
- **Fiscal year** - FY2018 through FY2027.
- **Date range** and **last-N-days** - e.g. the last 30 days of payments.
- **Amount range** - e.g. payments above $1,000,000.

### Example inputs

**Payments to one supplier** - `vendor` is a substring match, and vendor names are free text as typed.

```json
{ "vendor": "GRAINGER", "maxResults": 25 }
```

**What one department buys** - combine `department` with `category`.

```json
{ "department": "EDUCATION", "category": "SUPPLIES", "maxResults": 25 }
```

**One payment by check number** - `checkNumber` is a substring match too.

```json
{ "checkNumber": "0000779890" }
```

**Where the money goes** - `mode=aggregate` returns one count row per department; every group comes back.

```json
{ "mode": "aggregate", "groupBy": "department" }
```

### Or roll it up

Set `mode=aggregate` and get a count by **department**,
**division**, **category**, **fund type** or **fiscal year**. Every group comes
back - this mode is not cut off by `maxResults`.

### Then follow the money

- Total state spending by department or by category, over any window.
- Every payment a supplier has received from the State, and for what.
- Federal vs. General vs. Special fund spend, side by side.
- Payments over a threshold, newest first.

### Example output

**One payment line** - `checkNumber=0000779890` returns the payment as recorded:

```json
{
 "platform": "de-checkbook",
 "source": "delaware-state-checkbook",
 "mode": "rows",
 "groupKey": "",
 "groupCount": "",
 "groupBy": "",
 "fiscalYear": "2027",
 "fiscalPeriod": "2",
 "department": "DEPT OF EDUCATION",
 "division": "CHRISTINA SCHOOL DISTRICT",
 "vendor": "ZOHREH HAZEL COLE",
 "category": "STUDENT SUPPORT SERVICES",
 "fundType": "SPECIAL",
 "checkNumber": "0000779890",
 "checkDate": "2026-08-31T00:00:00.000",
 "amount": "1190",
 "sourceUpdatedAt": "2026-09-06"
}
```

**`mode=aggregate`, `groupBy=department`** - one count row per department:

```
DEPT OF EDUCATION               5,777,325
DEPT OF HEALTH & SOCIAL SVS     1,665,088
DEPT OF NATRL RES AND ENV CONT    777,415
DEPT OF TRANSPORTATION            741,231
HIGHER EDUCATION                  701,400
JUDICIAL                          541,540
```

### Notes on the data, from the source

- **One row is one payment line, not one check.** A single check can carry
  several lines, one per accounting distribution.
- **Check numbers are not serials for bulk runs.** Payroll is stamped
  `PAYROLL` (3,446,472 lines) and purchasing cards `PCA` (1,678,820); the
  remaining lines carry a real 10-digit serial. It is a field and a filter, not
  a key.
- **Refunds and reversals are in here.** 125,268 lines are negative, down to
  -$51,000,000. They are real accounting entries, returned as they stand -
  leave the minimum amount blank to include them, or set it to 0.01 for
  payments only.
- **Vendor names are free text as typed.** The same supplier can appear under
  several spellings.
- **`check_date` is the date the payment cleared**, not the date the work was
  ordered.

# Actor input Schema

## `vendor` (type: `string`):

Substring match on the payee name, e.g. 'GRAINGER', 'DELL', 'MEDICAL'. Vendor names are free text as typed into the accounting system, so the same supplier can appear under several spellings. Blank = any.

## `department` (type: `string`):

Substring match on the paying department, e.g. 'EDUCATION', 'TRANSPORTATION', 'CORRECTIONS'. 25 departments in total. Blank = any.

## `division` (type: `string`):

Substring match on the department's division, e.g. 'CHRISTINA SCHOOL DISTRICT', 'COMMUNITY HEALTH'. 376 divisions in total. Blank = any.

## `category` (type: `string`):

Substring match on the spending category, e.g. 'SUPPLIES', 'MEDICAL', 'EQUIPMENT', 'TRAVEL'. 567 categories in total. Blank = any.

## `checkNumber` (type: `string`):

Substring match on the check number. Note that bulk runs are stamped with a word rather than a serial: 'PAYROLL' covers 3,446,472 lines and 'PCA' (purchasing card) 1,678,820. Blank = any.

## `fundType` (type: `string`):

Exact fund the payment was charged to: 'GENERAL', 'SPECIAL', 'FEDERAL' or 'CAPITAL'. Blank = any.

## `fiscalYear` (type: `integer`):

Exact state fiscal year (July-June), e.g. 2025. Blank = any. FY2018-FY2027 are present.

## `checkFrom` (type: `string`):

Earliest check (payment) date, YYYY-MM-DD. Blank = any.

## `checkTo` (type: `string`):

Latest check (payment) date, YYYY-MM-DD. Blank = any.

## `minAmount` (type: `number`):

Smallest payment amount in dollars. Leave blank to include refunds and reversals, which are negative (125,268 lines, down to -$51,000,000). Set 0.01 for payments only.

## `maxAmount` (type: `number`):

Largest payment amount in dollars. Blank = no upper bound.

## `recentDays` (type: `integer`):

Only payments whose check date falls within the last N days. Ignored when 'Check date from' is set. 0 = off.

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

rows = payment lines matching your filters (default). aggregate = one count row per group (see groupBy).

## `groupBy` (type: `string`):

Which dimension to aggregate over (mode=aggregate). Blank = department. Every group is returned - aggregate mode is not cut off by maxResults.

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

Cap the number of records pushed in rows mode (0 = default 50; up to 2,000 per run). Each record is metered individually, so there is no per-run charge cap. Aggregate mode returns every group.

## Actor input object example

```json
{
  "vendor": "",
  "department": "",
  "division": "",
  "category": "",
  "checkNumber": "",
  "fundType": "",
  "checkFrom": "",
  "checkTo": "",
  "recentDays": 0,
  "mode": "rows",
  "groupBy": "",
  "maxResults": 50
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Delaware state payment records - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (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("j0401/de-checkbook").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("j0401/de-checkbook").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 j0401/de-checkbook --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,j0401/de-checkbook"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/GpukSAawzH3o8XAdh/builds/K5bh6Yc7GGPaWPWNZ/openapi.json