# NuGet Scraper · .NET Packages, Versions, Downloads & Authors (`reapx/nuget-scraper`) Actor

Scrape NuGet .NET packages, versions, download counts, authors, tags, and dependencies. Search by keyword, tag, framework, author, or package ID prefix.

- **URL**: https://apify.com/reapx/nuget-scraper.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (community)
- **Categories:** Developer tools, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 nuget package record scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

![reapX — public sources in, addressable records out](https://reapx.dev/reapx.gif)

## NuGet Scraper · .NET Packages, Versions, Downloads & Authors

NuGet Scraper extracts comprehensive public package metadata from NuGet, the official package manager for .NET. Collect package identifiers, titles, version history, download statistics, authors, project repository URLs, license terms, tags, framework targets, and security vulnerability alerts.

> Maintained by **reapX**. Every row cites the Apify run that produced it — nothing is
> inferred, modelled or filled in, and a field absent from the source is absent from the row.
> The extracted archive for this source is browsable at
> [reapx.dev/data/nuget-scraper/](https://reapx.dev/data/nuget-scraper/) and mirrored as an open dataset on
> [Hugging Face](https://huggingface.co/datasets/reapxdev/nuget-scraper) and
> [Kaggle](https://www.kaggle.com/datasets/reapxdev/nuget-scraper). Questions: reapxdev@proton.me

***

### ⬇️ Input

Every field is described here exactly as the Actor reads it. Run it with the prefilled input and it returns real rows without any further configuration.

| Field | Type | Required | Prefilled | What it does |
| --- | --- | --- | --- | --- |
| `query` | string | yes | `"json"` | Search query string for NuGet packages. Supports free text (e.g. json), tag filters (e.g. tag:logging), target framework (e.g. framework:net8.0), author (e.g. author:microsoft), or package... |
| `includePrerelease` | boolean | no | `false` | Include pre-release packages (alpha, beta, RC versions) in search results. When enabled, pre-release package metadata is scraped alongside stable releases. |
| `packageType` | string | no | - | Narrow the search to one kind of NuGet package: a library, a .NET CLI tool or a project/item template. |
| `includeDependencies` | boolean | no | `false` | Read each package's registration index and add dependencies, dependencyCount, targetFrameworks, published, licenseExpression and listed. The search endpoint carries none of those at any... |
| `minDownloads` | integer | no | - | Minimum total download count filter. Package records with fewer total downloads than this value will be excluded from the dataset results. |
| `maxItems` | integer | yes | `50` | Maximum package records to return and push to the default dataset (1 to 5,000). |
| `maxPages` | integer | yes | `5` | Maximum search result pages to fetch from the NuGet V3 search API (1 to 100). Each page retrieves up to 100 package items. |

#### What empty means, and what a larger value costs

The two questions an input table normally does not answer. Both columns are read off this Actor's own code and its own price list.

| Field | Left empty | Turned up |
| --- | --- | --- |
| `query` | Leave empty to search popular default packages. | Narrowing this reduces rows returned, so it lowers the bill. |
| `includePrerelease` | Only stable release packages are returned. Disabling pre-release excludes unfinished packages and speeds up processing. | Turning this on costs extra requests to the source, not extra rows. |
| `packageType` | Leave empty to search every package type, which is what nuget.org itself does. | This filter is applied by the search service, not afterwards, so it makes runs cheaper rather than more expensive. Measured live: json matches 11,017 packages, json restricted to... |
| `includeDependencies` | Those six fields stay empty, 0 and true. | One extra request per package, run 5 at a time, so a 500-package run takes noticeably longer. It adds no rows and no charge. |
| `minDownloads` | Leave empty for no minimum download constraint. | Narrowing this reduces rows returned, so it lowers the bill. |
| `maxItems` | Falls back to `50` | Each row returned is one **$0.001** charge, so this field is your cost cap as well as your row cap. At the ceiling of 5,000 rows that is $5.00 at list price. |
| `maxPages` | Falls back to `5` | More pages means more HTTP requests to the source and a longer run. It raises the ceiling on rows without raising the row cap itself. |

### ⬆️ Output

One row per record, as JSON, CSV, Excel or XML, and through the API. Every field below is on every row this Actor writes; a field the source did not return is empty rather than guessed.

| Field | Type | What it gives you | Example |
| --- | --- | --- | --- |
| `packageName` | string | Unique .NET package identifier on NuGet (e.g. Newtonsoft.Json) | "Newtonsoft.Json" |
| `title` | string | Display title of the NuGet package | "Json.NET" |
| `version` | string | Latest published version string | "13.0.4" |
| `description` | string | Full package description detailing purpose and usage | "Json.NET is a popular high-performance JSON framework fo... |
| `summary` | string | Short summary description of the package | "High-performance JSON framework for .NET" |
| `authors` | array | List of package authors | \["James Newton-King"] |
| `owners` | array | List of NuGet package owners/publishers | \["newtonsoft", "nuget"] |
| `totalDownloads` | integer | Cumulative total download count across all versions | 982341234 |
| `projectUrl` | string | URL to the open-source project repository or homepage | "https://www.newtonsoft.com/json" |
| `licenseUrl` | string | URL to the package license terms | "https://licenses.nuget.org/MIT" |
| `iconUrl` | string | URL to the package logo/icon image | "https://api.nuget.org/v3-flatcontainer/newtonsoft.json/1... |
| `tags` | array | Package categorization and search keywords | \["json", "serialization", "xml"] |
| `verified` | boolean | Whether the package owner prefix is verified by NuGet | true |
| `versionsCount` | integer | Total number of published releases and versions | 45 |
| `latestVersionDownloads` | integer | Download count specifically for the latest release | 168874731 |
| `packageTypes` | array | Types of NuGet package (e.g. Dependency, DotnetTool) | \["Dependency"] |
| `hasVulnerabilities` | boolean | Indicates whether known security vulnerabilities exist for any version | false |
| `vulnerabilitiesCount` | integer | Total number of recorded security advisory vulnerabilities | 0 |
| `published` | string | When the current version was published to nuget.org. Empty unless Include Dependencies & Publish Date is on. | "2026-07-31T09:14:02.473+00:00" |
| `licenseExpression` | string | Licence the package declares, as an SPDX expression. Empty unless Include Dependencies & Publish Date is on, or when... | "Apache-2.0" |
| `listed` | boolean | False when the current version has been unlisted from search by its owner but is still installable by exact version. | true |
| `dependencyCount` | integer | Distinct package dependencies across every target framework of the current version. Zero unless Include Dependencies &... | 24 |
| `targetFrameworks` | array | Frameworks the current version declares a dependency group for, such as .NETStandard2.0 or net8.0. | \[".NETStandard2.0", "net8.0"] |
| `dependencies` | array | Each dependency as package id, version range and the target framework that declares it. | \[{"id": "System.Text.Json", "range": "\[8.0.0, )", "target... |

#### Dataset views

The dataset ships with named views, so the Output tab, the API and any agent reading this Actor get the columns that matter for a job without asking for all of them.

**Overview** (`?view=overview`) - 7 columns: `packageName`, `title`, `version`, `totalDownloads`, `authors`, `tags`, `verified`

| Column | Header |
| --- | --- |
| `packageName` | Package |
| `title` | Title |
| `version` | Version |
| `totalDownloads` | Total Downloads |
| `authors` | Authors |
| `tags` | Tags |
| `verified` | Verified Owner |

**Downloads & Versions** (`?view=downloads`) - 7 columns: `packageName`, `version`, `totalDownloads`, `latestVersionDownloads`, `versionsCount`, `hasVulnerabilities`, `vulnerabilitiesCount`

| Column | Header |
| --- | --- |
| `packageName` | Package |
| `version` | Version |
| `totalDownloads` | Total Downloads |
| `latestVersionDownloads` | Downloads (this version) |
| `versionsCount` | Versions Published |
| `hasVulnerabilities` | Known Vulnerabilities |
| `vulnerabilitiesCount` | Advisory Count |

**Dependencies & Frameworks** (`?view=dependencies`) - 7 columns: `packageName`, `version`, `dependencyCount`, `targetFrameworks`, `dependencies`, `licenseExpression`, `published`

| Column | Header |
| --- | --- |
| `packageName` | Package |
| `version` | Version |
| `dependencyCount` | Dependencies |
| `targetFrameworks` | Target Frameworks |
| `dependencies` | Dependency List |
| `licenseExpression` | License |
| `published` | Published |

**Authors & Project Links** (`?view=authors`) - 7 columns: `packageName`, `authors`, `owners`, `projectUrl`, `licenseUrl`, `iconUrl`, `packageTypes`

| Column | Header |
| --- | --- |
| `packageName` | Package |
| `authors` | Authors |
| `owners` | Owners |
| `projectUrl` | Project URL |
| `licenseUrl` | License URL |
| `iconUrl` | Icon |
| `packageTypes` | Package Types |

Fetch one directly:

```
GET https://api.apify.com/v2/datasets/{datasetId}/items?view=overview&format=csv
```

#### One real row

Unedited, from this Actor's own most recent successful run.

```json
{
  "packageName": "Dapper",
  "title": "Dapper",
  "version": "2.1.79",
  "description": "A high performance Micro-ORM supporting SQL Server, MySQL, Sqlite, SqlCE, Firebird etc. Major Sponsor: Dapper Plus from ZZZ Projects.",
  "summary": "",
  "authors": [
    "Sam Saffron,Marc Gravell,Nick Craver"
  ],
  "owners": [
    "Dapper",
    "marc.gravell",
    "nick.craver"
  ],
  "totalDownloads": 730063539,
  "projectUrl": "https://github.com/DapperLib/Dapper",
  "licenseUrl": "https://www.nuget.org/packages/Dapper/2.1.79/license",
  "iconUrl": "https://api.nuget.org/v3-flatcontainer/dapper/2.1.79/icon",
  "tags": [
    "orm",
    "sql",
    "micro-orm"
  ],
  "verified": true,
  "versionsCount": 63,
  "latestVersionDownloads": 6769082,
  "packageTypes": [
    "Dependency"
  ],
  "hasVulnerabilities": false,
  "vulnerabilitiesCount": 0,
  "published": "2026-05-16T20:39:31.827+00:00",
  "licenseExpression": "Apache-2.0",
  "listed": true,
  "dependencyCount": 5,
  "targetFrameworks": [
    ".NETFramework4.6.1",
    "net8.0",
    "net10.0",
    ".NETStandard2.0"
  ],
  "dependencies": [
    {
      "id": "Microsoft.Bcl.AsyncInterfaces",
      "range": "[10.0.8, )",
      "targetFramework": ".NETFramework4.6.1"
    },
    {
      "id": "System.Threading.Tasks.Extensions",
      "range": "[4.6.3, )",
      "targetFramework": ".NETFramework4.6.1"
    },
    {
      "id": "Microsoft.Bcl.AsyncInterfaces",
      "range": "[10.0.8, )",
      "targetFramework": ".NETStandard2.0"
    },
    {
      "id": "System.Reflection.Emit.Lightweight",
      "range": "[4.7.0, )",
      "targetFramework": ".NETStandard2.0"
    },
    {
      "id": "System.Threading.Tasks.Extensions",
      "range": "[4.6.3, )",
      "targetFramework": ".NETStandard2.0"
    }
  ]
}
```

### 🧪 Worked examples

Every block below is an input this Actor has actually run, with the row count of the run that produced it. Copy one straight into the Console.

#### ORM libraries with dependencies and publish dates

```json
{
  "query": "tag:orm",
  "packageType": "Dependency",
  "includeDependencies": true,
  "maxItems": 25,
  "maxPages": 1
}
```

That run returned **25 rows** in 5s.

#### Popular JSON & Serialization Packages

Scrape top .NET JSON parsing, formatting, and serialization libraries from NuGet.

```json
{
  "query": "json",
  "maxItems": 50
}
```

That run returned **50 rows**.

#### High-Download .NET Utility Libraries

Extract popular .NET utility packages filtered by a 100,000+ total downloads threshold.

```json
{
  "query": "utility",
  "minDownloads": 100000,
  "maxItems": 50
}
```

That run returned **50 rows**.

#### Prerelease & Preview .NET Packages

Scrape package search results including preview, alpha, and beta release versions.

```json
{
  "query": "json",
  "includePrerelease": true,
  "maxItems": 50
}
```

That run returned **50 rows**.

#### Logging & Diagnostics Frameworks

Extract .NET logging abstractions, sinks, structured loggers, and diagnostic tools.

```json
{
  "query": "tag:logging",
  "maxItems": 50
}
```

That run returned **50 rows**.

#### MediatR CQRS In-Process Messaging

Collect MediatR mediator pattern implementations, request handlers, and pipeline behaviors.

```json
{
  "query": "id:MediatR",
  "maxItems": 50
}
```

That run returned **50 rows**.

### How it works

#### The endpoint it calls

Plain HTTP against the source's own public API. No headless browser, no login, no key of yours:

```
https://azuresearch-usnc.nuget.org/query
https://api.nuget.org/v3/registration5-gz-semver2
```

The Azure Search endpoint behind nuget.org - the same service the gallery's own search box calls, so the ranking you get here is the ranking a .NET developer sees.

#### The paging it does

Paging is `skip` and `take`, 100 packages per request, up to **Max Pages** requests. The client stops as soon as a page returns nothing, so a narrow query costs one request rather than the whole page budget.

Query syntax is the gallery's own, and it is what makes one task genuinely different from another: bare words search text, `tag:logging` filters by tag, `author:microsoft` by author, `id:Serilog` by package id prefix, `framework:net8.0` by target framework. `packageType` narrows to libraries, .NET tools or templates - measured live, `q=json` returns 11,017 hits and `q=json&packageType=DotnetTool` returns 350.

`semVerLevel=2.0.0` is always sent, so SemVer 2.0.0 packages are not silently missing from your results. De-duplication is by lowercased package id across every page.

#### The rate it holds

Every request is retried up to **3 times**, with the wait doubling between attempts, and HTTP **429, 500, 502, 503, 504** are treated as retryable rather than fatal. Each request times out at **15s**, detail requests run **5 at a time** and never more.

One request at a time, retried up to 3 times with the delay doubling between attempts. No key, no account, no quota to apply for.

#### What you are charged

One `package-scraped` event per row written to the dataset, $0.001 at list price. Charged for each NuGet package record scraped and pushed to default dataset

| Apify plan tier | Price per row |
| --- | --- |
| Free | $0.001 |
| Bronze | $0.00095 |
| Silver | $0.0009 |
| Gold | $0.00085 |
| Platinum | $0.0008 |
| Diamond | $0.00075 |

Apify platform usage is absorbed, not passed on, so the row price is the whole bill.

#### Why the dataset is correct at every moment

Rows are written and charged one at a time as the pages come back, so a run stopped by your budget cap leaves every row it had already collected and charges for those only.

### ⚠️ Error reference

Derived from this Actor's own exception classes and the HTTP branches in its client. The run always reports what happened in its **status message**, so you never need the log to know what you got.

| Raised | When | What the run does |
| --- | --- | --- |
| `BadQuery` | Raised when the NuGet API returns a 400 Bad Request error. | Run fails with: *NuGet API rejected query input: <exc>* |
| `SourceBlocked` | Raised when the NuGet API is unreachable, rate limited, or returning 5xx/403 errors. | Run fails with: *NuGet API unreachable or throttled: <exc>* |

#### HTTP statuses the client actually handles

| Status | Handling |
| --- | --- |
| `429` | Retried with backoff. The run continues if a later attempt succeeds. |
| `500` | Retried with backoff. The run continues if a later attempt succeeds. |
| `502` | Retried with backoff. The run continues if a later attempt succeeds. |
| `503` | Retried with backoff. The run continues if a later attempt succeeds. |
| `504` | Retried with backoff. The run continues if a later attempt succeeds. |
| `400` | The source rejected the query itself, so retrying it cannot help; the input is at fault. |

#### What each outcome costs

| Outcome | Rows | Charged |
| --- | --- | --- |
| Run finished | Everything the source returned for your filters | One `package-scraped` per row |
| Nothing matched your filters | 0 | **Nothing** |
| Source refused or was unreachable | Whatever was already collected | Only the rows you got |
| Budget cap reached mid-run | The rows collected before the cap | Only those rows |

Status messages this Actor can end on, verbatim from its own source:

- Run budget of $ cannot cover a single event record at $<record event price usd> plus start cost $<start cost>. Raise Max Total Charge to at least $\<start cost + record event price usd>.
- NuGet API unreachable or throttled: <exc>
- No NuGet packages found matching criteria. Zero charged.
- Pushed <pushed count> NuGet package records, <verified> of them from verified owners. Charged <pushed count> at $<record event price usd> each.

### ❓ FAQ

##### Can I search packages by target framework?

Yes. Use the `framework:` filter prefix in the `query` field, such as `framework:net8.0`, `framework:net9.0`, or `framework:netstandard2.0`.

##### How do I filter by specific package authors or owners?

Use the `author:` filter prefix in the `query` field, for example `author:microsoft` or `author:amazon`.

##### How do I scrape pre-release package versions?

Set `"includePrerelease": true` in your run input. By default, only stable releases are included.

##### What happens if a search query matches no packages?

The scraper completes with 0 records pushed and charges $0.00.

***

#### Do I need an API key, an account or a proxy?

No. The Actor reads the source's public interface over plain HTTP, with no credential of yours anywhere in the run and no headless browser. You need an Apify account and nothing else.

#### What does a run cost?

One `package-scraped` event per row written, $0.001 at list price, falling to $0.00075 on the highest Apify plan tier. Apify platform usage is absorbed rather than passed on, so the row price is the whole bill. A run that matches nothing is charged nothing.

#### How many rows can one run return?

Up to 5,000, set by the maximum-results field, which is also your cost cap. Raise it for a bigger slice, or set a **Max total charge** on the run and the Actor will stop cleanly when it gets there.

#### Can I get just some of the columns?

Yes. The dataset ships named views (`overview`, `downloads`, `dependencies`, `authors`); add `?view=<name>` to the dataset items URL, or pick one in the Output tab, and you get that view's columns in JSON, CSV or Excel.

#### Can an agent call this?

Yes, through Apify's MCP server at <https://mcp.apify.com> with nothing to integrate on our side: `search-actors` finds it, `fetch-actor-details` returns the input schema above, and `call-actor` runs it.

#### Will the dataset still be there next month?

Yes. The run names its own default dataset at startup, and Apify keeps named storages past the retention window that deletes unnamed ones, so the run id in a row you cited a year ago still resolves.

### 💬 Your feedback

Have feature requests or questions? Contact the maintainers at **reapxdev@proton.me** or visit [reapx.dev](https://reapx.dev).

***

Unofficial - not affiliated with NuGet / Microsoft. Collects public data only. reapx. Contact reapxdev@proton.me.

# Actor input Schema

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

<b>Search query string</b> for NuGet packages. Supports free text (e.g. <code>json</code>), tag filters (e.g. <code>tag:logging</code>), target framework (e.g. <code>framework:net8.0</code>), author (e.g. <code>author:microsoft</code>), or package ID prefix (e.g. <code>id:Serilog</code>).<br><br>Leave empty to search popular default packages. Broad queries return more package records, increasing execution time and pay-per-event charges.

## `includePrerelease` (type: `boolean`):

<b>Include pre-release packages</b> (alpha, beta, RC versions) in search results. When enabled, pre-release package metadata is scraped alongside stable releases.<br><br>When disabled (default), only stable release packages are returned. Disabling pre-release excludes unfinished packages and speeds up processing.

## `packageType` (type: `string`):

Narrow the search to one kind of NuGet package: a library, a .NET CLI tool or a project/item template.<br><br><b>Empty value:</b> leave empty to search every package type, which is what nuget.org itself does.<br><br><b>Consequence:</b> this filter is applied by the search service, not afterwards, so it makes runs cheaper rather than more expensive. Measured live: <code>json</code> matches 11,017 packages, <code>json</code> restricted to .NET tools matches 350.

## `includeDependencies` (type: `boolean`):

Read each package's registration index and add <code>dependencies</code>, <code>dependencyCount</code>, <code>targetFrameworks</code>, <code>published</code>, <code>licenseExpression</code> and <code>listed</code>. The search endpoint carries none of those at any page size.<br><br><b>Turned off (the default):</b> those six fields stay empty, <code>0</code> and <code>true</code>.<br><br><b>Consequence:</b> one extra request per package, run 5 at a time, so a 500-package run takes noticeably longer. It adds no rows and no charge.

## `minDownloads` (type: `integer`):

<b>Minimum total download count</b> filter. Package records with fewer total downloads than this value will be excluded from the dataset results.<br><br>Leave empty for no minimum download constraint. Setting a minimum download limit filters out obscure packages and reduces dataset noise.

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

<b>Maximum package records</b> to return and push to the default dataset (1 to 5,000).<br><br>Default is <code>50</code> package records for fast execution. The higher the number, the longer the run takes and the more pay-per-event credits are consumed.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## `maxPages` (type: `integer`):

<b>Maximum search result pages</b> to fetch from the NuGet V3 search API (1 to 100). Each page retrieves up to 100 package items.<br><br>Default is <code>5</code> pages. Higher page limits allow scraping deeper into search results but increase overall execution time.<br><br>The higher the number, the longer the run takes and the more you are charged, because you pay per row returned.

## Actor input object example

```json
{
  "query": "json",
  "maxItems": 50,
  "maxPages": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset containing scraped NuGet package records

# 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": "json",
    "includePrerelease": false,
    "packageType": "",
    "includeDependencies": false,
    "maxItems": 50,
    "maxPages": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/nuget-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": "json",
    "includePrerelease": False,
    "packageType": "",
    "includeDependencies": False,
    "maxItems": 50,
    "maxPages": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/nuget-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": "json",
  "includePrerelease": false,
  "packageType": "",
  "includeDependencies": false,
  "maxItems": 50,
  "maxPages": 5
}' |
apify call reapx/nuget-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reapx/nuget-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PGxgFtWr4cfQSztzE/builds/C5wVLKv5LFy0k3XHh/openapi.json