# NIH RePORTER Grants Scraper (`automation-lab/nih-reporter-grants-scraper`) Actor

Search NIH RePORTER grants and export projects, PIs, organizations, institutes, abstracts, awards, dates, and public URLs from the official API.

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

Extract public NIH grant and project records from NIH RePORTER using the official public API.

Use this actor to monitor funded biomedical research, map grant landscapes, find principal investigators, follow universities or biotech competitors, and export structured funding intelligence into CSV, JSON, Excel, databases, or dashboards.

### What does NIH RePORTER Grants Scraper do?

NIH RePORTER Grants Scraper searches the public NIH RePORTER Projects API and saves one dataset row per grant or project record.

It returns normalized records with project numbers, titles, abstracts, fiscal years, organizations, principal investigators, NIH institutes and centers, award amounts, dates, terms, and public RePORTER URLs.

The actor uses the official JSON API rather than a browser. That makes it faster, cheaper, and more reliable than scraping rendered pages.

### Who is it for?

- 🎓 University research offices tracking awards by institution, PI, fiscal year, or topic.
- 🧬 Biotech and pharma business-development teams mapping funded science and potential collaborators.
- 📊 Grant intelligence platforms building recurring NIH funding datasets.
- 🏥 Hospitals and research institutes monitoring competitor funding.
- 🧑‍🔬 Researchers looking for similar projects, active awards, or funding trends.
- 🧾 Consultants preparing market maps, diligence reports, and landscape summaries.

### Why use this actor?

- ✅ Uses the official NIH RePORTER API.
- ✅ No login, cookies, or private credentials required.
- ✅ Supports topic, fiscal year, agency/IC, organization, PI, activity code, award type, and project number filters.
- ✅ Produces clean, typed, export-ready rows.
- ✅ Includes direct RePORTER project links for review and citation.
- ✅ Handles pagination and retryable NIH API errors politely.

### Data returned

| Field group | Examples |
| --- | --- |
| Project IDs | `applId`, `projectNumber`, `coreProjectNumber`, `projectSerialNumber` |
| Grant content | `projectTitle`, `abstractText`, `publicHealthRelevance`, `terms`, `preferredTerms` |
| Fiscal/funding | `fiscalYear`, `awardAmount`, `directCostAmount`, `indirectCostAmount`, `totalCostByIc` |
| Organization | `organizationName`, city, state, country, organization type |
| People | `principalInvestigators`, `contactPiName` |
| NIH context | `agencyCode`, `administeringIcCode`, `administeringIcName`, `fundingIcs` |
| Dates | project start/end, budget start/end, award notice date |
| Links | `reporterUrl`, `sourceSearchUrl` |

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

This actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved grant/project row.
- You control cost with `maxItems`.

The official API does not require a proxy, so runs are designed to stay inexpensive and predictable.

### Quick start

1. Open the actor on Apify.
2. Enter a topic such as `cancer immunotherapy`.
3. Optionally add fiscal years, agencies, organization names, PI names, or project numbers.
4. Set `maxItems`.
5. Run the actor.
6. Export results from the dataset as CSV, JSON, Excel, XML, or RSS.

### Input options

#### Text query

Searches project title, abstract, and NIH terms.

Example:

```json
{
  "query": "Alzheimer biomarker"
}
````

#### Fiscal years

Restrict results to NIH fiscal years.

```json
{
  "fiscalYears": [2024, 2025]
}
```

#### Agencies / ICs

Use NIH agency or Institute/Center abbreviations such as `NCI`, `NIAID`, `NHLBI`, `NIA`, or `NINDS`.

```json
{
  "agencies": ["NCI"]
}
```

#### Organizations and PIs

Track awards by institution or investigator.

```json
{
  "organizationTerms": ["Harvard"],
  "principalInvestigatorTerms": ["Smith"]
}
```

#### Award and activity codes

Filter by NIH award type or activity code.

```json
{
  "awardTypes": ["1"],
  "activityCodes": ["R01", "R21"]
}
```

#### Project numbers

Retrieve known project numbers.

```json
{
  "projectNumbers": ["R01CA123456"]
}
```

### Example input

```json
{
  "query": "cancer immunotherapy",
  "fiscalYears": [2024, 2025],
  "agencies": ["NCI"],
  "maxItems": 100,
  "pageSize": 100
}
```

### Example output

```json
{
  "projectNumber": "5P30CA015704-51",
  "fiscalYear": 2026,
  "projectTitle": "Lung Cancer",
  "organizationName": "FRED HUTCHINSON CANCER CENTER",
  "principalInvestigators": ["A McGarry Houghton"],
  "administeringIcCode": "CA",
  "awardAmount": 401412,
  "reporterUrl": "https://reporter.nih.gov/project-details/11303351"
}
```

### Use cases

#### Grant intelligence

Build recurring exports of NIH funded projects by disease area, modality, institution, PI, or fiscal year.

#### Competitive intelligence

Track which universities, hospitals, startups, or pharma partners receive funding in a scientific area.

#### Business development

Find active principal investigators and funded labs that may be relevant for partnerships, licensing, or clinical collaborations.

#### Academic reporting

Export award histories for a department, center, or institution without manual RePORTER searches.

### Tips for better results

- Use specific scientific terms for high precision.
- Use fiscal years when you only need recent awards.
- Use agency filters for institute-specific landscapes.
- Start with `maxItems: 100`, inspect output, then increase for larger exports.
- Combine organization and topic filters for targeted monitoring.

### Integrations

You can connect the dataset to:

- Google Sheets or Excel exports for analysts.
- BI dashboards such as Looker Studio, Power BI, or Tableau.
- CRM or deal-flow databases for BD teams.
- Data warehouses for repeat grant-intelligence pipelines.
- LLM workflows for summarizing abstracts and identifying trends.

### API usage

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/nih-reporter-grants-scraper').call(run_input={
    'query': 'Alzheimer biomarker',
    'fiscalYears': [2024, 2025],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

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

### MCP usage

Use the Apify MCP server with this actor enabled:

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

Claude Code setup:

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

Claude Desktop JSON config:

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

Example prompts:

- "Run the NIH RePORTER grants scraper for CRISPR delivery grants from 2024 and summarize top institutions."
- "Find NCI-funded cancer immunotherapy projects and group them by principal investigator."
- "Export NIH Alzheimer's biomarker awards and identify collaboration targets."

### Output quality notes

NIH records can vary by year, institute, and award type. Some fields may be null when NIH does not provide them for a record.

The actor preserves both normalized fields and source URLs so you can inspect the original public RePORTER page.

### Limitations

- This actor returns public NIH RePORTER project data only.
- It does not access private grant applications or restricted NIH systems.
- It depends on the public NIH API availability and accepted query fields.
- Very broad searches should use a sensible `maxItems` cap.

### Legality

The actor uses NIH's public RePORTER API and collects public grant/project metadata. You are responsible for using exported data in compliance with applicable laws, Apify terms, and your organization's policies.

### FAQ

#### Does it require a NIH API key?

No. The checked Projects API endpoint is public and did not require authentication.

#### Can I search by project number?

Yes. Use the `projectNumbers` input for known full or core project numbers.

#### Why are some award fields null?

NIH does not provide every cost or award field for every record. Null values mean the source response did not include a usable value.

#### Why did I get fewer rows than `maxItems`?

The API may have fewer matching records than your requested cap, or your filters may be too narrow.

#### How do I monitor one university?

Set `organizationTerms` to the university name and optionally add fiscal years or research topic terms.

### Related scrapers

Explore other automation-lab actors for public research, government, and funding intelligence workflows:

- https://apify.com/automation-lab/pubmed-search-scraper
- https://apify.com/automation-lab/clinicaltrials-gov-studies-scraper
- https://apify.com/automation-lab/samgov-government-contracts-scraper
- https://apify.com/automation-lab/world-bank-projects-scraper

### Support

If the NIH API changes or you need an additional filter/output field, open an issue on the actor page with your input and expected result.

### Version

Initial version: official NIH RePORTER Projects API search with normalized grant intelligence output.

# Actor input Schema

## `query` (type: `string`):

Words or phrases to search across project titles, abstracts, and NIH terms.

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

NIH fiscal years to include. Leave empty to search all years.

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

Funding or administering agency/IC abbreviations such as NIH, NCI, NIAID, NHLBI, NIGMS.

## `organizationTerms` (type: `array`):

University, company, hospital, or research organization names to match.

## `principalInvestigatorTerms` (type: `array`):

PI names to match, for example Smith or Jane Smith.

## `awardTypes` (type: `array`):

NIH award type codes such as 1 (new), 2 (renewal), 5 (non-competing continuation).

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

NIH activity codes such as R01, R21, P30, U01, K99.

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

Full or core NIH project numbers to retrieve, such as R01CA123456.

## `onlyActive` (type: `boolean`):

Set true for active projects only, false for inactive only, or leave unset for both.

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

Maximum number of grant/project records to save.

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

NIH API page size. Keep 100 for polite default pagination; maximum 500.

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

Optional NIH API sort field, for example fiscal\_year or award\_amount. Leave blank for relevance/default order.

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

Sort direction when a sort field is provided.

## Actor input object example

```json
{
  "query": "cancer immunotherapy",
  "fiscalYears": [
    2024,
    2025
  ],
  "agencies": [
    "NCI"
  ],
  "organizationTerms": [],
  "principalInvestigatorTerms": [],
  "awardTypes": [],
  "activityCodes": [],
  "projectNumbers": [],
  "maxItems": 20,
  "pageSize": 100
}
```

# 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 = {
    "query": "cancer immunotherapy",
    "fiscalYears": [
        2024,
        2025
    ],
    "agencies": [
        "NCI"
    ],
    "organizationTerms": [],
    "principalInvestigatorTerms": [],
    "awardTypes": [],
    "activityCodes": [],
    "projectNumbers": [],
    "maxItems": 20,
    "pageSize": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/nih-reporter-grants-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 = {
    "query": "cancer immunotherapy",
    "fiscalYears": [
        2024,
        2025,
    ],
    "agencies": ["NCI"],
    "organizationTerms": [],
    "principalInvestigatorTerms": [],
    "awardTypes": [],
    "activityCodes": [],
    "projectNumbers": [],
    "maxItems": 20,
    "pageSize": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/nih-reporter-grants-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 '{
  "query": "cancer immunotherapy",
  "fiscalYears": [
    2024,
    2025
  ],
  "agencies": [
    "NCI"
  ],
  "organizationTerms": [],
  "principalInvestigatorTerms": [],
  "awardTypes": [],
  "activityCodes": [],
  "projectNumbers": [],
  "maxItems": 20,
  "pageSize": 100
}' |
apify call automation-lab/nih-reporter-grants-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Grants Scraper",
        "description": "Search NIH RePORTER grants and export projects, PIs, organizations, institutes, abstracts, awards, dates, and public URLs from the official API.",
        "version": "0.1",
        "x-build-id": "yZjiKbqQie9edRy9w"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~nih-reporter-grants-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-nih-reporter-grants-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-grants-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-nih-reporter-grants-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-grants-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-nih-reporter-grants-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": {
                    "query": {
                        "title": "Text query",
                        "type": "string",
                        "description": "Words or phrases to search across project titles, abstracts, and NIH terms."
                    },
                    "fiscalYears": {
                        "title": "Fiscal years",
                        "type": "array",
                        "description": "NIH fiscal years to include. Leave empty to search all years.",
                        "items": {
                            "type": "integer"
                        }
                    },
                    "agencies": {
                        "title": "Agency / IC codes",
                        "type": "array",
                        "description": "Funding or administering agency/IC abbreviations such as NIH, NCI, NIAID, NHLBI, NIGMS.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "organizationTerms": {
                        "title": "Organization names",
                        "type": "array",
                        "description": "University, company, hospital, or research organization names to match.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "principalInvestigatorTerms": {
                        "title": "Principal investigator names",
                        "type": "array",
                        "description": "PI names to match, for example Smith or Jane Smith.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "awardTypes": {
                        "title": "Award types",
                        "type": "array",
                        "description": "NIH award type codes such as 1 (new), 2 (renewal), 5 (non-competing continuation).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityCodes": {
                        "title": "Activity codes",
                        "type": "array",
                        "description": "NIH activity codes such as R01, R21, P30, U01, K99.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "projectNumbers": {
                        "title": "Project numbers",
                        "type": "array",
                        "description": "Full or core NIH project numbers to retrieve, such as R01CA123456.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyActive": {
                        "title": "Active projects only",
                        "type": "boolean",
                        "description": "Set true for active projects only, false for inactive only, or leave unset for both."
                    },
                    "maxItems": {
                        "title": "Maximum projects",
                        "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": "NIH API page size. Keep 100 for polite default pagination; maximum 500.",
                        "default": 100
                    },
                    "sortField": {
                        "title": "Sort field",
                        "type": "string",
                        "description": "Optional NIH API sort field, for example fiscal_year or award_amount. Leave blank for relevance/default order."
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Sort direction when a sort field is provided."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```