# 🎯 SPAC Tracker — Mergers, Redemptions, Trust Values (`nexgendata/spac-tracker`) Actor

Track active SPACs (Special Purpose Acquisition Companies) with trust values, deadlines, announced mergers, redemption rates, sponsor data. SPAC arbitrage data for special situations desks, hedge funds, retail SPAC traders. Bloomberg SPAC alternative — pay-per-result.

- **URL**: https://apify.com/nexgendata/spac-tracker.md
- **Developed by:** [NexGenData](https://apify.com/nexgendata) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $150.00 / 1,000 spac records

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

## 🎯 SPAC Tracker — Mergers, Redemptions, Trust Values

**Bloomberg SPAC alternative for the rest of us.** Pay-per-result tracking of active Special Purpose Acquisition Companies (SPACs): trust values, combination deadlines, announced mergers, redemption rates, sponsor data, warrant tickers. Built for special situations desks, SPAC arbitrage funds, and retail SPAC traders who want the SPAC-Research-Premium dataset without the $25K seat.

SPACs are weird, lumpy, and full of edges. A SPAC searching for a target with a $10.30 trust value trading at $10.10 is essentially a free option on the merger — but only if you know the deadline, the redemption mechanics, and whether the sponsor has skin in the game. This actor surfaces that signal in a single dataset row.

---

### What this actor does

For every SPAC in coverage, returns a structured record with:

| Field | Meaning |
| --- | --- |
| `symbol` | Common-share ticker (the unit `U` and warrant `W` variants are linked) |
| `name` | Legal entity name |
| `status` | `Searching`, `Announced`, `Voting`, `Completed`, `Liquidated` |
| `target_company` | If a merger has been announced, the operating target |
| `target_sector` | EV, Biotech, Fintech, AI, AgTech, Defense, etc. |
| `ipo_date`, `ipo_amount_usd` | When the SPAC IPO'd and how much it raised into trust |
| `trust_value_per_share` | Current per-share trust value (the redemption floor) |
| `current_price` | Live common-share price from Yahoo Finance |
| `discount_to_trust_pct` | `(trust − price) / trust × 100` — the arb opportunity |
| `deadline_date` | Combination deadline (after which the trust must be returned) |
| `days_to_deadline` | Computed days remaining |
| `sponsor_name` | The promoter/sponsor entity (Klein, Gores, Hennessy, Ares…) |
| `lead_underwriters` | Banks that took the IPO public |
| `redemption_rate_pct` | If announced/voted, what % of public shares redeemed |
| `warrant_symbol`, `warrant_price` | Linked warrant if outstanding |
| `data_source` | Provenance — curated baseline, SEC EDGAR 425, or both |

---

### How it works

The actor combines three signals:

1. **SEC EDGAR full-text search** — pulls every Form 425 (SPAC business-combination communication) filed in the trailing ~120 days, then deduplicates to issuer level. This catches new SPACs and merger-announcement chatter the moment it hits EDGAR.
2. **Curated baseline of high-profile active SPACs** — Churchill, Gores, Ares, Hennessy, Cantor (CF), Kensington, Investcorp, Plum, Pepperlime, Bleichroeder, Columbus, Bowen, AParadise, FinServ, Spark, Twelve Seas, plus completed and liquidated case studies (Polestar / GIIX, Gelesis / GLSHQ, CCC / DGNR, Volato / SOAR, PowerUp / PWUP).
3. **Yahoo Finance** — live common-share price lookups for ticker survivors so `discount_to_trust_pct` is real-time, not a stale snapshot.

The SEC-discovered list refreshes every run; the curated list provides the trust-value and sponsor attributes that EDGAR headers don't carry.

---

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `limit` | int | 50 | Max records to return |
| `status` | enum | `all` | `Searching` / `Announced` / `Voting` / `Completed` / `Liquidated` / `all` |
| `min_trust_usd` | number | 0 | Minimum trust-per-share floor |
| `days_to_deadline_max` | int | 0 | Only SPACs with combination deadlines within N days (0 disables) |
| `sector` | string | `""` | Substring match on `target_sector` (e.g. `EV`, `Biotech`, `Fintech`) |

#### Example inputs

**Find every announced de-SPAC merger that hasn't voted yet:**

```json
{ "status": "Announced", "limit": 100 }
````

**Find SPACs with deadlines inside 90 days (extension or liquidation watchlist):**

```json
{ "status": "Searching", "days_to_deadline_max": 90 }
```

**EV-sector SPACs with trust ≥ $10.20:**

```json
{ "sector": "EV", "min_trust_usd": 10.20 }
```

***

### Pricing

Pay-per-event. You pay only for what's returned:

| Event | Cost |
| --- | --- |
| Actor start | **$0.01** |
| Per SPAC record | **$0.15** |

A 50-record sweep of every announced de-SPAC merger costs **$0.01 + 50 × $0.15 = $7.51**. A daily 5-record watchlist of the SPACs closest to their deadline costs **$0.76 per run, ~$23 / month**.

That's signal-rich proprietary data at a fraction of the cost of the legacy terminals:

#### How we compare

| | **SPAC Tracker** (this actor) | Bloomberg Terminal | FactSet | SPAC Research Premium | SPACInsider Pro |
| --- | --- | --- | --- | --- | --- |
| Annual cost | **~$50 / mo on demand** | $24,000+ / seat | $12,000+ / seat | $4,800+ / yr | $1,800+ / yr |
| Trust value per share | ✅ | ✅ | ✅ | ✅ | ✅ |
| Combination deadline | ✅ | ✅ | ⚠️ partial | ✅ | ✅ |
| Live discount to trust | ✅ | ✅ | ✅ | ⚠️ EOD | ⚠️ EOD |
| Redemption rate | ✅ | ✅ | ✅ | ✅ | ✅ |
| API / JSON | ✅ | ⚠️ B-PIPE only | ⚠️ FactSet API | ❌ PDF + CSV | ❌ CSV |
| Pay-per-record | ✅ | ❌ seat | ❌ seat | ❌ subscription | ❌ subscription |
| Procurement-free | ✅ | ❌ | ❌ | ❌ | ❌ |
| Time to first record | < 60 seconds | weeks | weeks | days | days |

You don't need a Bloomberg terminal to run SPAC arbitrage. You need the deadline, the trust value, and the live price. This actor gives you all three.

***

### Buyer personas

- **Special-situations PMs** — screen for SPACs trading at >2% discount to trust with <12 months to deadline. Riskless yield plus optionality.
- **SPAC-arb funds** — full universe ingestion daily, programmatic redemption signal harvesting.
- **Retail SPAC traders** — pre-merger watchlist with sponsor reputation and target sector.
- **De-SPAC operators / boutique IBs** — sponsor-relationship map for cross-selling.
- **Activist short sellers** — identify SPACs with 90%+ redemption rates (early dilution warning).
- **Equity research analysts** — backfill data for de-SPAC coverage initiation notes.

***

### Why "Tier 5 niche specialty"?

SPACs are a niche dataset — there's no Bloomberg substitute under $10K/year, and the open web is hostile (SPAC Research is behind paywall, SPACInsider is half-rendered JS). But every announcement creates a real money-on-the-table arb. The signal density is high enough that **$0.15 per SPAC record is a screaming buy** versus competing data products. We price for the signal, not the row.

***

### Sister actors — the NexGenData equities-data fleet

Combine SPAC Tracker with the rest of the NexGenData fleet for full event-driven coverage:

- 🚀 **IPO Tracker** — [`nexgendata/ipo-tracker`](https://apify.com/nexgendata/ipo-tracker) — upcoming and recent IPOs, the SPAC merger's "traditional" alternative. Pair these to spot SPAC issuers that lose targets to direct listings.
- 🧾 **SEC Form 13F Holdings Tracker** — [`nexgendata/sec-form-13f-holdings-tracker`](https://apify.com/nexgendata/sec-form-13f-holdings-tracker) — see which hedge funds own SPAC commons and warrants. Cross-reference the sponsor's stake against institutional accumulation.
- ⚡ **SEC Form 8-K Material Events Scraper** — [`nexgendata/sec-form-8k-material-events-scraper`](https://apify.com/nexgendata/sec-form-8k-material-events-scraper) — every announcement, every extension vote, every sponsor PIPE filed as 8-K. Layer it on top of SPAC Tracker for the full event log.
- 📊 **Finviz Stock Screener** — [`nexgendata/finviz-stock-screener`](https://apify.com/nexgendata/finviz-stock-screener) — once a SPAC completes its de-SPAC and trades as the operating company, push the new ticker through Finviz for fundamentals.
- 🔻 **Short Interest Tracker** — [`nexgendata/short-interest-tracker`](https://apify.com/nexgendata/short-interest-tracker) — post-de-SPAC short interest is the canonical signal. A 25%+ short ratio on a freshly merged ex-SPAC is a flashing red light.
- 🤖 **Finance MCP Server** — [`nexgendata/finance-mcp-server`](https://apify.com/nexgendata/finance-mcp-server) — talk to all of these from Claude / ChatGPT / Cursor via MCP. "Show me every announced SPAC with a deadline inside 60 days and trust > $10.30."

***

### Output sample

```json
{
  "symbol": "AACT",
  "name": "Ares Acquisition Corporation II",
  "status": "Announced",
  "target_company": "Kodiak Robotics",
  "target_sector": "Autonomous Trucking",
  "ipo_date": "2023-06-12",
  "ipo_amount_usd": 450000000,
  "trust_value_per_share": 10.45,
  "current_price": 10.31,
  "discount_to_trust_pct": 1.34,
  "deadline_date": "2026-06-12",
  "days_to_deadline": 31,
  "sponsor_name": "Ares Management (David Kaplan)",
  "lead_underwriters": ["Citigroup", "Morgan Stanley"],
  "redemption_rate_pct": null,
  "warrant_symbol": "AACT.WS",
  "warrant_price": null,
  "data_source": "curated_baseline+sec_edgar_425"
}
```

***

### Data refresh and reliability

- **Source 1 — SEC EDGAR Form 425** is the gold standard for SPAC merger communications and runs against the same `efts.sec.gov` full-text index that powers the SEC's own search UI. Refreshes every actor run.
- **Source 2 — curated baseline** is human-maintained. We refresh it on a rolling basis as new SPACs IPO, announce, vote, or liquidate. PRs welcome.
- **Source 3 — Yahoo Finance** provides live common-share prices and is best-effort. If the SPAC ticker is delisted post-merger, `current_price` will be `null` and `discount_to_trust_pct` will be omitted.

We do **not** scrape SPAC Research (paywalled, ToS-restricted) or SPACInsider Pro. Everything in this actor is sourced from public SEC filings or public Yahoo Finance chart endpoints.

***

### FAQ

**Q: How often should I run this?**
Once a day during normal markets is fine. Run it intraday around SPAC vote days (especially 18:00 UTC when 8-K vote tallies tend to hit).

**Q: Why is `redemption_rate_pct` null on most records?**
Because redemption rates are only known once a vote has been held or extension has closed. Pre-vote SPACs have no redemption rate to report.

**Q: Does this cover non-US SPACs (LSE, SGX)?**
Not yet. The current pipeline is US-only (EDGAR-anchored). LSE/SGX SPAC coverage is on the roadmap — let us know if you need it.

**Q: Can I integrate this with my fund's risk system?**
Yes. The output is plain JSON; pipe the Apify dataset into Snowflake, BigQuery, or Postgres via the Apify integrations menu. Many funds run this on a 6-hour cron into a `spac_universe` table.

***

### Get started

Click **Try for free**, set `{"limit": 5}` to validate the schema, then dial up `limit` and add filters as you build your watchlist.

Looking for more actors like this? Browse the full NexGenData fleet and earn me a coffee: **<https://apify.com/nexgendata?fpr=2ayu9b>** 🎯

# Actor input Schema

## `limit` (type: `integer`):

Maximum number of SPAC records to return. Higher limits widen coverage across active SPACs, announced mergers, and recently liquidated trusts. Defaults to 50.

## `status` (type: `string`):

Filter by SPAC lifecycle stage: Searching (trust raised, hunting target), Announced (merger announced, pre-vote), Voting (shareholder vote scheduled), Completed (de-SPAC done), Liquidated (trust returned). 'all' returns every status.

## `min_trust_usd` (type: `number`):

Only include SPACs whose trust value per share is at or above this floor. SPAC arb funds typically filter on $10.00+ to focus on plain-vanilla units. Set 0 to disable.

## `days_to_deadline_max` (type: `integer`):

Only include SPACs whose combination deadline is within this many days. Useful for tracking SPACs running out of runway (often forced to extend or liquidate). Set 0 to disable.

## `sector` (type: `string`):

Optional substring match against target\_sector (e.g. 'EV', 'Biotech', 'Fintech', 'AI'). Leave blank to return all sectors. Case-insensitive substring match.

## Actor input object example

```json
{
  "limit": 50,
  "status": "all",
  "min_trust_usd": 0,
  "days_to_deadline_max": 0,
  "sector": ""
}
```

# 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 = {
    "limit": 50,
    "status": "all",
    "min_trust_usd": 0,
    "days_to_deadline_max": 0,
    "sector": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/spac-tracker").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 = {
    "limit": 50,
    "status": "all",
    "min_trust_usd": 0,
    "days_to_deadline_max": 0,
    "sector": "",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/spac-tracker").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 '{
  "limit": 50,
  "status": "all",
  "min_trust_usd": 0,
  "days_to_deadline_max": 0,
  "sector": ""
}' |
apify call nexgendata/spac-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "🎯 SPAC Tracker — Mergers, Redemptions, Trust Values",
        "description": "Track active SPACs (Special Purpose Acquisition Companies) with trust values, deadlines, announced mergers, redemption rates, sponsor data. SPAC arbitrage data for special situations desks, hedge funds, retail SPAC traders. Bloomberg SPAC alternative — pay-per-result.",
        "version": "0.0",
        "x-build-id": "U1FiU68iY0cfRo4dA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~spac-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-spac-tracker",
                "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/nexgendata~spac-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-spac-tracker",
                "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/nexgendata~spac-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-spac-tracker",
                "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": {
                    "limit": {
                        "title": "Max SPAC records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of SPAC records to return. Higher limits widen coverage across active SPACs, announced mergers, and recently liquidated trusts. Defaults to 50.",
                        "default": 50
                    },
                    "status": {
                        "title": "SPAC status filter",
                        "enum": [
                            "all",
                            "Searching",
                            "Announced",
                            "Voting",
                            "Completed",
                            "Liquidated"
                        ],
                        "type": "string",
                        "description": "Filter by SPAC lifecycle stage: Searching (trust raised, hunting target), Announced (merger announced, pre-vote), Voting (shareholder vote scheduled), Completed (de-SPAC done), Liquidated (trust returned). 'all' returns every status.",
                        "default": "all"
                    },
                    "min_trust_usd": {
                        "title": "Minimum trust value per share (USD)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "number",
                        "description": "Only include SPACs whose trust value per share is at or above this floor. SPAC arb funds typically filter on $10.00+ to focus on plain-vanilla units. Set 0 to disable.",
                        "default": 0
                    },
                    "days_to_deadline_max": {
                        "title": "Maximum days to deadline",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include SPACs whose combination deadline is within this many days. Useful for tracking SPACs running out of runway (often forced to extend or liquidate). Set 0 to disable.",
                        "default": 0
                    },
                    "sector": {
                        "title": "Target sector filter",
                        "type": "string",
                        "description": "Optional substring match against target_sector (e.g. 'EV', 'Biotech', 'Fintech', 'AI'). Leave blank to return all sectors. Case-insensitive substring match.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
