# Open Collective Scraper (`automation-lab/open-collective-scraper`) Actor

Scrape Open Collective: collective details, backers, transactions, and expenses via the public GraphQL API. No auth required. Export to JSON, CSV, Excel.

- **URL**: https://apify.com/automation-lab/open-collective-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Open Collective Scraper

Extract open-source funding data from [Open Collective](https://opencollective.com) — no API key, no authentication, no browser overhead. Pure GraphQL API wrapper that fetches collective details, members/backers, transactions, and expenses in seconds.

**Try it now:** [Open Collective Scraper on Apify Store](https://apify.com/automation-lab/open-collective-scraper)

### What does Open Collective Scraper do?

Open Collective Scraper connects to Open Collective's public GraphQL API at `https://api.opencollective.com/graphql/v2` and extracts structured data about any public collective. You provide one or more collective slugs (the URL identifier after `opencollective.com/`), and the actor returns a clean JSON/CSV dataset with the data you need.

**Capabilities:**
- 🏠 **Collective details** — name, description, website, social links, currency, creation date, and financial stats (balance, total raised, total spent, contributor count)
- 👥 **Members & backers** — role, donation totals, account info, profile URLs, and join dates — paginate through thousands of backers
- 💸 **Transactions** — full financial history: type (CREDIT/DEBIT), kind (CONTRIBUTION, HOST_FEE, etc.), amounts, net amounts, fees, and counterparty info
- 📋 **Expenses** — approved and pending payments: description, amount, payee, status, tags, and linked items
- ✅ **100% public data** — no login, no API key, no personal tokens required for public collectives
- ⚡ **HTTP-only** — pure API calls, no browser — fast and cheap

### Who is Open Collective Scraper for?

#### 🔬 Open-source researchers & academics
You're studying the open-source funding ecosystem — who donates, how much, and to which projects. With this actor you can:
- Map donation networks across hundreds of collectives
- Track which companies sponsor which projects via their backer accounts
- Analyze contribution trends over time using transaction history

#### 📊 Investors & VC analysts
You need to evaluate an open-source project's financial health before making an investment or partnership decision:
- Pull current balance, total raised, and spending trends
- Identify major sponsors and their contribution levels
- Compare funding levels across competing projects

#### 🏢 Developer relations & sponsorship teams
You're identifying open-source projects worth sponsoring or projects that sponsor your competitors:
- Bulk-extract backer lists from related collectives
- Find influential contributors and community leaders (ADMIN/MEMBER roles)
- Monitor when key sponsors join or leave a collective

#### 📰 Journalists & tech writers
You're covering open-source sustainability, funding inequality, or specific project economics:
- Pull verifiable financial data directly from the source
- Compare funding across language ecosystems (JS, Python, Rust, etc.)
- Extract transaction histories for investigative pieces

#### 🤖 Automation engineers
You maintain dashboards or pipelines that track OSS health metrics:
- Schedule daily/weekly runs to monitor balance changes
- Feed data into Google Sheets or Airtable for stakeholder reporting
- Trigger Slack alerts when a collective's balance drops below a threshold

### Why use Open Collective Scraper?

- 🚀 **Actually works** — direct API access, not scraping the DOM — immune to UI changes
- 🆓 **No auth required** — all public data is accessible without API keys or logins
- 📄 **Multi-type output** — collective, member, transaction, and expense records in one run
- 🔄 **Full pagination** — handles collectives with thousands of backers or tens of thousands of transactions
- 🛡️ **Graceful error handling** — invalid slugs are logged and skipped, not crashes
- 🔗 **URL input support** — paste full OpenCollective URLs or just slugs
- 📦 **Apify platform benefits** — schedule runs, export to Google Sheets, connect to Make/Zapier, monitor via webhooks

### What data can you extract?

#### 🏠 Collective Details

| Field | Description |
|-------|-------------|
| `id` | Unique Open Collective identifier |
| `name` | Display name |
| `slug` | URL slug (e.g., "webpack") |
| `description` | Short description |
| `longDescription` | Full HTML description |
| `website` | Official website URL |
| `imageUrl` | Avatar/logo image URL |
| `twitterHandle` | Twitter/X profile URL |
| `githubHandle` | GitHub organization URL |
| `currency` | Operating currency |
| `balanceValue` | Current balance amount |
| `totalAmountReceivedValue` | All-time total raised |
| `totalAmountSpentValue` | All-time total spent |
| `contributorsCount` | Number of contributors |
| `isActive` | Whether collective is active |
| `tags` | Categorization tags |
| `createdAt` | Founding date |

#### 👥 Member / Backer Records

| Field | Description |
|-------|-------------|
| `id` | Member record ID |
| `role` | BACKER, MEMBER, ADMIN, HOST, CONTRIBUTOR, ATTENDEE |
| `createdAt` | When membership started |
| `since` | Alternative start date |
| `totalDonationsValue` | Lifetime donation total |
| `totalDonationsCurrency` | Currency |
| `accountSlug` | Backer's Open Collective slug |
| `accountName` | Backer's display name |
| `accountType` | Individual or Organization |
| `accountImageUrl` | Backer's avatar URL |
| `accountWebsite` | Backer's website |
| `url` | Link to backer's OC profile |

#### 💸 Transaction Records

| Field | Description |
|-------|-------------|
| `id` | Transaction UUID |
| `type` | CREDIT or DEBIT |
| `kind` | CONTRIBUTION, HOST_FEE, EXPENSE, PAYMENT_PROCESSOR_FEE, etc. |
| `createdAt` | Transaction timestamp |
| `description` | Human-readable description |
| `amountValue` | Gross amount |
| `netAmountValue` | Net amount after fees |
| `platformFeeValue` | Open Collective platform fee |
| `hostFeeValue` | Fiscal host fee |
| `paymentProcessorFeeValue` | Payment processor fee |
| `fromAccountSlug` | Sender slug |
| `toAccountSlug` | Recipient slug |
| `isRefunded` | Whether transaction was refunded |
| `taxAmount` | Tax amount if applicable |

#### 📋 Expense Records

| Field | Description |
|-------|-------------|
| `id` | Expense ID |
| `type` | INVOICE, RECEIPT, GRANT, SETTLEMENT, UNCLASSIFIED |
| `status` | PENDING, APPROVED, PAID, REJECTED, CANCELLED |
| `description` | What the expense is for |
| `createdAt` | Submission date |
| `amountValue` | Requested amount |
| `amountCurrency` | Currency |
| `payeeSlug` | Recipient's OC slug |
| `payeeName` | Recipient's name |
| `payeeType` | Individual or Organization |
| `createdBySlug` | Submitter's slug |
| `tags` | Expense tags |
| `itemsCount` | Number of line items |

### How much does it cost to scrape Open Collective?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription. All platform costs are **included**.

| | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) |
|---|---|---|---|---|
| **Per record** | $0.00115 | $0.001 | $0.00078 | $0.0006 |
| **1,000 records** | $1.15 | $1.00 | $0.78 | $0.60 |
| **+ Start fee** | $0.005 | $0.00475 | $0.00425 | $0.00375 |

Higher-tier plans get additional volume discounts (see PLATINUM and DIAMOND tiers in the actor's pricing tab).

**Real-world cost examples:**

| Task | Records | Estimated Cost (Free tier) |
|------|---------|--------------------------|
| 1 collective + 100 backers | 101 | ~$0.12 |
| 5 collectives + details only | 5 | ~$0.01 |
| 1 collective + 1,000 transactions | 1,001 | ~$1.16 |
| 10 collectives + 100 backers each | 1,010 | ~$1.16 |

**Free plan estimate:** With $5 in free credits, you can scrape approximately 4,000 records.

### How to scrape Open Collective data

1. **Open** the [Open Collective Scraper](https://apify.com/automation-lab/open-collective-scraper) on Apify Store
2. **Click "Try for free"** — no credit card required for your first $5 in credits
3. **Enter collective slugs** — paste slugs like `webpack`, `babel`, `vuejs`, or full URLs like `https://opencollective.com/webpack`
4. **Select data types** — choose from `collective`, `members`, `transactions`, `expenses`
5. **Set limits** — control how many members/transactions/expenses to fetch per collective
6. **Click "Start"** and wait for results (typically under 30 seconds for 100 records)
7. **Export results** as JSON, CSV, Excel, XML, or RSS — or connect directly to Google Sheets

**Example inputs for common workflows:**

**Get collective stats for 5 projects:**
```json
{
    "collectiveSlugs": ["webpack", "babel", "vuejs", "react", "typescript"],
    "dataTypes": ["collective"],
    "maxMembers": 0
}
````

**Get top 500 backers of a collective:**

```json
{
    "collectiveSlugs": ["webpack"],
    "dataTypes": ["members"],
    "maxMembers": 500,
    "memberRoles": ["BACKER"]
}
```

**Get recent transactions (credits only):**

```json
{
    "collectiveSlugs": ["vuejs"],
    "dataTypes": ["transactions"],
    "maxTransactions": 100,
    "transactionTypes": ["CREDIT"]
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `collectiveSlugs` | array | — | **Required.** List of slugs or Open Collective URLs to scrape |
| `dataTypes` | array | `["collective","members"]` | Which data types to extract: `collective`, `members`, `transactions`, `expenses` |
| `maxMembers` | integer | `100` | Max members per collective. `0` = no limit |
| `maxTransactions` | integer | `100` | Max transactions per collective. `0` = no limit |
| `maxExpenses` | integer | `100` | Max expenses per collective. `0` = no limit |
| `memberRoles` | array | `[]` | Filter members by role. Options: `BACKER`, `MEMBER`, `ADMIN`, `HOST`, `CONTRIBUTOR`, `ATTENDEE`. Empty = all roles |
| `transactionTypes` | array | `[]` | Filter transactions by type: `CREDIT`, `DEBIT`. Empty = both |

### Output examples

Each run produces a single flat dataset where different record types coexist. Every record has a `recordType` field (`collective`, `member`, `transaction`, or `expense`) plus `collectiveSlug` and `collectiveName` for easy filtering.

**Collective record:**

```json
{
    "recordType": "collective",
    "collectiveSlug": "webpack",
    "collectiveName": "webpack",
    "id": "wov349mr-wgz75lpy-mzpa08dj-eybknoxd",
    "name": "webpack",
    "slug": "webpack",
    "description": "webpack is THE build solution for modern web applications.",
    "website": "https://webpack.js.org/",
    "balanceValue": 100156.56,
    "balanceCurrency": "USD",
    "totalAmountReceivedValue": 1951653.85,
    "totalAmountReceivedCurrency": "USD",
    "contributorsCount": 2605,
    "isActive": true,
    "url": "https://opencollective.com/webpack"
}
```

**Member record:**

```json
{
    "recordType": "member",
    "collectiveSlug": "webpack",
    "collectiveName": "webpack",
    "id": "nmlo94zn-7x08dpo3-z3pewga3-vjbrky5m",
    "name": "Aseem Sood",
    "role": "BACKER",
    "createdAt": "2016-10-15T15:47:40.951Z",
    "totalDonationsValue": 14,
    "totalDonationsCurrency": "USD",
    "accountSlug": "aseem",
    "accountType": "Individual",
    "url": "https://opencollective.com/aseem"
}
```

**Transaction record:**

```json
{
    "recordType": "transaction",
    "collectiveSlug": "vuejs",
    "collectiveName": "vue",
    "id": "2258ff56-4943-4a3a-b8a0-317878e9d806",
    "type": "CREDIT",
    "kind": "CONTRIBUTION",
    "createdAt": "2026-04-04T11:12:23.954Z",
    "description": "Monthly financial contribution to vue (Backers)",
    "amountValue": 2,
    "amountCurrency": "USD",
    "netAmountValue": 2,
    "fromAccountSlug": "felix19",
    "fromAccountName": "Felix",
    "toAccountSlug": "vuejs",
    "url": "https://opencollective.com/vuejs/transactions"
}
```

### Tips for best results

- 🔢 **Start small** — set `maxMembers: 20` and `maxTransactions: 20` to preview data before running at scale
- 📋 **Use `recordType` to filter** — the output dataset contains mixed record types; filter by `recordType` in your downstream tool or the Apify dataset table view
- 🔗 **Paste full URLs** — the actor accepts both `webpack` and `https://opencollective.com/webpack` — useful when copying directly from the browser
- ⏰ **Schedule for monitoring** — run daily/weekly to track funding changes over time
- 📊 **Member roles matter** — `BACKER` = financial contributors; `CONTRIBUTOR` = code/non-financial contributors; `ADMIN` = team members
- 🌐 **No pagination headaches** — the actor handles multi-page fetching automatically; just set `maxTransactions: 0` to get all records
- 💡 **Expenses may be empty** — many collectives don't use Open Collective for expense management; this is expected

### Integrations

**Open Collective Scraper → Google Sheets**
Use the built-in Google Sheets integration to populate a funding tracker spreadsheet. Set up a daily run on a popular collective (e.g., `webpack`) to monitor balance changes and new backers automatically. Perfect for open-source sustainability research.

**Open Collective Scraper → Slack/Discord**
Connect via Make (formerly Integromat) or Zapier: when a large transaction (> $1,000 CREDIT) appears in the transaction feed, send a Slack alert to your dev-relations channel. Use this to track when major sponsors join a competitor project.

**Open Collective Scraper → Airtable**
Feed member records into an Airtable base to build a sponsor relationship database. Enrich with company info by cross-referencing `accountWebsite` with your CRM. Filter by `accountType: "Organization"` to focus on corporate sponsors.

**Scheduled runs for OSS health monitoring**
Schedule a weekly run on 10-20 collectives in your ecosystem to track `balanceValue`, `contributorsCount`, and `totalAmountReceivedValue`. Export to a time-series database or Google Data Studio for trend analysis.

**Open Collective Scraper → Webhooks**
Use Apify webhooks to trigger a downstream pipeline whenever a scrape completes. For example, update a public dashboard or send a summary email every Monday morning with the latest funding stats for your watchlist.

### Using the Apify API

You can trigger and manage Open Collective Scraper runs programmatically using the Apify API.

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/open-collective-scraper').call({
    collectiveSlugs: ['webpack', 'babel', 'vuejs'],
    dataTypes: ['collective', 'members'],
    maxMembers: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/open-collective-scraper').call(run_input={
    'collectiveSlugs': ['webpack', 'babel', 'vuejs'],
    'dataTypes': ['collective', 'members'],
    'maxMembers': 100,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~open-collective-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "collectiveSlugs": ["webpack", "babel"],
    "dataTypes": ["collective", "members"],
    "maxMembers": 100
  }'
```

After the run completes, retrieve results:

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items?format=csv" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN"
```

### Use with AI agents via MCP

Open Collective Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/open-collective-scraper to fetch the top 200 backers of webpack and tell me which organizations are sponsoring it"
- "Scrape the last 100 transactions for vuejs and summarize the monthly donation trends"
- "Get collective details for babel, jest, and prettier and compare their current balances and total funding raised"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Open Collective?

Open Collective is a transparent platform — financial data is intentionally public to foster trust in open-source funding. The actor exclusively uses Open Collective's **official public GraphQL API** (`api.opencollective.com/graphql/v2`), which is designed for programmatic access.

**Key points:**

- ✅ Only public data is accessed — the same data visible to anyone on the website
- ✅ Uses the official API, not HTML scraping — respectful and stable
- ✅ No authentication bypassed — no login, session cookies, or private data accessed
- ✅ Rate limiting is respected — built-in delays between requests to avoid overloading the server
- ⚠️ Do not store or redistribute personal data in violation of GDPR — backer names and profile info are personal data when combined
- ⚠️ Always review [Open Collective's Terms of Service](https://opencollective.com/tos) before using data commercially

This actor is intended for research, analytics, and automation of publicly available data. Use it responsibly.

### FAQ

**How fast does it run?**
Very fast — purely HTTP API calls, no browser. Expect 100 records in under 5 seconds, 1,000 records in 30-60 seconds (including built-in rate-limit delays of ~200ms per pagination request).

**How much does it cost to scrape 1,000 backers?**
On the free plan: $0.005 (start fee) + 1,001 × $0.00115 ≈ $1.16. On the Scale plan: ~$0.79. The first $5 in free credits gets you ~4,000 records.

**Does it work for organizations and projects too, not just collectives?**
Yes — the `collective` query endpoint in Open Collective's API handles all account types. You can use it for organizations, projects, events, and funds as long as their slug is valid and the account is public.

**Why are the expenses list empty for some collectives?**
Not all collectives use Open Collective's expense management feature. Many collectives only use OC for receiving donations and handle payouts through other tools. This is normal and not a bug.

**Why do some transactions show 0 netAmount?**
Platform fees, host fees, and payment processor fees can reduce the net amount to zero or even negative. This is especially common for `HOST_FEE` and `PAYMENT_PROCESSOR_FEE` transaction kinds. These are real transactions — they represent fee deductions.

**I'm getting rate limit errors. What should I do?**
The built-in delays (200ms between pagination calls, 500ms between collectives) handle normal usage. If you're running many collectives in a single job, consider splitting into smaller batches or using Apify's scheduler to run separate jobs. You can also obtain a personal token from Open Collective to increase your rate limits.

**How do I get all backers for a collective with thousands of members?**
Set `maxMembers: 0` — this disables the limit and fetches all pages automatically. For webpack (3,000+ backers) this takes approximately 30-45 seconds.

### Other Open Source & Developer Tools scrapers

Looking for complementary data? Here are other automation-lab actors you might find useful:

- [Apify Store Analyzer](https://apify.com/automation-lab/apify-store-analyzer) — Analyze Apify actor performance, pricing, and reviews
- [ArXiv Scraper](https://apify.com/automation-lab/arxiv-scraper) — Research academic papers related to your open-source domain
- [Bing Search Scraper](https://apify.com/automation-lab/bing-search-scraper) — Search the web via Bing for projects, funding pages, and more
- [JSON Schema Generator](https://apify.com/automation-lab/json-schema-generator) — Generate JSON schemas from sample data
- [Caniuse Browser Compatibility Checker](https://apify.com/automation-lab/caniuse-browser-compatibility-checker) — Check browser support for web APIs
- [Broken Link Checker](https://apify.com/automation-lab/broken-link-checker) — Find broken links in documentation sites
- [Color Contrast Checker (WCAG)](https://apify.com/automation-lab/color-contrast-checker) — Validate accessibility of design systems

# Actor input Schema

## `collectiveSlugs` (type: `array`):

Enter Open Collective slugs to scrape. The slug is the part after opencollective.com/ in the URL. Example: for https://opencollective.com/webpack the slug is 'webpack'.

## `dataTypes` (type: `array`):

Select which data types to extract. Options: collective (details & stats), members (backers & contributors), transactions (financial history), expenses (approved payments). Example: \["collective", "members"].

## `maxMembers` (type: `integer`):

Maximum number of members/backers to fetch per collective. Set to 0 for all.

## `maxTransactions` (type: `integer`):

Maximum number of transactions to fetch per collective. Set to 0 for all.

## `maxExpenses` (type: `integer`):

Maximum number of expenses to fetch per collective. Set to 0 for all.

## `memberRoles` (type: `array`):

Filter members by role. Leave empty to fetch all roles. Valid values: BACKER, MEMBER, ADMIN, HOST, CONTRIBUTOR, ATTENDEE.

## `transactionTypes` (type: `array`):

Filter transactions by type. Leave empty for all. Valid values: CREDIT (incoming), DEBIT (outgoing).

## Actor input object example

```json
{
  "collectiveSlugs": [
    "webpack",
    "babel"
  ],
  "dataTypes": [
    "collective",
    "members"
  ],
  "maxMembers": 20,
  "maxTransactions": 20,
  "maxExpenses": 20,
  "memberRoles": [],
  "transactionTypes": []
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "collectiveSlugs": [
        "webpack",
        "babel"
    ],
    "dataTypes": [
        "collective",
        "members"
    ],
    "maxMembers": 20,
    "maxTransactions": 20,
    "maxExpenses": 20,
    "memberRoles": [],
    "transactionTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/open-collective-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 = {
    "collectiveSlugs": [
        "webpack",
        "babel",
    ],
    "dataTypes": [
        "collective",
        "members",
    ],
    "maxMembers": 20,
    "maxTransactions": 20,
    "maxExpenses": 20,
    "memberRoles": [],
    "transactionTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/open-collective-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 '{
  "collectiveSlugs": [
    "webpack",
    "babel"
  ],
  "dataTypes": [
    "collective",
    "members"
  ],
  "maxMembers": 20,
  "maxTransactions": 20,
  "maxExpenses": 20,
  "memberRoles": [],
  "transactionTypes": []
}' |
apify call automation-lab/open-collective-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Collective Scraper",
        "description": "Scrape Open Collective: collective details, backers, transactions, and expenses via the public GraphQL API. No auth required. Export to JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "TXs2MAhkmGfqhm5Um"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~open-collective-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-open-collective-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~open-collective-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-open-collective-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~open-collective-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-open-collective-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": [
                    "collectiveSlugs"
                ],
                "properties": {
                    "collectiveSlugs": {
                        "title": "🔍 Collective Slugs",
                        "type": "array",
                        "description": "Enter Open Collective slugs to scrape. The slug is the part after opencollective.com/ in the URL. Example: for https://opencollective.com/webpack the slug is 'webpack'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataTypes": {
                        "title": "📊 Data to Extract",
                        "type": "array",
                        "description": "Select which data types to extract. Options: collective (details & stats), members (backers & contributors), transactions (financial history), expenses (approved payments). Example: [\"collective\", \"members\"].",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "collective",
                            "members"
                        ]
                    },
                    "maxMembers": {
                        "title": "Max members per collective",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of members/backers to fetch per collective. Set to 0 for all.",
                        "default": 100
                    },
                    "maxTransactions": {
                        "title": "Max transactions per collective",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of transactions to fetch per collective. Set to 0 for all.",
                        "default": 100
                    },
                    "maxExpenses": {
                        "title": "Max expenses per collective",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of expenses to fetch per collective. Set to 0 for all.",
                        "default": 100
                    },
                    "memberRoles": {
                        "title": "Member roles to include",
                        "type": "array",
                        "description": "Filter members by role. Leave empty to fetch all roles. Valid values: BACKER, MEMBER, ADMIN, HOST, CONTRIBUTOR, ATTENDEE.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "transactionTypes": {
                        "title": "Transaction types to include",
                        "type": "array",
                        "description": "Filter transactions by type. Leave empty for all. Valid values: CREDIT (incoming), DEBIT (outgoing).",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```