# Conda-Forge Scraper (`crawlerbros/conda-forge-scraper`) Actor

Scrape conda-forge, the community-led collection of 25K+ conda packages for scientific Python, R, and more. Search packages, get detailed metadata, or list packages by maintainer.

- **URL**: https://apify.com/crawlerbros/conda-forge-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Conda-Forge Scraper

Scrape **conda-forge** — the community-led conda channel with 25,000+ packages for scientific Python, R, Julia, and more. Get package metadata including versions, platforms, download counts, maintainers, and documentation links via the Anaconda.org public API.

### What you get

- **Package search** — find conda-forge packages by name keyword with full metadata
- **Package details** — download counts, all versions, platform availability, maintainers, license, home/doc/dev URLs
- **Maintainer listings** — discover all packages contributed by a specific maintainer
- **Platform filtering** — filter results to specific CPU/OS targets (linux-64, win-64, osx-arm64, etc.)
- **No API key required** — uses the public Anaconda.org REST API

### Data source

All data is sourced from **Anaconda.org** (`api.anaconda.org`) which hosts the conda-forge channel. Data is publicly accessible without authentication.

### Use cases

- Scientific Python ecosystem research and package discovery
- Dependency auditing and license compliance checks
- Monitoring package update frequency and download popularity
- Finding alternative packages in the conda-forge ecosystem
- Building package registries and developer tooling
- Tracking maintainer contributions across conda-forge

### Modes

| Mode | Description | Required input |
|---|---|---|
| `search` | Search conda-forge packages by name keyword | `query` |
| `byPackage` | Get full metadata for a specific package | `packageName` |
| `byMaintainer` | List packages by a conda-forge maintainer | `maintainerUsername` |

### Input

| Field | Type | Description | Example |
|---|---|---|---|
| `mode` | select | What to fetch | `search` |
| `query` | string | Name keyword to search (mode=search) | `numpy` |
| `packageName` | string | Exact package name (mode=byPackage) | `scipy` |
| `maintainerUsername` | string | Anaconda.org username (mode=byMaintainer) | `jakirkham` |
| `platform` | select | Filter by platform (optional) | `linux-64` |
| `maxItems` | integer | Maximum records to return (1–500) | `20` |

#### Platform options

| Value | Platform |
|---|---|
| `linux-64` | Linux 64-bit (x86_64) |
| `linux-aarch64` | Linux ARM64 |
| `linux-ppc64le` | Linux PowerPC 64 LE |
| `win-64` | Windows 64-bit |
| `win-32` | Windows 32-bit |
| `osx-64` | macOS Intel |
| `osx-arm64` | macOS Apple Silicon |
| `noarch` | Platform-independent |

### Output

Each package record contains:

| Field | Description |
|---|---|
| `name` | Package name |
| `channel` | Always `conda-forge` |
| `summary` | Short description |
| `description` | Full description (when available) |
| `version` | Latest version |
| `versions` | All available versions (newest first, capped at 50) |
| `license` | License identifier (e.g. BSD-3-Clause, MIT) |
| `licenseUrl` | URL to license text |
| `condaPlatforms` | Supported platforms (e.g. linux-64, win-64) |
| `downloads` | Total download count |
| `homeUrl` | Project homepage |
| `devUrl` | Source code repository URL |
| `docUrl` | Documentation URL |
| `anacondaUrl` | Direct link to the Anaconda.org package page |
| `maintainers` | List of maintainer usernames (byPackage mode) |
| `watchers` | Number of watchers on Anaconda.org (byPackage mode) |
| `createdAt` | Package creation timestamp |
| `modifiedAt` | Last modification timestamp |
| `scrapedAt` | ISO 8601 timestamp when the record was scraped |

### Popular packages to try

| Package | Description |
|---|---|
| `numpy` | Fundamental array computing |
| `pandas` | Data manipulation and analysis |
| `scipy` | Scientific computing algorithms |
| `matplotlib` | Plotting and visualization |
| `scikit-learn` | Machine learning |
| `pytorch` | Deep learning framework |
| `tensorflow` | ML/deep learning |
| `r-base` | R statistical computing |
| `jupyterlab` | Interactive notebooks |

### FAQs

**Is an API key required?**
No. The Anaconda.org public API is freely accessible without registration or authentication.

**What is conda-forge?**
conda-forge is a community-maintained collection of conda package recipes and build infrastructure. It provides over 25,000 packages for the conda package manager, covering scientific computing, data science, machine learning, and many other domains.

**How current is the data?**
The data reflects real-time metadata from Anaconda.org. Package information is updated whenever maintainers publish new releases.

**How do I find packages for a specific platform?**
Set the `platform` field to filter results (e.g. `osx-arm64` for Apple Silicon Macs).

**What is the `byMaintainer` mode useful for?**
It lets you discover all packages a specific contributor maintains in conda-forge. Useful for auditing maintainer activity or finding related packages from trusted authors.

**What is the daily test run prefill?**
The default prefill `{"mode": "search", "query": "numpy", "maxItems": 5}` reliably returns multiple conda-forge package records and is used for daily automated health checks.

# Actor input Schema

## `mode` (type: `string`):

What to fetch from conda-forge.
## `query` (type: `string`):

Package name keyword to search (e.g. `numpy`, `pandas`, `scikit`).
## `packageName` (type: `string`):

Exact conda-forge package name (e.g. `numpy`, `scipy`, `matplotlib`).
## `maintainerUsername` (type: `string`):

Anaconda.org username of the conda-forge package maintainer (e.g. `jakirkham`, `ocefpaf`).
## `platform` (type: `string`):

Only include packages available on this platform (optional).
## `maxItems` (type: `integer`):

Maximum number of package records to emit.

## Actor input object example

```json
{
  "mode": "search",
  "query": "numpy",
  "packageName": "numpy",
  "maintainerUsername": "jakirkham",
  "platform": "",
  "maxItems": 5
}
````

# Actor output Schema

## `packages` (type: `string`):

Dataset containing all scraped conda-forge 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 = {
    "mode": "search",
    "query": "numpy",
    "packageName": "numpy",
    "maintainerUsername": "jakirkham",
    "platform": "",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/conda-forge-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 = {
    "mode": "search",
    "query": "numpy",
    "packageName": "numpy",
    "maintainerUsername": "jakirkham",
    "platform": "",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/conda-forge-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 '{
  "mode": "search",
  "query": "numpy",
  "packageName": "numpy",
  "maintainerUsername": "jakirkham",
  "platform": "",
  "maxItems": 5
}' |
apify call crawlerbros/conda-forge-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Conda-Forge Scraper",
        "description": "Scrape conda-forge, the community-led collection of 25K+ conda packages for scientific Python, R, and more. Search packages, get detailed metadata, or list packages by maintainer.",
        "version": "1.0",
        "x-build-id": "lTLFb5gA6tSTCfvRT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~conda-forge-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-conda-forge-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/crawlerbros~conda-forge-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-conda-forge-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/crawlerbros~conda-forge-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-conda-forge-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byPackage",
                            "byMaintainer"
                        ],
                        "type": "string",
                        "description": "What to fetch from conda-forge.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Package name keyword to search (e.g. `numpy`, `pandas`, `scikit`).",
                        "default": "numpy"
                    },
                    "packageName": {
                        "title": "Package name (mode=byPackage)",
                        "type": "string",
                        "description": "Exact conda-forge package name (e.g. `numpy`, `scipy`, `matplotlib`)."
                    },
                    "maintainerUsername": {
                        "title": "Maintainer username (mode=byMaintainer)",
                        "type": "string",
                        "description": "Anaconda.org username of the conda-forge package maintainer (e.g. `jakirkham`, `ocefpaf`)."
                    },
                    "platform": {
                        "title": "Filter by platform",
                        "enum": [
                            "",
                            "linux-64",
                            "linux-32",
                            "linux-aarch64",
                            "linux-ppc64le",
                            "win-64",
                            "win-32",
                            "osx-64",
                            "osx-arm64",
                            "noarch"
                        ],
                        "type": "string",
                        "description": "Only include packages available on this platform (optional).",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of package records to emit.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```