# NIH RePORTER Grant Search Scraper (`automation-lab/nih-reporter-grant-search-scraper`) Actor

Search NIH RePORTER grants and export awards, PIs, organizations, institutes, abstracts, dates, and raw records from the official API.

- **URL**: https://apify.com/automation-lab/nih-reporter-grant-search-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## NIH RePORTER Grant Search Scraper

Export grant and project records from the official NIH RePORTER API.

The actor turns NIH RePORTER searches into clean dataset rows with project numbers, titles, award amounts, recipient organizations, principal investigators, institutes, project dates, abstracts, and optional raw API records.

### What does NIH RePORTER Grant Search Scraper do?

NIH RePORTER Grant Search Scraper searches `api.reporter.nih.gov` and saves matching grant projects to an Apify dataset.

It is built for repeatable research workflows where you need more than a one-off website search.

- 🔎 Search by terms such as disease area, therapy, method, or technology
- 📅 Filter by fiscal year
- 🏛️ Filter by NIH institute / center codes
- 🧑‍🔬 Filter by principal investigator
- 🏫 Filter by recipient organization
- 📄 Export abstracts and funding metadata
- ⚙️ Use raw NIH criteria JSON for advanced searches

### Who is it for?

This scraper is useful for teams that monitor public biomedical funding.

- University research offices tracking awards in a department
- Biotech business-development teams looking for collaboration leads
- Grant consultants building opportunity maps
- Competitive-intelligence analysts monitoring funded science
- Nonprofits following disease-area funding
- Data teams enriching grant dashboards

### Why use this actor?

NIH RePORTER is public, but manual searches are hard to repeat at scale.

This actor provides:

- Structured dataset exports
- Pagination handling
- Flattened fields for spreadsheets and BI tools
- Optional raw records for data engineering
- Apify API, scheduling, webhooks, and integrations
- Pay-per-event billing tied to returned rows

### Data you can extract

| Field | Description |
| --- | --- |
| `projectNumber` | NIH project identifier |
| `projectTitle` | Project title |
| `fiscalYear` | Fiscal year |
| `awardAmount` | Award amount when available |
| `organizationName` | Recipient organization |
| `organizationCity` | Recipient city |
| `organizationState` | Recipient state |
| `organizationCountry` | Recipient country |
| `organizationUei` | Recipient UEI |
| `contactPiName` | Contact PI or first PI |
| `principalInvestigators` | All PI names returned by NIH |
| `agencyCode` | NIH institute / center code |
| `agencyName` | NIH institute / center name |
| `activityCode` | Grant activity code when available |
| `applicationType` | Application type when available |
| `projectStartDate` | Project start date |
| `projectEndDate` | Project end date |
| `abstractText` | Abstract text |
| `reporterUrl` | Link back to NIH RePORTER |
| `rawResult` | Optional raw NIH API object |

### How much does it cost to scrape NIH RePORTER grants?

The actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved grant row.
- You control spend with `maxResults`.
- The default input saves a modest sample so first runs stay cheap.

### How to use

1. Open the actor on Apify.
2. Enter search terms such as `cancer immunotherapy`.
3. Choose one or more fiscal years.
4. Optionally add NIH institute codes, organizations, PIs, or activity codes.
5. Set `maxResults`.
6. Run the actor.
7. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

#### Search terms

Use `terms` for the main NIH RePORTER keyword search.

Examples:

- `cancer immunotherapy`
- `Alzheimer biomarkers`
- `CRISPR delivery`
- `opioid prevention`

#### Fiscal years

Use `fiscalYears` to limit records to one or more NIH fiscal years.

Example:

```json
[2024, 2023]
````

#### NIH agency / IC codes

Use `agencyIcCodes` for institute or center filters.

Examples:

- `NCI`
- `NIAID`
- `NHLBI`
- `DK`

#### Organization names

Use `organizationNames` to focus on recipient institutions.

Examples:

- `JOHNS HOPKINS UNIVERSITY`
- `DANA-FARBER CANCER INST`
- `UNIVERSITY OF CALIFORNIA`

#### PI names

Use `piNames` to find awards tied to specific investigators.

#### Project numbers

Use `projectNumbers` for exact lookup workflows.

#### Activity codes

Use `activityCodes` to focus on mechanisms such as `R01`, `U01`, `F32`, or `P30`.

#### Raw criteria

Use `rawCriteria` when you know NIH RePORTER v2 criteria keys that are not exposed as first-class inputs.

Structured fields are merged with raw criteria and override matching keys.

### Example input

```json
{
  "terms": "cancer immunotherapy",
  "fiscalYears": [2024],
  "agencyIcCodes": ["NCI"],
  "maxResults": 100,
  "pageSize": 100,
  "includeRawResult": false
}
```

### Example output

```json
{
  "projectNumber": "5F32DK132864-03",
  "projectTitle": "Elucidating novel molecular mechanisms of irisin-mediated effects via integrin",
  "fiscalYear": 2024,
  "awardAmount": 56728,
  "organizationName": "DANA-FARBER CANCER INST",
  "organizationCity": "BOSTON",
  "organizationState": "MA",
  "organizationCountry": "UNITED STATES",
  "contactPiName": "Mu A",
  "principalInvestigators": ["Mu A"],
  "agencyCode": "DK",
  "agencyName": "National Institute of Diabetes and Digestive and Kidney Diseases",
  "projectStartDate": "2022-05-01",
  "projectEndDate": "2024-12-31",
  "reporterUrl": "https://reporter.nih.gov/project-details/5F32DK132864-03"
}
```

### Tips for better searches

- Start broad, then add filters.
- Use fiscal years to reduce result volume.
- Use activity codes when you only need a grant mechanism.
- Use organization filters for account-based prospecting.
- Enable raw records only when you need full NIH API detail.

### Integrations

The dataset can feed many workflows:

- 📊 Export to Google Sheets or Excel for grant landscape review
- 🧩 Send rows to Airtable or Notion through Apify integrations
- 🔔 Schedule weekly monitoring and send webhooks to Slack
- 🧠 Feed grant abstracts into LLM classification pipelines
- 🧪 Enrich CRM accounts with NIH funding signals

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/nih-reporter-grant-search-scraper').call({
  terms: 'cancer immunotherapy',
  fiscalYears: [2024],
  maxResults: 100
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nih-reporter-grant-search-scraper').call(run_input={
    'terms': 'cancer immunotherapy',
    'fiscalYears': [2024],
    'maxResults': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~nih-reporter-grant-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"terms":"cancer immunotherapy","fiscalYears":[2024],"maxResults":100}'
```

### MCP usage

Use this actor from Apify MCP in Claude Code, Claude Desktop, or other MCP clients.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/nih-reporter-grant-search-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/nih-reporter-grant-search-scraper"
    }
  }
}
```

Example prompts:

- "Find 100 NIH RePORTER cancer immunotherapy grants from 2024 and summarize top recipient organizations."
- "Export NIH grants for Alzheimer biomarkers and group them by institute."
- "Look up R01 grants mentioning CRISPR delivery and list contact PIs."

### Scheduling and monitoring

You can schedule the actor to run weekly or monthly.

Typical monitoring ideas:

- New awards in a disease area
- New grants to target organizations
- New awards for a PI list
- Changes in funding by institute

### Legality and data source

This actor uses the official public NIH RePORTER API.

Users are responsible for complying with Apify terms, NIH API expectations, and applicable laws. The actor does not bypass logins, paywalls, or private systems.

### FAQ

#### Does this scraper use the official NIH RePORTER API?

Yes. It sends HTTPS requests to the public NIH RePORTER v2 projects search API.

#### Can I export raw NIH records?

Yes. Enable `includeRawResult` to attach the raw API object to each dataset row.

### Troubleshooting

#### Why did I get fewer rows than expected?

Your filters may be narrow, or the NIH API may have fewer matching records than `maxResults`. Try broader terms or remove organization/PI filters.

#### Why is `activityCode` empty?

Some NIH API result shapes do not include every requested field for every record. Use `includeRawResult` to inspect the original NIH object.

### Related scrapers

Explore other automation-lab actors for research and lead workflows:

- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/company-website-scraper
- https://apify.com/automation-lab/google-news-scraper

### Changelog

Initial version supports NIH RePORTER project search through the official API, flattened grant rows, structured filters, pagination, and optional raw records.

# Actor input Schema

## `terms` (type: `string`):

Keyword or phrase to search across NIH RePORTER project records.

## `fiscalYears` (type: `array`):

NIH fiscal years to include.

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

Maximum number of grant/project records to save.

## `pageSize` (type: `integer`):

Records requested per NIH API page. Keep default unless you need smaller pages for debugging.

## `agencyIcCodes` (type: `array`):

Institute or center codes, such as NCI, NIAID, NHLBI, or DK. These are passed to NIH RePORTER criteria.agencies.

## `organizationNames` (type: `array`):

Filter to matching recipient organizations or universities.

## `piNames` (type: `array`):

Filter by PI names.

## `projectNumbers` (type: `array`):

Specific NIH project numbers to look up.

## `activityCodes` (type: `array`):

Grant activity codes such as R01, U01, F32, or P30.

## `rawCriteria` (type: `object`):

Advanced JSON criteria merged with the structured fields above. Structured fields override matching keys.

## `includeRawResult` (type: `boolean`):

Attach the raw NIH API result to every output item for advanced analysis.

## Actor input object example

```json
{
  "terms": "cancer immunotherapy",
  "fiscalYears": [
    2024
  ],
  "maxResults": 20,
  "pageSize": 100,
  "includeRawResult": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "terms": "cancer immunotherapy",
    "fiscalYears": [
        2024
    ],
    "maxResults": 20,
    "pageSize": 100,
    "includeRawResult": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nih-reporter-grant-search-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 = {
    "terms": "cancer immunotherapy",
    "fiscalYears": [2024],
    "maxResults": 20,
    "pageSize": 100,
    "includeRawResult": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nih-reporter-grant-search-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 '{
  "terms": "cancer immunotherapy",
  "fiscalYears": [
    2024
  ],
  "maxResults": 20,
  "pageSize": 100,
  "includeRawResult": false
}' |
apify call automation-lab/nih-reporter-grant-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/nih-reporter-grant-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Grant Search Scraper",
        "description": "Search NIH RePORTER grants and export awards, PIs, organizations, institutes, abstracts, dates, and raw records from the official API.",
        "version": "0.1",
        "x-build-id": "NPmcWTAuK9modVxWP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nih-reporter-grant-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nih-reporter-grant-search-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/automation-lab~nih-reporter-grant-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nih-reporter-grant-search-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/automation-lab~nih-reporter-grant-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nih-reporter-grant-search-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": {
                    "terms": {
                        "title": "Search terms",
                        "type": "string",
                        "description": "Keyword or phrase to search across NIH RePORTER project records."
                    },
                    "fiscalYears": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "NIH fiscal years to include.",
                        "items": {
                            "type": "integer",
                            "minimum": 1985,
                            "maximum": 2030
                        }
                    },
                    "maxResults": {
                        "title": "Maximum grants",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of grant/project records to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Records requested per NIH API page. Keep default unless you need smaller pages for debugging.",
                        "default": 100
                    },
                    "agencyIcCodes": {
                        "title": "NIH agency / IC codes",
                        "type": "array",
                        "description": "Institute or center codes, such as NCI, NIAID, NHLBI, or DK. These are passed to NIH RePORTER criteria.agencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizationNames": {
                        "title": "Organization names",
                        "type": "array",
                        "description": "Filter to matching recipient organizations or universities.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "piNames": {
                        "title": "Principal investigator names",
                        "type": "array",
                        "description": "Filter by PI names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "projectNumbers": {
                        "title": "Project numbers",
                        "type": "array",
                        "description": "Specific NIH project numbers to look up.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityCodes": {
                        "title": "Activity codes",
                        "type": "array",
                        "description": "Grant activity codes such as R01, U01, F32, or P30.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "rawCriteria": {
                        "title": "Raw NIH RePORTER criteria override",
                        "type": "object",
                        "description": "Advanced JSON criteria merged with the structured fields above. Structured fields override matching keys."
                    },
                    "includeRawResult": {
                        "title": "Include raw NIH record",
                        "type": "boolean",
                        "description": "Attach the raw NIH API result to every output item for advanced analysis.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```