# NIH RePORTER Project Scraper (`automation-lab/nih-reporter-project-scraper`) Actor

Export NIH RePORTER funded project records by keyword, fiscal year, IC, organization, PI, activity code, and project ID from the official API.

- **URL**: https://apify.com/automation-lab/nih-reporter-project-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 Project Scraper

Export funded NIH project records from the official NIH RePORTER public API.

### What does NIH RePORTER Project Scraper do?

NIH RePORTER Project Scraper turns NIH RePORTER searches into clean datasets.

It searches funded projects by keyword, fiscal year, agency, organization, PI, activity code, project number, and APPL ID.

The actor saves grant records with award amounts, project dates, organization fields, PI names, agency/IC metadata, abstracts, and direct NIH project URLs.

### Who is it for?

- 🏛️ University research offices tracking funded awards.
- 🔬 Grant prospecting teams finding comparable projects.
- 💊 Pharma and biotech analysts monitoring NIH-funded research.
- 📊 Consultants building market maps from federal funding data.
- 🧑‍💼 Business development teams finding investigators and institutions.

### Why use this actor?

The NIH RePORTER website is useful for manual research, but repeat workflows need structured exports.

This actor uses the public API directly, so it is fast, stable, and does not need a browser.

You can schedule runs, export CSV/JSON/Excel, or connect the dataset to downstream systems.

### Data source

The actor calls:

`https://api.reporter.nih.gov/v2/projects/search`

This is the official public NIH RePORTER API.

### Input options

Use one filter or combine several filters.

- Search terms
- Fiscal years
- Organization names
- Organization states
- Organization countries
- Principal investigator names
- NIH institutes and centers
- Activity codes
- Project numbers
- APPL IDs
- Maximum projects
- API page size
- Optional topic terms

### Example searches

Search recent cancer immunotherapy awards.

Search R01 grants funded by NCI in fiscal year 2024.

Search awards to a specific university.

Search one investigator's NIH-funded project portfolio.

Search a list of known APPL IDs.

### Output data

Each dataset row is one NIH project record.

| Field | Description |
| --- | --- |
| applId | NIH application ID |
| projectNumber | Full project number |
| projectTitle | Project title |
| fiscalYear | NIH fiscal year |
| awardAmount | Award amount when available |
| activityCode | NIH activity code |
| agencyCode | NIH IC abbreviation |
| agencyName | NIH institute/center name |
| organizationName | Recipient organization |
| contactPiName | Contact principal investigator |
| reporterUrl | NIH RePORTER project URL |

### Pricing: How much does it cost to scrape NIH RePORTER projects?

The actor uses pay-per-event pricing.

There is a small start charge per run and a per-project charge for every saved dataset item.

Small searches are inexpensive because the actor uses direct API requests and no proxy.

### How to run

1. Open the actor on Apify.
2. Enter one or more search terms.
3. Add fiscal years or agencies if needed.
4. Set `maxItems` to the number of projects you want.
5. Click Start.
6. Download the dataset as CSV, JSON, Excel, or via API.

### Input example

```json
{
  "terms": ["cancer immunotherapy"],
  "fiscalYears": [2024],
  "agencies": ["NCI"],
  "activityCodes": ["R01"],
  "maxItems": 100
}
````

### Output example

```json
{
  "applId": 10757019,
  "projectNumber": "5R01CA276268-02",
  "projectTitle": "Example NIH funded project title",
  "fiscalYear": 2024,
  "awardAmount": 123456,
  "agencyCode": "NCI",
  "organizationName": "DANA-FARBER CANCER INST",
  "contactPiName": "DOE, JANE",
  "reporterUrl": "https://reporter.nih.gov/project-details/10757019"
}
```

### Tips for best results

Use focused terms for prospecting.

Use fiscal years to keep exports current.

Use activity codes like R01, R21, U01, P30, or F32 when you need award-type segmentation.

Set `includeTerms` only when you need NIH controlled terms because it can make output rows larger.

### Common use cases

- Find funded projects in a disease area.
- Build grant prospecting lists.
- Monitor competitive research programs.
- Map organizations receiving NIH awards.
- Export projects for BI dashboards.
- Create recurring award reports.

### Integrations

Send dataset rows to Google Sheets.

Load CSV exports into Excel or Airtable.

Use webhooks to trigger enrichment when a run finishes.

Connect Apify datasets to BI tools through the Apify API.

### 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-project-scraper').call({
  terms: ['cancer immunotherapy'],
  fiscalYears: [2024],
  maxItems: 100
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/nih-reporter-project-scraper').call(run_input={
    'terms': ['cancer immunotherapy'],
    'fiscalYears': [2024],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

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

### MCP integration

Use the actor from Claude Desktop or Claude Code through Apify MCP.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/nih-reporter-project-scraper`

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Find 50 NIH-funded cancer immunotherapy projects from fiscal year 2024."
- "Export NCI R01 awards and summarize top recipient organizations."
- "Create a prospecting list of investigators working on Alzheimer's disease grants."

### Scheduling

Schedule the actor weekly or monthly to monitor new NIH-funded projects.

Use fiscal year filters and consistent keywords to keep recurring exports comparable.

### Data quality notes

The actor returns data as provided by NIH RePORTER.

Some awards may omit award amount, abstract text, or organization details.

Dates are kept in the API's ISO-style format.

### Legality

NIH RePORTER data is public government research-award data.

Use exports responsibly and follow applicable laws, NIH terms, and your organization's compliance rules.

Do not use contact or investigator data for spam.

### Troubleshooting

If you receive no results, broaden the search terms or remove restrictive filters.

If a sort field fails, remove it and let NIH return the default relevance/order.

If rows are large, turn off `includeTerms`.

### Related scrapers

Explore related Automation Lab actors at:

- https://apify.com/automation-lab/

### FAQ

#### Does this actor need a proxy?

No. It uses the official public API.

#### Does it scrape the NIH website UI?

No. It calls the API used for structured RePORTER project search.

#### Can I search by APPL ID?

Yes. Use the `applIds` input.

#### Can I export abstracts?

Yes. Abstract text is included when the API returns it.

#### Can I schedule monitoring?

Yes. Use Apify schedules with the same input filters.

### Changelog

Initial version: official API project search export.

### Support

If a filter does not behave as expected, include your run input and desired NIH RePORTER query in the issue.

### Workflow examples

Grant analysts can create repeatable exports for the same scientific area and compare funding totals over time.

Research offices can monitor fiscal-year activity for their institution, partner organizations, or peer universities.

Business development teams can discover active awardees, principal investigators, and project titles in a therapeutic area.

Competitive-intelligence teams can build market maps from organization names, award amounts, activity codes, and NIH source links.

The actor keeps these workflows in one structured dataset, supports both small and large API exports, avoids browser automation and proxy costs, and returns CSV-friendly fields for BI dashboards, grant landscape reviews, investigator prospecting, and institution benchmarking.

# Actor input Schema

## `terms` (type: `array`):

Keywords or phrases to search in NIH funded projects.

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

NIH fiscal years to include.

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

Recipient organization names, for example university or institute names.

## `organizationStates` (type: `array`):

US state abbreviations for recipient organizations, e.g. MA, CA, NY.

## `organizationCountries` (type: `array`):

Recipient organization countries.

## `principalInvestigatorNames` (type: `array`):

PI names to filter by. Use full names or last names.

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

NIH project numbers or core project numbers.

## `applIds` (type: `array`):

Specific NIH application IDs (APPL\_ID values).

## `agencies` (type: `array`):

NIH IC abbreviations, such as NCI, NIAID, NIDDK, NHLBI, or NINDS.

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

NIH activity codes such as R01, R21, U01, F32, or P30.

## `includeTerms` (type: `boolean`):

Parse and include the long NIH controlled-term list. Disable for smaller CSV exports.

## `maxItems` (type: `integer`):

Maximum number of project records to save.

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

API records per request. Leave at 100 unless you need smaller requests.

## `sortField` (type: `string`):

Optional NIH API sort field, for example fiscal\_year or award\_amount.

## `sortOrder` (type: `string`):

Sort direction when a sort field is provided.

## Actor input object example

```json
{
  "terms": [
    "cancer immunotherapy"
  ],
  "fiscalYears": [
    2024
  ],
  "agencies": [
    "NCI"
  ],
  "includeTerms": false,
  "maxItems": 20,
  "pageSize": 100,
  "sortOrder": "desc"
}
```

# 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
    ],
    "agencies": [
        "NCI"
    ],
    "includeTerms": false,
    "maxItems": 20,
    "pageSize": 100,
    "sortOrder": "desc"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nih-reporter-project-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],
    "agencies": ["NCI"],
    "includeTerms": False,
    "maxItems": 20,
    "pageSize": 100,
    "sortOrder": "desc",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nih-reporter-project-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
  ],
  "agencies": [
    "NCI"
  ],
  "includeTerms": false,
  "maxItems": 20,
  "pageSize": 100,
  "sortOrder": "desc"
}' |
apify call automation-lab/nih-reporter-project-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Project Scraper",
        "description": "Export NIH RePORTER funded project records by keyword, fiscal year, IC, organization, PI, activity code, and project ID from the official API.",
        "version": "0.1",
        "x-build-id": "1K9fKEgQX8DXsQkuI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nih-reporter-project-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nih-reporter-project-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-project-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nih-reporter-project-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-project-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nih-reporter-project-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": "array",
                        "description": "Keywords or phrases to search in NIH funded projects.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fiscalYears": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "NIH fiscal years to include."
                    },
                    "organizationNames": {
                        "title": "Organization names",
                        "type": "array",
                        "description": "Recipient organization names, for example university or institute names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizationStates": {
                        "title": "Organization states",
                        "type": "array",
                        "description": "US state abbreviations for recipient organizations, e.g. MA, CA, NY.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizationCountries": {
                        "title": "Organization countries",
                        "type": "array",
                        "description": "Recipient organization countries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "principalInvestigatorNames": {
                        "title": "Principal investigator names",
                        "type": "array",
                        "description": "PI names to filter by. Use full names or last names.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "projectNumbers": {
                        "title": "Project numbers",
                        "type": "array",
                        "description": "NIH project numbers or core project numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "applIds": {
                        "title": "Application IDs",
                        "type": "array",
                        "description": "Specific NIH application IDs (APPL_ID values)."
                    },
                    "agencies": {
                        "title": "Agencies / institutes / centers",
                        "type": "array",
                        "description": "NIH IC abbreviations, such as NCI, NIAID, NIDDK, NHLBI, or NINDS.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityCodes": {
                        "title": "Activity codes",
                        "type": "array",
                        "description": "NIH activity codes such as R01, R21, U01, F32, or P30.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeTerms": {
                        "title": "Include NIH topic terms",
                        "type": "boolean",
                        "description": "Parse and include the long NIH controlled-term list. Disable for smaller CSV exports.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of project records to save.",
                        "default": 20
                    },
                    "pageSize": {
                        "title": "Page size",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "API records per request. Leave at 100 unless you need smaller requests.",
                        "default": 100
                    },
                    "sortField": {
                        "title": "Sort field",
                        "type": "string",
                        "description": "Optional NIH API sort field, for example fiscal_year or award_amount."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Sort direction when a sort field is provided.",
                        "default": "desc"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```