# GitHub Contributor Email Scraper (`fetch_cat/github-contributor-email-scraper`) Actor

Export public GitHub commit-author emails, contributor identity fields, timestamps, and commit evidence from repositories or organizations.

- **URL**: https://apify.com/fetch_cat/github-contributor-email-scraper.md
- **Developed by:** [Fetch Cat](https://apify.com/fetch_cat) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 8 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 contributor email rows

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Export public GitHub commit-author emails with the repository, commit URL, timestamp and linked profile when available. GitHub Contributor Email Scraper turns public commit metadata into rows you can review, download or pass to your own reporting workflow.

Start with a repository list or a GitHub organization. This is public commit evidence, not private-email discovery or mailbox verification. A commit email does not imply consent to contact its author.

### Quick start

1. Add a public repository such as `apify/crawlee`.
2. Start with 20 commits per repository. No GitHub token is needed for a small REST lookup.
3. Click **Start**, then open the dataset to inspect the returned rows.

```json
{
  "repositories": ["apify/crawlee"],
  "maxCommitsPerRepo": 20,
  "includeNoreplyEmails": false,
  "dedupeByEmail": true,
  "apiMode": "auto"
}
```

The limit counts commits inspected, not guaranteed unique emails. Noreply filtering, missing emails and repeated authors can leave fewer rows or an empty dataset.

Prefer a video guide? This short Apify walkthrough shows you how to set up and run an Actor. It uses a different Actor, but the setup steps are the same.

https://youtu.be/1OW8gOqlZbY?t=25

### Ready-to-run examples

Choose a small, preconfigured input:

- [Extract public contributor emails from Apify Crawlee](https://apify.com/fetch_cat/github-contributor-email-scraper/examples/github-crawlee-contributor-emails) — Start with one repository and a unique-email list.
- [Scan a GitHub organization](https://apify.com/fetch_cat/github-contributor-email-scraper/examples/github-organization-contributor-emails) — Discover a bounded set of public repositories.
- [Export commit-level author evidence](https://apify.com/fetch_cat/github-contributor-email-scraper/examples/github-commit-evidence-no-dedupe) — Keep separate commit records instead of one row per email.

### What you get

- **Public author metadata:** Email and author name stored on a commit, plus a linked GitHub account when available.
- **Reviewable evidence:** Repository, commit SHA, source URL and timestamp for every row.
- **Repository or organization input:** Review selected projects or a bounded set of public organization repositories.
- **Contact list or commit evidence:** Exclude noreply addresses for a narrower list, or keep them and disable email deduplication for an audit.

### Who is it for?

Developer-relations and open-source teams can review contributors to projects they work with. Maintainers and security analysts can retain commit evidence for repository audits. Data teams can combine exported rows with their own approved contributor records.

The scraper collects the public metadata. Contribution scoring, identity verification, outreach decisions and comparisons between runs belong in your downstream workflow.

### Practical workflows

#### Audit public commit-author evidence

Use one known repository with `maxCommitsPerRepo` set to 20 and select the intended branch when needed. Set `dedupeByEmail` to false for commit-level evidence. Keep `commitSha`, `commitUrl`, `committedAt` and `authorEmail` together in your audit spreadsheet, then review the linked public commits. A commit email is source evidence, not proof of account ownership, permission to contact someone or deliverability.

#### Inspect a small organization sample

Set `organization`, `maxRepositories: 2` and `maxCommitsPerRepo: 10` to bound repository discovery and commit inspection. Keep repository names with the returned rows and use your own workflow to compare later exports. An organization sample is not an exhaustive contributor directory, and email deduplication can retain only the first eligible evidence row.

### Input settings

| Setting | API key | Description |
| --- | --- | --- |
| Repository URLs | `repositoryUrls` | Up to 100 public GitHub repository URLs. |
| Repository names | `repositories` | Up to 100 `owner/repo` values or full repository URLs. |
| Organization login | `organization` | Optional GitHub organization login or profile URL. |
| Maximum organization repositories | `maxRepositories` | Public organization repositories to discover, from 1 to 100. Default: 20. |
| Maximum commits per repository | `maxCommitsPerRepo` | Recent commits inspected per repository, from 1 to 1,000. Default: 20. |
| Since date | `since` | Optional ISO date or timestamp lower bound. |
| Until date | `until` | Optional ISO date or timestamp upper bound. |
| Branch | `branch` | Optional branch name. Blank uses each repository's default branch. |
| Include noreply emails | `includeNoreplyEmails` | Keep GitHub noreply addresses. Default: false. |
| Deduplicate by email | `dedupeByEmail` | Save the first row for each email across the run. Default: true. |
| GitHub API mode | `apiMode` | `auto`, `rest`, or `graphql`. Default: auto. |
| Maximum active run seconds | `maxRunSeconds` | Optional active-work cutoff from 1 to 270 seconds. Pending work is checkpointed. |
| GitHub token | `githubToken` | Optional secret token for GraphQL and higher GitHub limits. Public-repository read access is sufficient. |

At least one repository input or an organization is required. The form examples are prefills, not API defaults. Invalid hosts, malformed repository names, invalid dates and unsafe branch names are rejected before work starts.

`apiMode: "auto"` uses GraphQL when a GitHub token is available and REST otherwise. Choose `rest` to use REST with or without a token. Choose `graphql` only with a token. No proxy setting is offered.

Use `since` and `until` for a date window and `branch` for a known branch. `maxRepositories` limits organization discovery only. Explicit repositories and discovered repositories are merged, with explicit input taking precedence on overlap.

With `dedupeByEmail: true`, the first eligible row per case-insensitive email is saved across the run. Disable it for commit-level evidence. Set `includeNoreplyEmails: true` when privacy-protecting GitHub addresses are useful for your audit.

#### Example input: recent public commits

```json
{
  "repositories": ["apify/crawlee"],
  "since": "2026-01-01",
  "maxCommitsPerRepo": 20,
  "includeNoreplyEmails": true,
  "dedupeByEmail": false
}
```

### Output data

| Field | Type | Description |
| --- | --- | --- |
| `repository` | string | Canonical `owner/repo`. |
| `owner` | string | Repository owner login. |
| `repo` | string | Repository name. |
| `commitSha` | string | Git commit object ID. |
| `commitUrl` | string | Public source commit URL. |
| `authorName` | string or null | Author name stored in the commit. |
| `authorEmail` | string | Author email stored in the public commit. |
| `isNoreplyEmail` | boolean | Whether the address is a GitHub noreply address. |
| `githubLogin` | string or null | Linked GitHub login when available. |
| `profileUrl` | string or null | Linked public GitHub profile URL. |
| `committedAt` | string or null | Commit author timestamp. |
| `messageSnippet` | string or null | First 240 normalized characters of the commit message. |
| `sourceType` | string | `repository` or `organization`. |
| `scrapedAt` | string | Row-save timestamp. |
| `apiMode` | string | `rest` or `graphql`. |

Illustrative shape only, not a scraped record:

```json
{
  "repository": "apify/crawlee",
  "owner": "apify",
  "repo": "crawlee",
  "commitSha": "example-sha",
  "commitUrl": "https://github.com/apify/crawlee/commit/example-sha",
  "authorName": "Example Developer",
  "authorEmail": "dev@example.com",
  "isNoreplyEmail": false,
  "githubLogin": null,
  "profileUrl": null,
  "committedAt": "2026-01-01T12:00:00Z",
  "messageSnippet": "Improve retry handling",
  "sourceType": "repository",
  "scrapedAt": "2026-07-20T12:00:00Z",
  "apiMode": "graphql"
}
```

Every dataset row keeps a commit URL and SHA so you can review the public source evidence.

After repository processing, `RUN_SUMMARY` in the run's key-value store reports saved rows, inspected commits, exclusions and repository failures. It is not guaranteed for failures before repository processing begins. Completed rows remain available if a later repository fails. `PENDING_WORK` retains unfinished work after a cutoff and is cleared when processing completes.

#### Download your results

Open your run's dataset, choose **Export** and select JSON, CSV or Excel. JSON keeps nested fields together. CSV and Excel are useful when you want to review the records in a spreadsheet.

See [Apify's download and export guide](https://docs.apify.com/storage/dataset#apify-console) for the available formats and field options.

### Pricing

This Actor uses pay-per-event pricing. The `start` event is charged once after valid input, including runs that later return no rows or encounter a repository failure.

The `item` event is charged per saved contributor-email row. Filtered commits, duplicate rows, missing-email records, repository errors and summary records are not charged as items. Commit limits bound the work inspected rather than promising a particular number of saved rows.

See the [live Pricing tab](https://apify.com/fetch_cat/github-contributor-email-scraper/pricing) for current rates and discounts. Apify platform usage may be charged separately.

### Tips for best results

- **Start with one repository.** Inspect a small result before expanding the repository list or commit limit.
- **Choose the evidence you need.** Keep email deduplication for a unique-address list, or turn it off for commit-level records.
- **Check the summary.** Review repository errors and exclusions before treating a multi-repository result as complete.
- **Use a token for larger jobs.** GitHub's authenticated limits can help, but do not guarantee unlimited access.
- **Set a date window.** Use `since` and `until` to focus a repeat export, then compare records in your own workflow.

### Limits and caveats

- Only public repository metadata is supported. The Actor does not discover hidden emails or access private repositories.
- GitHub can omit a linked login or profile even when a commit contains an author name and email. An email may be outdated or undeliverable.
- Noreply addresses protect contributors' contact details. Public availability is not permission for unsolicited messaging.
- Rate limits, unavailable branches and repository failures can limit coverage. A cutoff fails the run while preserving completed output and pending work.
- A valid date window with no commits, or commits with no included emails, can succeed with zero rows. If every repository fails, the current implementation fails the run. Check `RUN_SUMMARY` when available.
- Git history can change. The Actor does not provide contributor rankings, mailbox checks or built-in change detection.

### Automation and integrations

#### Save your settings for next time

Once you have an input that works for you, [save it as an Apify task](https://docs.apify.com/actors/running/tasks). This keeps your settings together so you can use them again without filling in the form from scratch.

#### Run on a schedule

Need fresh results regularly? You can [schedule the Actor or a saved task](https://docs.apify.com/actors/running/schedules) to run at a time that suits you.

Each scheduled run collects the data again. If you want to compare results or highlight changes, add that step in your own workflow.

#### Send results to your other tools

Use **n8n, Make or Zapier** to connect this scraper to the rest of your workflow. For example, you could pass its results to an AI assistant or add records to a spreadsheet. Follow the [Apify integration guides](https://docs.apify.com/integrations) for your chosen tool.

For a custom connection, an [Apify webhook](https://docs.apify.com/integrations/webhooks) can notify your app when a run finishes or fails. Your app can then fetch the results or handle the failure.

### API usage

Want to collect this data from your own app or automation? The examples below send input to the scraper and show how to collect its results.

The Node.js and Python examples wait for the run to finish before reading its results. The cURL example starts the run and returns its details. Wait for that run to finish, then use its `defaultDatasetId` to fetch the results.

For setup instructions, see Apify's [JavaScript client guide](https://docs.apify.com/api/client/js), [Python client guide](https://docs.apify.com/api/client/python) and [Actor runs API reference](https://docs.apify.com/api/v2/acts-runs-post).

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/fetch_cat~github-contributor-email-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "repositories": ["apify/crawlee"],
    "maxCommitsPerRepo": 20,
    "apiMode": "rest"
  }'
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/github-contributor-email-scraper').call({
  repositories: ['apify/crawlee'],
  maxCommitsPerRepo: 20,
  includeNoreplyEmails: false,
  dedupeByEmail: true,
  apiMode: 'auto',
  githubToken: process.env.GITHUB_TOKEN
});

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

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])

run = client.actor("fetch_cat/github-contributor-email-scraper").call(run_input={
    "repositories": ["apify/crawlee"],
    "maxCommitsPerRepo": 20,
    "includeNoreplyEmails": False,
    "dedupeByEmail": True,
    "apiMode": "rest",
})

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

### MCP and AI agents

You can ask your AI assistant to collect data with **GitHub Contributor Email Scraper** and help you work with the results. The scraper returns the data, and your assistant can then summarize it, compare records or prepare notes.

Connect your assistant through the [Apify MCP server](https://mcp.apify.com/). MCP gives your assistant a way to find this scraper, run it and read the results. Follow the [official setup and sign-in guide](https://docs.apify.com/mcp) for your app.

#### Easier setup with an Apify plugin

If you use a supported coding assistant, the [official Apify plugin](https://docs.apify.com/agents/plugins) can set up the connection for you. It connects your assistant to Apify and includes instructions for common tasks. Follow the guide for your particular app.

#### Use Apify AI in Console

Prefer to keep everything in Apify? Open [Apify AI in Console](https://docs.apify.com/account/apify-ai) and ask it to find Fetch Cat's **GitHub Contributor Email Scraper**. You can describe the data you want and ask questions about the results.

Apify AI is currently in beta. It asks for confirmation before starting an Actor, and normal run charges apply.

#### Choose your assistant

- **Claude and Claude Code (Anthropic):** [Apify setup guide](https://docs.apify.com/integrations/claude).
- **ChatGPT and Codex (OpenAI):** [Apify setup guides](https://docs.apify.com/integrations/openai).
- **Grok Bot (xAI):** [Apify plugin guide](https://docs.apify.com/integrations/grok-bot).
- **Gemini CLI (Google):** [MCP server setup guide](https://geminicli.com/docs/tools/mcp-server/). Use the server URL below with the HTTP configuration supported by Gemini CLI.

#### Connect just this scraper

To keep your setup focused on this scraper, add this server configuration to a compatible MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/github-contributor-email-scraper"
    }
  }
}
```

Sign in to Apify when your client asks. If your client uses a Bearer token instead, follow its setup guide and keep the token in its secure configuration. Configuration formats vary by app, so use the linked guide if your client needs a different format.

#### Use Apify's general server

Already connected to the general Apify MCP server at `https://mcp.apify.com`? You can use it to find this scraper without adding another server. Ask your assistant to use **GitHub Contributor Email Scraper** by Fetch Cat, or give it the identifier `fetch_cat/github-contributor-email-scraper`.

Your assistant can check the available settings and retrieve the results from the returned run. If the run is still working, it should follow that run rather than start it again. Both connection options use Apify's hosted service.

#### Example requests

- “Inspect up to 20 recent public commits from apify/crawlee and help me review the returned author-email records and linked commit evidence.”
- “Use maxRepositories 2 and maxCommitsPerRepo 10 for the public Apify organization, then summarize which repositories appear in the returned author records.”
- “Inspect up to 10 recent commits from apify/crawlee, including noreply addresses, then help me prepare a spreadsheet of the returned evidence for a repository audit.”

Normal Apify charges apply. Check the [live Pricing tab](https://apify.com/fetch_cat/github-contributor-email-scraper/pricing) before asking your assistant to run a larger batch.

### Pay with x402

If your AI agent has a funded wallet, it can pay for Apify usage through [x402](https://docs.apify.com/integrations/x402). This experimental option lets an agent use Apify without a conventional account.

[Apify AGI](https://agi.apify.com/) provides a prepaid API token with a spending cap after payment. Your agent can use that token to run this scraper through the Apify API or an authenticated MCP connection.

Some MCP setups also support paying for each request directly. That is a different payment option, so check the official guide for its availability.

Follow the official guide for wallet setup, supported payment options and current terms. Apify handles the payments. Keep wallet keys and payment tokens in your agent's secure configuration.

#### Other ways for agents to pay

Apify also supports **MPP** for prepaid access through AGI and **Skyfire** for eligible Actors. If your agent already uses one of these, see the [agentic payment guide](https://docs.apify.com/agents/payments) to choose the right setup.

### FAQ

#### Does it require a GitHub token?

Small public REST lookups can run without one. GraphQL requires a token. Automatic mode uses GraphQL when a token is available and REST otherwise.

#### Can it find a contributor's private email?

No. It returns the author email recorded on a public commit. Linked account details can be null, and the email is not checked for deliverability.

#### Can it scan an entire organization?

It discovers up to 100 public repositories per run. The default discovery limit is 20. Explicit repositories can also be supplied, and `maxCommitsPerRepo` limits inspected commits in each repository.

#### Why are there fewer emails than commits?

Several commits can share an author email. The default email deduplication saves the first eligible match. Missing emails and noreply filtering can reduce the result further.

#### Why did it return zero rows?

The date window may have no matching commits, or the inspected commits may have no included emails. Review `RUN_SUMMARY.emptyReason` when present. A repository failure is different from a completed lookup with no matching rows.

#### Can I export CSV or call it from an AI assistant?

Yes. Download the dataset as CSV, Excel or JSON, or retrieve it through the API and MCP setup above. An assistant can analyze the returned records afterward.

#### What happens if one repository fails?

Completed output is retained and repository errors appear in `RUN_SUMMARY` when processing reaches summary creation. If all repositories fail or unfinished work reaches the active-work cutoff, the run fails. A partial multi-repository dataset is not proof of complete coverage.

### Related Actors

- [GitHub Profile Scraper](https://apify.com/fetch_cat/github-profile-scraper) — Collect public GitHub profile details for known users alongside commit-author evidence.
- [GitHub Repositories Search Scraper](https://apify.com/fetch_cat/github-repositories-search-scraper) — Discover public repositories and available repository metadata from search queries.
- [GitHub Issues and Pull Requests Scraper](https://apify.com/fetch_cat/github-issues-pull-requests-scraper) — Collect public issue and pull-request records for repository research.
- [Website Contact Finder](https://apify.com/fetch_cat/website-contact-finder) — Find publicly displayed contact details with source-page evidence on selected websites.
- [Bulk URL Status Checker](https://apify.com/fetch_cat/bulk-url-status-checker) — Check supplied URLs for HTTP status, redirects and available page metadata.

### Support and feedback

For custom additions or integrations, email <hello@fetchcat.dev>.

Found an error or have a feature request? [Open an issue](https://apify.com/fetch_cat/github-contributor-email-scraper/issues) with the run URL, a non-sensitive input example and what you expected.

Need help sharing it? See [Apify’s guide to sharing a run when reporting an issue](https://docs.apify.com/account/collaboration/general-resource-access#automatically-sharing-runs-via-actor-issues). Sharing a run can give the developer access to its input, logs and results, so use a run that contains no sensitive data. Please leave out API tokens, passwords, cookies, private documents and personal data. Use a public sample URL or a redacted example instead.

Tried this scraper? We'd love to hear how it worked for you. [Leave a review from the Actor page](https://apify.com/fetch_cat/github-contributor-email-scraper) to help others choose the right tool and help us improve it. Your feedback means a lot to us.

Made with care for curious people, AI agents and the possibilities in data. ♥

# Changelog

This Actor's version history is a separate document: https://apify.com/fetch_cat/github-contributor-email-scraper/changelog.md

# Actor input Schema

## `repositoryUrls` (type: `array`):

Public GitHub repository URLs, for example https://github.com/apify/crawlee. Up to 100 entries.

## `repositories` (type: `array`):

Public repositories as owner/repo values or full GitHub URLs. Up to 100 entries.

## `organization` (type: `string`):

Optional GitHub organization login or profile URL. Public repositories are added to the explicit repository list.

## `maxRepositories` (type: `integer`):

Maximum public repositories to discover from the organization. Explicit repository inputs are not counted against this limit.

## `includeNoreplyEmails` (type: `boolean`):

Keep GitHub privacy-protecting noreply addresses in the dataset. Disabled by default.

## `dedupeByEmail` (type: `boolean`):

Save only the first commit row for each email across all repositories. Disable for commit-level evidence.

## `maxCommitsPerRepo` (type: `integer`):

Maximum recent commits inspected in each repository. Use a small value for tests and up to 1,000 for deeper coverage.

## `since` (type: `string`):

Optional ISO date or timestamp. Only commits on or after this time are inspected.

## `until` (type: `string`):

Optional ISO date or timestamp. Only commits on or before this time are inspected.

## `branch` (type: `string`):

Optional branch name such as main or release/v1. Leave empty to use each repository's default branch.

## `apiMode` (type: `string`):

Auto uses GraphQL when a token is available and REST otherwise. Choose REST or GraphQL to force a route; GraphQL requires a token.

## `maxRunSeconds` (type: `integer`):

Optional active-work budget before the Actor checkpoints pending repositories and stops safely. Platform cleanup time is reserved separately.

## `githubToken` (type: `string`):

Optional GitHub token for higher rate limits and GraphQL. Public-repository read access is sufficient; the token is never written to output.

## Actor input object example

```json
{
  "repositoryUrls": [
    {
      "url": "https://github.com/apify/crawlee"
    }
  ],
  "repositories": [
    "apify/crawlee"
  ],
  "organization": "",
  "maxRepositories": 20,
  "includeNoreplyEmails": false,
  "dedupeByEmail": true,
  "maxCommitsPerRepo": 20,
  "since": "",
  "until": "",
  "branch": "",
  "apiMode": "auto"
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

## `pendingWork` (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 = {
    "repositoryUrls": [
        {
            "url": "https://github.com/apify/crawlee"
        }
    ],
    "repositories": [
        "apify/crawlee"
    ],
    "organization": "",
    "since": "",
    "until": "",
    "branch": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/github-contributor-email-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 = {
    "repositoryUrls": [{ "url": "https://github.com/apify/crawlee" }],
    "repositories": ["apify/crawlee"],
    "organization": "",
    "since": "",
    "until": "",
    "branch": "",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/github-contributor-email-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 '{
  "repositoryUrls": [
    {
      "url": "https://github.com/apify/crawlee"
    }
  ],
  "repositories": [
    "apify/crawlee"
  ],
  "organization": "",
  "since": "",
  "until": "",
  "branch": ""
}' |
apify call fetch_cat/github-contributor-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,fetch_cat/github-contributor-email-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/LDpNlPzaCotpWp9SH/builds/E8kgOlvYpl7Zyhhcd/openapi.json