# 📰 PR Newswire Releases — Corporate Announcement Stream (`nexgendata/pr-newswire-press-releases-scraper`) Actor

Scrape PR Newswire press releases — title, URL, summary, image, publication date (JSON-LD), modification date, full body text, extracted tickers (NASDAQ/NYSE/AMEX). Keyword + category + country filters. PR firms, M\&A bankers, financial journalists, IR, equity research.

- **URL**: https://apify.com/nexgendata/pr-newswire-press-releases-scraper.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Business, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 press releases

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

## 📰 PR Newswire Press Releases Scraper — Corporate press release stream — headline, body, issuer, ticker, geography

The PR Newswire Press Releases Scraper pulls structured press releases from [PRNewswire.com](https://www.prnewswire.com), one of the largest corporate-distribution wires (announcements from public companies, late-stage startups, government agencies, and non-profits). You get headline, body, issuer, posted date, ticker tags (when publicly traded), geography, and category — perfect for event-driven trading research, competitive-intel monitoring, M&A pipeline tracking, and sales-prospecting on newly-funded companies.

### Why PR Newswire Press Releases Scraper Beats PR Newswire, PRWeb, and Business Wire

| Source | Price | What you get |
|--------|-------|--------------|
| PR Newswire (official) | Distribution from $350+/release | Issuer-side service; reader API requires enterprise contract |
| PRWeb | $99-389/release | Distribution service, not bulk read |
| Business Wire | $Custom | Distribution service, no reader API |
| GlobeNewswire | $Custom | Distribution service, no reader API |
| NexGenData PR Newswire Scraper | PPE per release | Bulk read access — headline, body, issuer, date, ticker tags, geography — JSON |

### What You Get

- Release ID + canonical PRNewswire URL
- Headline + sub-headline
- Full body text (HTML and plain-text)
- Issuing company name
- Stock ticker tags (when issuer is publicly traded)
- Posted datetime (UTC)
- Geography tag (issuer HQ country/state when published)
- Category / topic tags (Acquisitions / Partnerships / Funding / Earnings / Product / etc.)
- Industry tag (Financial Services / Healthcare / Technology / etc.)
- Contact info section (when published)
- Photo / asset URLs included in the release
- Distribution language

### Use Cases

- **Event-driven trading research** — for each release, dedupe on headline keywords (Acquisition, Merger, Bankruptcy, FDA Approval) and route to your event-trader.
- **M&A pipeline** — track every 'acquires' and 'definitive agreement' release across PR Newswire daily, dedupe against your deal-flow CRM.
- **Competitive monitoring** — set up keyword alerts on competitor brand names and surface their announcements within minutes.
- **Sales-prospecting on funding news** — when a company announces Series A/B/C funding, that's a buying-signal for sales-stack products.
- **Crisis-comms / brand monitoring** — track brand mentions across press releases for legal and PR teams.
- **Investor relations** — track peer-company earnings-release timing and language to inform your own IR cadence.
- **Government / regulatory research** — track agency announcements and policy-related releases.

### Quick Start

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "categories": ["acquisitions-mergers-and-takeovers", "venture-capital"],
    "sinceHours": 24,
    "maxItems": 500
}

run = client.actor("nexgendata/pr-newswire-press-releases-scraper").call(run_input=run_input)

## Iterate results
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

## Or fetch all in one go
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
print(f"Got {len(items)} rows")
````

You can also run from the **Apify CLI**:

```bash
apify call nexgendata/pr-newswire-press-releases-scraper --input='{
    "categories": ["acquisitions-mergers-and-takeovers", "venture-capital"],
    "sinceHours": 24,
    "maxItems": 500
}'
```

Or from the **web console**: open the actor page on Apify, click **Try for free**, paste the input JSON, hit **Run**. Results stream into the dataset which you can export as JSON / JSONL / CSV / Excel / HTML.

#### Scheduling

This actor pairs cleanly with **Apify Scheduler** (built into the platform) — schedule it hourly / daily / cron-style and dedupe results into your warehouse on the stable primary-key fields documented above. Webhook outputs are supported, so you can fire a Slack / Zapier / Make / n8n / your-own-API call the moment new rows materialize.

#### Integration patterns

- **CRM enrichment**: pipe rows directly into HubSpot / Salesforce / Pipedrive via Zapier or Make
- **Warehouse**: append to BigQuery / Snowflake / Postgres on a daily schedule via Apify → S3 → warehouse ingest
- **LLM-ready RAG**: each row is already JSON-flat; embed the plain-text body field and store in pgvector / Pinecone / Weaviate
- **Slack alerts**: filter by your trigger keyword and fire a Slack webhook for matches in real-time

### Pricing

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

- **$0.04 per press release** — the primary event (one charge per row pushed to the dataset)
- **0.00005 USD per actor-start GB-event** — actor start cost (one-time per run, sub-cent at typical memory)

No subscriptions, no minimums, no per-CPU-second charges. Apify's $5/month free tier covers most experiments. Browse 200+ buyer-intent actors at https://apify.com/nexgendata?fpr=2ayu9b

#### Cost worked example

A daily scheduled run pulling 500 fresh rows costs roughly:

- 500 rows × primary-event price (~$0.04-0.05) = $20-25
- 1 actor start × ~$0.00005 = negligible

So **~$20-25 per 500-row daily run**, or **~$0.04-0.05 per row** all-in. There are no surprise compute, storage, or proxy add-ons — proxy rotation is bundled into the per-row price.

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

- **Predictable**: you know your cost from row count before the run starts
- **Failure-safe**: if a target site changes its HTML and the actor returns 0 rows, you pay 0 (vs paying for the CPU-seconds anyway under time-based pricing)
- **Easy to attribute**: 1 row = 1 unit cost, so per-customer / per-pipeline cost accounting is trivial

### Sister Actors in the NexGenData Fleet

| Use case | Actor |
|----------|-------|
| Crunchbase news & funding announcements | [crunchbase-news-scraper](https://apify.com/nexgendata/crunchbase-news-scraper) |
| SEC 8-K material event filings | [sec-form-8k-material-events-scraper](https://apify.com/nexgendata/sec-form-8k-material-events-scraper) |
| Y Combinator alumni database | [yc-companies-directory-scraper](https://apify.com/nexgendata/yc-companies-directory-scraper) |
| Daily Product Hunt launch stream | [product-hunt-launches-scraper](https://apify.com/nexgendata/product-hunt-launches-scraper) |
| Show HN indie launch stream | [hn-show-hn-tracker](https://apify.com/nexgendata/hn-show-hn-tracker) |
| Delaware DOC entity registry lookup | [delaware-corporations-search-scraper](https://apify.com/nexgendata/delaware-corporations-search-scraper) |
| Federal Register agency rule scraper | [federal-register-rules-scraper](https://apify.com/nexgendata/federal-register-rules-scraper) |

(All sister actors share the same PPE billing and Apify-standard JSON output, so you can compose multi-step pipelines without rewriting input/output adapters.)

### FAQ

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

A: PR Newswire publishes releases continuously through the day. Each actor run pulls live; we recommend a 15-30 minute schedule for trading-style use cases.

**Q: Can I filter by industry or geography?**

A: Yes — pass topic/industry/geography filter strings supported by PR Newswire's index pages. The actor handles pagination automatically.

**Q: Is the body the full release text?**

A: Yes — the actor pulls the full HTML body and a clean plain-text version for NLP / LLM consumption.

**Q: Will I be rate-limited?**

A: The actor uses Apify residential proxies and polite pacing. We have not observed blocks at typical volumes (≤5K releases/run).

**Q: Is scraping PR Newswire legal?**

A: The actor reads public unauthenticated press-release pages, the same way a browser does. You are responsible for compliance with PR Newswire's terms and your local laws.

**Q: Output format?**

A: JSON, JSONL, CSV, Excel via Apify dataset export. Schema is stable.

### Schema Stability & Versioning

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

- New fields may be **added** at any time — they will simply appear as new keys in the JSON output, defaulting to `null` for older runs.
- Existing fields are **never renamed or removed** without a major-version bump and an advance changelog notice.
- Field semantics (units, timezones, value-sets) are **never silently changed** — if we need to change semantics, we add a new field with the new name and deprecate (but keep) the old one for at least 90 days.

This means you can build production pipelines on this actor and not worry about a Tuesday breaking a Friday's ETL job. If you spot an unexpected change, reach out via the actor's Apify Issues tab and we'll look at it the same day.

### Compliance & Legal

- The actor reads **public, unauthenticated pages** the same way a logged-out browser does.
- All requests route through Apify's compliant residential-proxy infrastructure with polite rate limiting.
- You are responsible for ensuring your downstream use complies with the target site's Terms of Service, your jurisdiction's data-protection laws (GDPR, CCPA, UK DPA, etc.), and any sector-specific rules (HIPAA, PCI, etc.).
- We do not collect, store, or transmit credentials for the target site.
- Most read-only competitive-intelligence and lead-generation use is widely accepted. Consult counsel before bulk redistribution.

### Support

Open an issue on the actor's Apify Issues tab — the NexGenData team responds within one business day. For feature requests (new fields, new input filters), include the use case so we can prioritize on it.

### About NexGenData

NexGenData publishes 200+ buyer-intent actors covering SEC filings, YC alumni, Delaware DOC, lead generation, competitive intelligence, stock fundamentals across 30+ exchanges, ATS job boards, real-estate marketplaces, and more. All actors are pay-per-result and share a stable, additive-only JSON schema. Browse the full catalog at https://apify.com/nexgendata?fpr=2ayu9b

***

SEO: 📰 PR Newswire Scraper — Corporate Press Release Stream API

# Actor input Schema

## `keyword` (type: `string`):

Search keyword. Empty = no keyword filter (returns latest releases). Example: 'earnings', 'IPO', 'Microsoft', 'partnership'.

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

PR Newswire category slug. Example: 'earnings', 'mergers-acquisitions', 'product-launches', 'health'. Empty = ALL categories.

## `country` (type: `string`):

Country code for the regional release feed. Default 'US'. Other examples: 'CA', 'UK', 'DE', 'JP'.

## `dateFrom` (type: `string`):

Earliest publication date (UTC, inclusive). Requires includeFullBody=true to be effective (date filter uses detail-page JSON-LD).

## `dateTo` (type: `string`):

Latest publication date (UTC, inclusive). Requires includeFullBody=true to be effective.

## `includeFullBody` (type: `boolean`):

If true, follow each release URL to fetch the full body text + JSON-LD metadata (datePublished, dateModified, description, tickers extracted via regex). Adds ~0.4s per release. If false, you only get title + summary + image from the list page.

## `maxReleases` (type: `integer`):

Max releases to return (1–2000). Each release is one dataset row. ~25 releases per list page; pagination is automatic.

## Actor input object example

```json
{
  "country": "US",
  "includeFullBody": false,
  "maxReleases": 5
}
```

# 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 = {
    "keyword": "",
    "category": "",
    "country": "US",
    "dateFrom": "",
    "dateTo": "",
    "includeFullBody": false,
    "maxReleases": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/pr-newswire-press-releases-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 = {
    "keyword": "",
    "category": "",
    "country": "US",
    "dateFrom": "",
    "dateTo": "",
    "includeFullBody": False,
    "maxReleases": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/pr-newswire-press-releases-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 '{
  "keyword": "",
  "category": "",
  "country": "US",
  "dateFrom": "",
  "dateTo": "",
  "includeFullBody": false,
  "maxReleases": 5
}' |
apify call nexgendata/pr-newswire-press-releases-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📰 PR Newswire Releases — Corporate Announcement Stream",
        "description": "Scrape PR Newswire press releases — title, URL, summary, image, publication date (JSON-LD), modification date, full body text, extracted tickers (NASDAQ/NYSE/AMEX). Keyword + category + country filters. PR firms, M&A bankers, financial journalists, IR, equity research.",
        "version": "0.0",
        "x-build-id": "b8wteiXlPxMp3uCoU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~pr-newswire-press-releases-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-pr-newswire-press-releases-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/nexgendata~pr-newswire-press-releases-scraper/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-pr-newswire-press-releases-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/nexgendata~pr-newswire-press-releases-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-pr-newswire-press-releases-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keyword": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Search keyword. Empty = no keyword filter (returns latest releases). Example: 'earnings', 'IPO', 'Microsoft', 'partnership'."
                    },
                    "category": {
                        "title": "Category (optional)",
                        "type": "string",
                        "description": "PR Newswire category slug. Example: 'earnings', 'mergers-acquisitions', 'product-launches', 'health'. Empty = ALL categories."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country code for the regional release feed. Default 'US'. Other examples: 'CA', 'UK', 'DE', 'JP'.",
                        "default": "US"
                    },
                    "dateFrom": {
                        "title": "Date from (YYYY-MM-DD, optional)",
                        "type": "string",
                        "description": "Earliest publication date (UTC, inclusive). Requires includeFullBody=true to be effective (date filter uses detail-page JSON-LD)."
                    },
                    "dateTo": {
                        "title": "Date to (YYYY-MM-DD, optional)",
                        "type": "string",
                        "description": "Latest publication date (UTC, inclusive). Requires includeFullBody=true to be effective."
                    },
                    "includeFullBody": {
                        "title": "Include full release body",
                        "type": "boolean",
                        "description": "If true, follow each release URL to fetch the full body text + JSON-LD metadata (datePublished, dateModified, description, tickers extracted via regex). Adds ~0.4s per release. If false, you only get title + summary + image from the list page.",
                        "default": false
                    },
                    "maxReleases": {
                        "title": "Max releases",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Max releases to return (1–2000). Each release is one dataset row. ~25 releases per list page; pagination is automatic.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
