# conda-forge Packages Scraper (`parseforge/conda-forge-packages-scraper`) Actor

Scrapes conda-forge packages by search term or name prefix and returns each package as a flat row with name, summary, description, and metadata. Export to CSV, JSON, Excel, or XML.

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

## Pricing

from $19.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/actors/running/actors-in-store.md#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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### conda-forge Packages Scraper

**Scrape conda-forge packages by search term or name prefix, up to a million per run.** Every package comes with its name, version, summary, and full metadata. No login or API key. Export to CSV, JSON, Excel, or XML.

conda-forge hosts over 25,000 community-maintained conda packages for Python, R, and scientific computing, but browsing the channel by hand is slow and the official API needs registration. This Actor reads the public package index directly, filters by a search term or name prefix, and returns each match in one fixed schema.

| Who uses it | What they scrape conda-forge for |
|---|---|
| Data scientists | Audit which conda-forge packages are available for a dependency before pinning versions |
| DevOps engineers | Build an inventory of conda-forge packages used across environments |
| Package maintainers | Monitor the conda-forge channel for packages that match a naming convention |
| Security researchers | List conda-forge packages by prefix to review metadata for supply-chain checks |

### What it does

This Actor collects conda-forge package records by search term or name prefix, and returns each one as a flat row with its name, version, summary, and metadata.

- 🔍 **Search filter:** keep only packages whose name, summary, or description contains your term, like numpy or gis.
- 🔤 **Name prefix:** keep only packages whose name starts with a prefix, like py or gdal.
- 📄 **Pagination:** use Offset and Maximum packages to page through the full channel alphabetically.
- 📦 **Flat rows:** every package is returned as one row, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with conda-forge data

**📊 Audit dependencies.**

A data scientist searches conda-forge for a package name to confirm it exists and check its summary before adding it to an environment.yml.

**🗂️ Build a package inventory.**

A DevOps engineer pages through conda-forge with a prefix like py to list all matching packages and export them to CSV for an internal registry.

**🔎 Monitor naming conventions.**

A package maintainer runs the Actor weekly with a prefix to see if new conda-forge packages match their project's namespace.

**🛡️ Review metadata for security.**

A security researcher collects conda-forge packages by search term and reviews the returned metadata for suspicious summaries or versions.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Reads the public conda-forge package index directly, no registration or rate limits |
| **Filter as you go** | Search term and name prefix filters run before collection, so only matches reach your dataset |
| **Page through everything** | Offset and Maximum packages let you collect the full channel in chunks |
| **Fixed schema** | Every package returns the same flat fields, so downstream processing is predictable |

### How it compares

This Actor focuses on simple search and prefix filtering of conda-forge packages, while the competitors below offer additional features like maintainer listing or Anaconda-specific data.

| Feature | ParseForge | Conda-Forge Scraper | Anaconda Conda Package Scraper - Versions & Downloads |
|---|---|---|---|
| Search by package name or summary | Yes | Yes | Not listed |
| Filter by name prefix | Yes | Not listed | Not listed |
| List packages by maintainer | Not listed | Yes | Not listed |
| Package versions and downloads | Not listed | Not listed | Yes |
| License and platform data | Not listed | Not listed | Yes |
| Export to CSV, JSON, Excel, XML | Yes | Not listed | Yes |

### Configure the run

Drive the Actor with a search term or a name prefix, alone or together, and use Offset and Maximum packages to page through the channel. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "offset": 0,
 "maxItems": 10
}
```

A larger pull:

```json
{
 "offset": 0,
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [conda-forge Packages Scraper](https://apify.com/parseforge/conda-forge-packages-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to conda-forge through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/conda-forge-packages-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your Search term or Name Starts With input is not too restrictive. Try leaving both empty and setting a small Maximum packages to see the first packages in the channel.

**Why did the run stop before collecting all packages?**

The Maximum packages input limits the run. Increase it, or use Offset to continue from where the previous run stopped.

**Why is the output missing some fields?**

The Actor returns the fields available in the conda-forge index. Some packages may have empty values for optional metadata like summary.

**Can I use this Actor for the Anaconda default channel?**

No, this Actor scrapes conda-forge only. For the Anaconda default channel, use a different scraper.

### FAQ

| Question | Answer |
|---|---|
| What is conda-forge? | conda-forge is a community-led collection of conda packages for scientific Python, R, and other languages. It is the default channel for many data science environments. |
| Do I need an API key or login? | No. This Actor reads the public conda-forge package index directly, so there is no registration, OAuth, or rate limit to manage. |
| How do I search for a package? | Set the Search term input to a word like numpy or gis. The Actor keeps only packages whose name, summary, or description contains that text. |
| How do I list packages by name prefix? | Set the Name Starts With input to a prefix like py or gdal. The filter is case-insensitive and runs before collection. |
| Can I collect all conda-forge packages? | Yes. Leave Search term and Name Starts With empty, set Maximum packages to a high number, and use Offset to page through the full channel alphabetically. |
| What fields does each package row contain? | Each row includes the package name, version, summary, and other metadata from the conda-forge index. The exact fields are shown in the sample output. |
| What export formats are supported? | You can export the dataset to CSV, JSON, Excel, or XML from the Apify platform. |
| How many packages can I collect in one run? | The Maximum packages input accepts up to 1,000,000, so you can collect the entire channel in a single run if needed. |
| Is this the same as the Anaconda package repository? | No. conda-forge is a separate community channel. This Actor scrapes conda-forge only, not the Anaconda default channel. |
| Can I filter by package version or license? | Not directly. The Actor filters by search term and name prefix only. You can post-process the exported data to filter by version or license. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by conda-forge community. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `search` (type: `string`):

Optional. Keep only packages whose name, summary, or description contains this text (for example numpy, gis, machine learning). Leave empty to browse the full channel alphabetically.

## `startsWith` (type: `string`):

Optional. Keep only packages whose name starts with this prefix (case-insensitive), for example py or gdal.

## `offset` (type: `integer`):

How many matching packages to skip before collecting. Use with Max Items to page through the channel.

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

Maximum number of packages to collect per run.

## Actor input object example

```json
{
  "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 = {
    "search": "",
    "startsWith": "",
    "offset": 0,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/conda-forge-packages-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 = {
    "search": "",
    "startsWith": "",
    "offset": 0,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/conda-forge-packages-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 '{
  "search": "",
  "startsWith": "",
  "offset": 0,
  "maxItems": 10
}' |
apify call parseforge/conda-forge-packages-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/conda-forge-packages-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/9xudOVh41P26iWJOU/builds/fqXfc0kAgzmYnQlRf/openapi.json