# NIH RePORTER Scraper (`parseforge/nih-reporter-scraper`) Actor

Scrape NIH research grant awards with 40+ fields per project. Get funding amounts, principal investigators, institutions, abstracts, spending categories, and geo coordinates. Filter by keyword, fiscal year, agency, and active status.

- **URL**: https://apify.com/parseforge/nih-reporter-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Developer tools, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔬 NIH Reporter Grants Scraper

> 🚀 **Export NIH research grant data including funding amounts, abstracts, and PI details in seconds.** Search **500,000+ federally funded projects** by keyword, fiscal year, or funding mechanism. No API key, no registration, no manual data wrangling.

> 🕒 **Last updated:** 2026-05-21 · **📊 17 fields** per record · **🔬 500,000+ grants** · **🏛️ All NIH institutes** · **📅 Fiscal years 1985-2026**

The **NIH Reporter Grants Scraper** exports publicly funded biomedical and behavioral research grants from the NIH Research Portfolio Online Reporting Tools (RePORTER) and returns **17 fields per record**, including project title, principal investigator, institution, award amount, abstract, and project dates. The underlying dataset is the authoritative federal record of NIH-funded research, maintained by the National Institutes of Health.

The catalog covers **every NIH institute and center, hundreds of funding mechanisms, and fiscal years going back to 1985**. This Actor makes that data searchable and downloadable as CSV, Excel, JSON, or XML in seconds. All filters run against the official public NIH API, so you get authoritative, real-time grant data without any scraping workarounds.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Academic researchers, science journalists, policy analysts, biotech companies, grant consultants, university administrators | Funding trend analysis, competitive landscape research, PI discovery, institution benchmarking, literature mapping |

---

### 📋 What the NIH Reporter Grants Scraper does

Four filtering workflows in a single run:

- 🔍 **Keyword search.** Search across project titles, abstracts, and full text for any biomedical topic.
- 📅 **Fiscal year filter.** Restrict to a specific NIH fiscal year from 1985 to 2026.
- 💰 **Funding mechanism filter.** Filter by mechanism code (R01, R21, T32, F31, K99, and hundreds more).
- 📊 **Scale to any volume.** From 10 preview records to 1,000,000 grants in a single run.

Each record includes project identification (title, number, URL), PI and institution details, award financials, project timeline, and the full abstract text.

> 💡 **Why it matters:** tracking NIH funding trends requires combining dozens of CSV exports or navigating the Reporter UI one page at a time. This Actor returns structured, machine-readable grant data from the official API in a single request, ready for analysis in Excel, Python, or any BI tool.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>searchQuery</td><td>string</td><td>"cancer immunotherapy"</td><td>Keywords to search across grant titles and abstracts. Any biomedical term works.</td></tr>
<tr><td>fiscalYear</td><td>integer</td><td>-</td><td>Filter to a single NIH fiscal year (e.g. 2024). Leave empty for all years.</td></tr>
<tr><td>fundingMechanism</td><td>string</td><td>-</td><td>NIH mechanism code such as R01, R21, T32, K99, F31. Leave empty for all mechanisms.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example - search for Alzheimer research in 2024:**
```json
{
    "searchQuery": "Alzheimer disease biomarkers",
    "fiscalYear": 2024,
    "maxItems": 100
}
````

**Example - R01 grants only:**

```json
{
    "searchQuery": "machine learning genomics",
    "fundingMechanism": "R01",
    "maxItems": 500
}
```

> ⚠️ **Good to Know:** Free accounts are capped at 10 items per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to get started, then upgrade for full access. The `fiscalYear` and `fundingMechanism` inputs are optional - omitting them returns grants across all years and mechanisms.

***

### 📊 Output

Each grant record contains 17 fields:

| Field | Type | Description |
|---|---|---|
| 🏷️ `title` | string | NIH project title |
| 🔢 `projectNumber` | string | NIH project number (e.g. R01AI000000-01) |
| 🔗 `url` | string | Link to the NIH Reporter project detail page |
| 👤 `principalInvestigator` | string | Name of the principal investigator |
| 🏛️ `institution` | string | Awardee institution name |
| 🏙️ `city` | string | Institution city |
| 📍 `state` | string | Institution state |
| 🌍 `country` | string | Institution country |
| 💰 `awardAmount` | integer | Total award amount in USD |
| 📅 `fiscalYear` | integer | NIH fiscal year of the award |
| 🏷️ `fundingMechanism` | string | NIH funding mechanism (e.g. R01, R21) |
| 📆 `projectStartDate` | string | Project start date (ISO 8601) |
| 📆 `projectEndDate` | string | Project end date (ISO 8601) |
| 📝 `abstract` | string | Full project abstract text |
| 🏥 `clinicalTrial` | boolean | Whether a clinical trial is required |
| 🕒 `scrapedAt` | string | Timestamp when record was scraped |
| ❌ `error` | string | Error message if scraping failed |

**Sample record:**

```json
{
    "title": "SUPPORT SERVICES FOR THE PREVENTION AND TREATMENT THROUGH A COMPREHENSIVE CARE CONTINUUM FOR HIV-AFFECTED ADOLESCENTS IN RESOURCE CONSTRAINED SETTINGS IMPLEMENTATION SCIENCE NETWORK",
    "projectNumber": "75N94023D00001-P00007-759402300004-1",
    "url": "https://reporter.nih.gov/project-details/11524614",
    "principalInvestigator": "DRIVER, BARBARA",
    "institution": "WESTAT, INC.",
    "city": "Bethesda",
    "state": "MD",
    "country": "UNITED STATES",
    "awardAmount": 726552,
    "fiscalYear": 2026,
    "fundingMechanism": "R and D Contracts",
    "projectStartDate": "2026-08-25T00:00:00",
    "projectEndDate": "2028-08-24T00:00:00",
    "abstract": "Support Services for the Prevention and Treatment through a Comprehensive Care Continuum for HIV-affected Adolescents...",
    "clinicalTrial": null,
    "scrapedAt": "2026-05-21T00:00:00.000Z",
    "error": null
}
```

***

### ✨ Why choose this Actor

- 🏛️ **Official NIH API** - data comes directly from the authoritative federal source, not scraped HTML
- ⚡ **No auth required** - completely public API, no credentials or API keys needed
- 🔍 **Full-text search** - search across titles AND abstracts simultaneously
- 📊 **Rich data** - 17 fields including full abstracts up to several thousand words
- 📅 **40+ years of history** - fiscal years 1985 through present
- 💰 **Award financials** - exact dollar amounts for every grant
- 🔄 **Real-time** - always current, pulled live from NIH Reporter on every run

***

### 📈 How it compares to alternatives

| Method | Speed | Fields | Automation | Cost |
|---|---|---|---|---|
| **This Actor** | Seconds | 17 | Full API | Free tier available |
| NIH Reporter UI | Minutes per page | Partial | Manual only | Free |
| Manual CSV export | 10-30 min | Limited | Manual | Free |
| Custom API script | Hours to build | Custom | Yes | Engineering time |
| Data brokers | Days | Varies | Yes | Expensive |

***

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the **NIH Reporter Grants Scraper** Actor page
3. Enter your search query (e.g. `"CRISPR gene editing"`)
4. Optionally set a fiscal year or funding mechanism filter
5. Set `maxItems` to the number of grants you need
6. Click **Start** and wait seconds for results
7. Download your dataset as CSV, Excel, JSON, or XML

***

### 💼 Business use cases

#### Grant landscape analysis

Track which institutions are receiving the most NIH funding in your research area. Identify top PIs, funding trends over time, and emerging research topics by querying keywords across multiple fiscal years.

#### Competitive intelligence for grant writers

Before writing an R01, search for funded projects in your area to understand what NIH is currently supporting, identify gaps in the funded portfolio, and benchmark your budget against comparable awards.

#### Academic research mapping

Universities can extract all grants awarded to their institution or peer institutions to build comprehensive research portfolios, support faculty recruitment, and identify collaboration opportunities.

#### Science journalism and policy research

Journalists and policy analysts can extract funding data by topic area (e.g. climate health, opioid crisis, COVID-19) to quantify federal investment and track how NIH priorities shift across administrations.

***

### 🔌 Automating NIH Reporter Grants Scraper

Connect this Actor to your workflow tools without writing any code:

- **Make (Integromat):** Schedule weekly grant monitoring runs and push results to Google Sheets or Airtable
- **Zapier:** Trigger a run when a new keyword is added to a spreadsheet, then send results to Slack or email
- **Slack:** Deliver weekly NIH funding digests to a research team channel automatically
- **Webhook:** POST results to any REST endpoint - LIMS, CRMs, or internal dashboards
- **Apify Scheduler:** Set daily or weekly runs to keep your grant database current

***

### 🌟 Beyond business use cases

#### Academic research

Study how federal biomedical funding priorities have shifted over 40 years. Analyze the geographic distribution of NIH grants, track which universities dominate specific research areas, or map collaboration networks through shared institutional awards.

#### Creative and educational projects

Build searchable public tools that let patients and advocates explore what research NIH is funding for their disease. Create educational dashboards showing how federal science investment translates into research outputs.

#### Non-profit and advocacy work

Patient advocacy organizations can use this data to monitor NIH investment in their disease area, identify gaps in the funded research portfolio, and make evidence-based funding recommendations.

#### Data science experimentation

NIH Reporter is an excellent labeled dataset for NLP experimentation - training text classifiers, topic models, or citation networks using real scientific abstracts and metadata.

***

### 🤖 Ask an AI assistant about this scraper

You can use an AI assistant to help you get the most out of this Actor:

- "Which institutions received the most NIH R01 grants for cancer research in 2024?"
- "Help me write a search query to find NIH grants on CRISPR applications in agriculture"
- "What funding mechanism should I use to find postdoctoral fellowships?"
- "Analyze this NIH grant dataset and identify the top 10 research themes"

***

### ❓ Frequently Asked Questions

**🔍 What can I search for?**
Any biomedical or behavioral research topic. The search runs across project titles, abstracts, and full text. Try disease names, biological processes, technologies, or any scientific keyword.

**📅 How far back does the data go?**
NIH Reporter contains grants going back to fiscal year 1985, giving you over 40 years of federal research investment history.

**💰 Are award amounts always populated?**
Most grants have award amounts. A small number of contract vehicles may show null if the NIH does not disclose the exact amount.

**🏛️ Does this include all NIH institutes?**
Yes. All 27 NIH institutes and centers are included - NCI, NIAID, NIMH, NHLBI, and all others.

**📝 How long are the abstracts?**
Abstracts vary from a few sentences to several thousand words. Some older grants may have no abstract on file.

**🔢 What are funding mechanisms?**
NIH uses mechanism codes to categorize grant types: R01 (research project), R21 (exploratory), K99 (career transition), T32 (training), F31 (predoctoral fellowship), and hundreds more.

**📊 What is the maximum number of items?**
Paid accounts can retrieve up to 1,000,000 grants per run. The NIH Reporter database contains approximately 500,000-600,000 active and recently closed projects.

**🔄 How current is the data?**
Data is pulled live from the NIH Reporter API on every run. The API is updated by NIH regularly as new awards are issued.

**🏥 What does the clinicalTrial field mean?**
It indicates whether the NIH required a clinical trial protocol for this grant. Many grants show null because this requirement is mechanism-specific.

**📁 What export formats are available?**
Apify supports CSV, Excel (XLSX), JSON, XML, and RSS. You can also access data via the Apify API for programmatic integration.

**🔑 Do I need an API key for NIH Reporter?**
No. The NIH Reporter API is fully public with no authentication required. This Actor accesses it directly.

**🌍 Are international institutions included?**
Yes. NIH funds some international collaborations. The country field identifies the institution location.

***

### 🔌 Integrate with any app

Connect your NIH grant data to the tools your team already uses:

| Integration | Use Case |
|---|---|
| Google Sheets | Live-updating grant monitoring dashboards |
| Airtable | Structured grant database with filtering |
| Slack | Automated weekly funding digests |
| Notion | Research knowledge base with grant context |
| Excel | Offline analysis and pivot tables |
| Python / Pandas | Data science and NLP pipelines |
| R / tidyverse | Statistical analysis of funding trends |
| Tableau / Power BI | Visualization of funding distributions |
| PostgreSQL / BigQuery | Long-term grant database archiving |
| Zapier / Make | No-code workflow automation |

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [ClinicalTrials.gov Scraper](https://apify.com/parseforge) | FDA-registered clinical trial data including phases, sponsors, and outcomes |
| [OpenAlex Publications Scraper](https://apify.com/parseforge) | Academic publications, citations, and author networks |
| [NIH NLM PubMed Scraper](https://apify.com/parseforge) | Biomedical literature abstracts and MeSH terms from PubMed |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering 150+ public data sources across science, finance, government, and more.

***

*This Actor accesses publicly available data from the NIH Research Portfolio Online Reporting Tools (RePORTER) via the official public API (api.reporter.nih.gov). All data is provided by the U.S. Department of Health and Human Services. This tool is not affiliated with or endorsed by the National Institutes of Health. Use of this data is subject to NIH's public data use policies.*

# Actor input Schema

## `searchQuery` (type: `string`):

Keywords to search in grant titles and abstracts (e.g. 'cancer immunotherapy', 'Alzheimer', 'machine learning')

## `fiscalYear` (type: `integer`):

Filter by fiscal year (e.g. 2024, 2023). Leave empty for all years.

## `fundingMechanism` (type: `string`):

Filter by NIH funding mechanism (e.g. 'R01', 'R21', 'T32', 'F31', 'K99'). Leave empty for all.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "searchQuery": "cancer immunotherapy",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "cancer immunotherapy",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/nih-reporter-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 = {
    "searchQuery": "cancer immunotherapy",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/nih-reporter-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 '{
  "searchQuery": "cancer immunotherapy",
  "maxItems": 10
}' |
apify call parseforge/nih-reporter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NIH RePORTER Scraper",
        "description": "Scrape NIH research grant awards with 40+ fields per project. Get funding amounts, principal investigators, institutions, abstracts, spending categories, and geo coordinates. Filter by keyword, fiscal year, agency, and active status.",
        "version": "0.1",
        "x-build-id": "IiyvL0BL61UqQsYcy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~nih-reporter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-nih-reporter-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/parseforge~nih-reporter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-nih-reporter-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/parseforge~nih-reporter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-nih-reporter-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keywords to search in grant titles and abstracts (e.g. 'cancer immunotherapy', 'Alzheimer', 'machine learning')"
                    },
                    "fiscalYear": {
                        "title": "Fiscal Year",
                        "minimum": 1985,
                        "maximum": 2026,
                        "type": "integer",
                        "description": "Filter by fiscal year (e.g. 2024, 2023). Leave empty for all years."
                    },
                    "fundingMechanism": {
                        "title": "Funding Mechanism",
                        "type": "string",
                        "description": "Filter by NIH funding mechanism (e.g. 'R01', 'R21', 'T32', 'F31', 'K99'). Leave empty for all."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
