# 📈 Stock Buyback Announcement Tracker (`nexgendata/stock-buyback-announcement-tracker`) Actor

Track recent share-repurchase (buyback) announcements from SEC EDGAR filings, with authorized dollar amounts extracted. For equity investors, event-driven funds, and IR teams.

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

## Pricing

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

## 📈 Stock Buyback Announcement Tracker — SEC Repurchase API

**Track every share-repurchase (buyback) announcement the moment it hits SEC EDGAR — with the authorized dollar amount extracted from the filing text. Pay-per-result JSON, $0.10 per announcement. No Bloomberg seat, no FactSet contract, no event-feed subscription.**

Buybacks are one of the cleanest event-driven signals on the tape: a board that authorizes a $2B repurchase is telling the market it thinks its own stock is cheap, and the announcement itself moves the price. This actor reads the official SEC EDGAR full-text search index for new buyback language across 8-K, 10-Q and any other form type you point it at, then optionally opens each filing and pulls out the authorized dollar amounts ("up to $500 million", "an additional $1.0 billion", "10 million shares") so the dollar magnitude — the actual signal — lands in your dataset instead of buried in a PDF. Every record carries company name, ticker, filing date, form type, the extracted amounts array, and a direct EDGAR document URL so you can verify against the primary source in one click.

### Why use this

Buyback intelligence is gated behind expensive terminals and event-feed vendors. Bloomberg's event-driven analytics, FactSet's corporate-actions feed, and dedicated buyback-tracking newsletters all charge four- to five-figure annual sums and lock the data behind a per-seat login you cannot pipe into your own model. The raw filings, meanwhile, are public, free, and published on EDGAR the same minute the company files — but finding the repurchase language across thousands of daily 8-Ks and 10-Qs, then parsing the authorized amount out of legalese, is exactly the tedious work that kills a do-it-yourself approach.

This actor closes that gap. It queries EDGAR full-text search the way an analyst would, runs each of your buyback search phrases as an exact-phrase query, de-duplicates across forms, and hands you a clean structured feed. The `extractAmounts` option turns each hit into a quantified event by fetching the filing and regex-extracting the dollar figures, so you can rank announcements by size, filter out trivial top-ups, and route the big authorizations straight to your trading or IR workflow.

### What you get

Every record returned by this actor is structured JSON with the fields below, populated wherever the underlying EDGAR filing provides them:

- `companyName` — the filer's name as registered with the SEC
- `ticker` — exchange ticker symbol when EDGAR maps the filer to one (null for filers without a mapped symbol)
- `filedDate` — the date the filing was accepted by EDGAR (YYYY-MM-DD)
- `formType` — the SEC form the announcement appeared in (8-K, 10-Q, etc.)
- `announcedAmounts` — array of authorized buyback dollar amounts extracted from the filing body (only populated when `extractAmounts` is enabled)
- `documentUrl` — direct link to the primary filing document on sec.gov for one-click verification

The schema is stable across runs, so you can load straight into Snowflake, BigQuery, Postgres, or your CRM without re-mapping each refresh.

### Use cases

- **Event-driven equity trading** — Run the actor every morning with `extractAmounts` on, sort the day's announcements by the largest figure in `announcedAmounts`, and route any authorization above your size threshold (say $500M) to your event-trader. Large buybacks relative to market cap have a documented post-announcement drift you can model against.
- **Buyback-yield screening** — Append each run to a warehouse table keyed on `companyName` + `filedDate`, then join `announcedAmounts` against market cap to compute an authorized-buyback-yield factor for a systematic value/quality sleeve.
- **Investor-relations competitive intelligence** — IR teams track when peer companies announce repurchases and at what magnitude, to time and size their own program and to brief the board with current comparables.
- **Activist and special-situations research** — A fresh buyback authorization is often a defensive response to activist pressure or a signal of excess cash; pair it with insider and 13D feeds to build a fuller picture of capital-allocation intent.
- **Credit and covenant monitoring** — Lenders and credit analysts watch for large repurchase authorizations that draw down cash and can pressure leverage ratios or trip covenants.
- **Quant signal backtesting** — Pull a multi-year history by setting `startDate`/`endDate`, then backtest the announcement-drift and buyback-yield signals on a clean, de-duplicated event set.
- **News and newsletter automation** — Feed the daily feed into an LLM summarizer to auto-draft a "today's buyback announcements" digest with company, ticker, and authorized amount.

### Sample output

```json
{
  "companyName": "APPLE INC",
  "ticker": "AAPL",
  "filedDate": "2026-05-01",
  "formType": "8-K",
  "announcedAmounts": ["$110.0 billion", "$25.0 billion"],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000045/aapl-20260501.htm"
}
````

### Input parameters

| Parameter | Label | Description |
| --- | --- | --- |
| `searchPhrases` | Search phrases | Buyback-related phrases to search in SEC filings; each is run as a separate exact-phrase query (e.g. "share repurchase program", "authorized to repurchase"). |
| `forms` | Filing form types | Comma-separated SEC form types to search (e.g. `8-K` or `8-K,10-Q`). |
| `daysBack` | Days back | Look back this many days from today (ignored if `startDate`/`endDate` are set). |
| `startDate` | Start date (YYYY-MM-DD) | Override the start of the date range. |
| `endDate` | End date (YYYY-MM-DD) | Override the end of the date range. |
| `extractAmounts` | Extract authorized amounts | Fetch each filing and extract the announced buyback dollar amounts — slower, but adds the key signal. |
| `maxResults` | Max results | Maximum number of announcement filings to return. |
| `userAgentContact` | SEC User-Agent contact | SEC requires a User-Agent with contact info. Optional override (e.g. `YourCompany you@email.com`). |

### How to use

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("nexgendata/stock-buyback-announcement-tracker").call(run_input={
    "searchPhrases": ["share repurchase program", "authorized to repurchase"],
    "forms": "8-K,10-Q",
    "daysBack": 7,
    "extractAmounts": True,
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["ticker"], item["formType"], item["announcedAmounts"])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgendata~stock-buyback-announcement-tracker/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchPhrases": ["share repurchase program", "authorized to repurchase"],
    "forms": "8-K,10-Q",
    "daysBack": 7,
    "extractAmounts": true,
    "maxResults": 200
  }'
```

Schedule it daily via Apify's built-in scheduler and dedupe on `companyName` + `filedDate` + `formType` into your warehouse to maintain a rolling buyback-event table. Webhooks let you fire a Slack or n8n alert the moment a new large authorization lands.

### Pricing

This actor runs on Apify's **pay-per-event (PPE)** model — you pay only for results, not run-time:

- **$0.10 per announcement record** pushed to your dataset
- A negligible per-actor-start charge

No subscriptions, no seat licences, no per-CPU-second billing. If EDGAR returns no new buyback filings in your window, you pay essentially nothing.

#### Worked cost example

A daily scheduled run over the trailing 7 days, with `extractAmounts` on, that surfaces 40 buyback announcements:

- 40 records × $0.10 = **$4.00**
- plus one negligible actor-start charge

So roughly **$4 per 40-announcement daily run**, all-in — versus four- and five-figure annual contracts for an equivalent event feed inside Bloomberg or FactSet. A full multi-year backfill of, say, 5,000 historical announcements is a one-time ~$500 — still a rounding error against a single terminal seat.

#### Why pay-per-event beats time-based pricing

- **Predictable** — you know your cost from the record count, not from how long a scrape happened to run.
- **Failure-safe** — if EDGAR changes its HTML and a run returns 0 rows, you pay 0.
- **Easy to attribute** — 1 announcement = 1 unit of cost, so per-strategy or per-desk cost accounting is trivial.

### How this compares to Bloomberg Terminal

| Capability | Bloomberg Terminal | Stock Buyback Announcement Tracker (this actor) |
| --- | --- | --- |
| Buyback / corporate-actions coverage | Global, deeply curated | US SEC EDGAR filers (8-K, 10-Q, any form you query) |
| Authorized-amount extraction | Yes, analyst-curated | Yes, regex-extracted from filing text via `extractAmounts` |
| Annual cost | ~$24,000 / seat / year | Pay-per-record, no subscription |
| Programmatic access | BLPAPI, seat-locked | Apify REST API + webhooks, no seat lock |
| Pipe into your own model / warehouse | Restricted by terms | Native JSON / JSONL / CSV export |

If you need a fully curated global corporate-actions database with analyst overrides and decades of normalized history, a terminal still wins. But if your workflow is a daily event scan of US buyback announcements feeding a trading model, a research screen, or an IR brief, paying per announcement record is the right cost model and a 95%+ saving versus a terminal seat.

### FAQ

**Q: How current is the data?**

A: As current as EDGAR. The SEC accepts and publishes filings throughout the trading day; each run queries EDGAR full-text search live, so a run picks up announcements within minutes of acceptance.

**Q: How accurate are the extracted amounts?**

A: `announcedAmounts` is a regex extraction of dollar figures from the filing body. It is high-precision on standard "up to $X billion / X million shares" language but is a convenience field, not a substitute for reading the filing. Always confirm the authoritative figure against the `documentUrl` before trading on it.

**Q: Why is `ticker` sometimes null?**

A: EDGAR maps many but not all filers to an exchange ticker. Smaller issuers, foreign private issuers, and recently-listed names may file without a mapped symbol; the `companyName` and `documentUrl` always resolve the entity.

**Q: Can I search forms other than 8-K?**

A: Yes. Pass any comma-separated form list to `forms` — buyback language frequently appears in 10-Q and 10-K filings as well as the headline 8-K.

**Q: Can I pull historical announcements?**

A: Yes. Set `startDate` and `endDate` (which override `daysBack`) to backfill any window EDGAR full-text search covers.

**Q: What output formats are supported?**

A: JSON, JSONL, CSV, and Excel via Apify's dataset export, plus webhook delivery.

### Schema stability & versioning

This actor follows NexGenData's **additive-only schema** contract:

- New fields may be **added** at any time — they appear as new JSON keys and default to `null` for older runs.
- Existing fields are **never renamed or removed** without a major-version bump and an advance changelog notice.
- Field semantics (date formats, the meaning of `announcedAmounts`) are **never silently changed** — if a change is needed, we add a new field and keep the old one for at least 90 days.

You can build production pipelines on this actor without a Tuesday change breaking a Friday ETL job.

### Compliance & legal

- The actor reads **public, unauthenticated SEC EDGAR pages** — the same full-text search index and filing documents any browser can open.
- It identifies itself to the SEC with a compliant User-Agent (set yours via `userAgentContact`) per the SEC fair-access policy, and paces requests politely.
- NexGenData is **not affiliated with, endorsed by, or sponsored by** the U.S. Securities and Exchange Commission. "EDGAR" is a service of the SEC.
- The extracted `announcedAmounts` are a convenience parse; the filing at `documentUrl` is the authoritative primary source and should be verified before any investment or compliance decision.
- You are responsible for ensuring your downstream use complies with applicable securities laws and the SEC's terms of access.

### Related NexGenData actors

Part of NexGenData's **SEC / Disclosure** intelligence suite — pair this actor with:

- [SEC Form 4 Insider Monitor](https://apify.com/nexgendata/sec-form-4-insider-monitor?fpr=2ayu9b) — CEO/CFO buys and sells, the insider counterpart to buyback signals
- [SEC 8-K Event Monitor](https://apify.com/nexgendata/sec-8k-event-monitor?fpr=2ayu9b) — all material 8-K events, the form most buybacks are announced in
- [SEC Tender Offer & M\&A Tracker](https://apify.com/nexgendata/sec-tender-offer-ma-tracker?fpr=2ayu9b) — takeover bids and tender offers
- [SEC Executive Compensation & Proxy Tracker](https://apify.com/nexgendata/sec-exec-comp-proxy-tracker?fpr=2ayu9b) — DEF 14A pay and capital-allocation context
- [SEC Form 3 New Insider & 10% Owner Tracker](https://apify.com/nexgendata/sec-form-3-new-insider-tracker?fpr=2ayu9b) — new insiders and beneficial owners
- [SEC Activist Proxy Solicitation Tracker](https://apify.com/nexgendata/sec-activist-proxy-solicitation-tracker?fpr=2ayu9b) — activist campaigns that often trigger defensive buybacks

Browse the full catalog of 200+ buyer-intent actors at **https://apify.com/nexgendata?fpr=2ayu9b**.

# Actor input Schema

## `searchPhrases` (type: `array`):

Buyback-related phrases to search in SEC filings (each run as an exact-phrase query).

## `forms` (type: `string`):

Comma-separated SEC form types to search (e.g. '8-K' or '8-K,10-Q').

## `daysBack` (type: `integer`):

Look back this many days from today (ignored if startDate/endDate set).

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

Override start of the date range.

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

Override end of the date range.

## `extractAmounts` (type: `boolean`):

Fetch each filing and extract the announced buyback dollar amounts (slower but adds the key signal).

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

Maximum number of announcement filings to return.

## `userAgentContact` (type: `string`):

SEC requires a User-Agent with contact info. Optional override (e.g. 'YourCompany you@email.com').

## Actor input object example

```json
{
  "searchPhrases": [
    "share repurchase program",
    "accelerated share repurchase"
  ],
  "forms": "8-K",
  "daysBack": 90,
  "extractAmounts": true,
  "maxResults": 200
}
```

# 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 = {
    "searchPhrases": [
        "share repurchase program",
        "accelerated share repurchase"
    ],
    "forms": "8-K"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/stock-buyback-announcement-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 = {
    "searchPhrases": [
        "share repurchase program",
        "accelerated share repurchase",
    ],
    "forms": "8-K",
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/stock-buyback-announcement-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 '{
  "searchPhrases": [
    "share repurchase program",
    "accelerated share repurchase"
  ],
  "forms": "8-K"
}' |
apify call nexgendata/stock-buyback-announcement-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📈 Stock Buyback Announcement Tracker",
        "description": "Track recent share-repurchase (buyback) announcements from SEC EDGAR filings, with authorized dollar amounts extracted. For equity investors, event-driven funds, and IR teams.",
        "version": "0.0",
        "x-build-id": "jmE8NI9A2UVnbQoH0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~stock-buyback-announcement-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-stock-buyback-announcement-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~stock-buyback-announcement-tracker/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-stock-buyback-announcement-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~stock-buyback-announcement-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-stock-buyback-announcement-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": {
                    "searchPhrases": {
                        "title": "Search phrases",
                        "type": "array",
                        "description": "Buyback-related phrases to search in SEC filings (each run as an exact-phrase query).",
                        "default": [
                            "share repurchase program"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "forms": {
                        "title": "Filing form types",
                        "type": "string",
                        "description": "Comma-separated SEC form types to search (e.g. '8-K' or '8-K,10-Q').",
                        "default": "8-K"
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Look back this many days from today (ignored if startDate/endDate set).",
                        "default": 90
                    },
                    "startDate": {
                        "title": "Start date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Override start of the date range."
                    },
                    "endDate": {
                        "title": "End date (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Override end of the date range."
                    },
                    "extractAmounts": {
                        "title": "Extract authorized amounts",
                        "type": "boolean",
                        "description": "Fetch each filing and extract the announced buyback dollar amounts (slower but adds the key signal).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of announcement filings to return.",
                        "default": 200
                    },
                    "userAgentContact": {
                        "title": "SEC User-Agent contact",
                        "type": "string",
                        "description": "SEC requires a User-Agent with contact info. Optional override (e.g. 'YourCompany you@email.com')."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
