# GitHub Profile Scraper — Public Emails & Developer Leads (`apivault_labs/github-profile-scraper`) Actor

Collect public GitHub profiles and repository audiences with published contacts and source-qualified leads. Bulk export: JSON, CSV, Excel and API. PPE: $1.9/1K profile results; start fee, usage extra.

- **URL**: https://apify.com/apivault_labs/github-profile-scraper.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** Social media, Developer tools, Lead generation
- **Features:** Limited permissions
- **Stats:** 100 total users, 15 monthly users, 99.4% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 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.

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

## GitHub Profile Scraper & Lead Finder

![GitHub Profile Intelligence — Discover, Qualify, Export](https://api.apify.com/v2/key-value-stores/u4YZtIlXXYEybGzl4/records/github-profile-intelligence-hero-v1.png)

![Apify Actor](https://img.shields.io/badge/Apify-Actor-00bcd4)
![Price](https://img.shields.io/badge/Price-%241.90%20per%201K-6f63ff)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-24b3b3)

Turn public GitHub profiles, repository audiences, and organization members into structured developer research records.

Collect identity and activity signals, compare public repositories and languages, qualify profiles with optional research scores, and export the results for recruiting, community analysis, or responsible B2B research.

### MCP and AI agents

Use this Actor for public GitHub profile research and available repository or organization audiences. Start with one explicitly selected username.

Select `apivault_labs/github-profile-scraper` in the Actor's **API → MCP** tab, or connect an authenticated
MCP client to:

```text
https://mcp.apify.com/?tools=apivault_labs/github-profile-scraper
```

The direct tool is **`apivault_labs--github-profile-scraper`**. Keep the Apify token in the client's secure
authentication configuration. Public source data does not remove the requirement
for Apify authentication and applicable run charges. Read `tools/list` before
calling: wrapper fields can differ from the Actor input schema.

Small Actor input:

```json
{
  "profileUrls": [
    "octocat"
  ],
  "extractRepos": false,
  "includeLanguageStats": false,
  "includeLeadScore": false
}
```

Send this object as the direct tool's arguments. Its current wrapper also accepts
`waitSecs: 45`. `waitSecs` controls how long the tool waits; it is not the Actor
run timeout. If the run is still active, poll its returned run ID with
`get-actor-run`; do not start a duplicate. Once terminal, use
`get-dataset-items` with the returned dataset ID and a small limit/field selection,
then `get-key-value-store-record` with the returned store ID and required record
key. Missing IDs/records must be reported, not replaced with another run's storage.

Read profile rows, `SUMMARY` and `ERRORS`. `PARTIAL`, `sourceErrors`, `enrichmentWarnings`, `deferred` and `deferredSources` mean some research remains incomplete. `EMPTY` can follow filters; missing public contacts are not verified absence of contacts. Repository aggregates describe a configured sample, not all-time contribution totals. Stargazer access requires repository permissions; do not promise arbitrary competitor audiences. If present, `RETRY_INPUT` contains deferred work; inspect it and rerun only when needed, supplying authorized secrets from your configuration rather than public output.

Agent request: “Research the public octocat profile with optional enrichment disabled. Return its profile URL and available fields, then check SUMMARY and ERRORS.”

Keep the first run small. Increase limits only for the requested scope, check
current Pricing and cap runtime/spend using controls actually supported by your
run client. Distinguish source errors, filtered emptiness and partial delivery;
a completed tool call alone does not establish successful data collection.

### Choose your workflow

#### Profile research

Provide GitHub usernames or profile URLs to collect structured public profile data.

#### Repository audience research

Provide repository URLs to discover available contributors (default) or forkers and enrich each username into a profile record. Stargazer listings require an authorized token and repository access. Results depend on your limit and source availability.

#### Organization research

Provide organization names or URLs to collect publicly listed members and compare their profile signals.

You can combine all three workflows in one run. Duplicate usernames are merged automatically.

### Data you can collect

| Category | Example fields |
|---|---|
| Identity | `username`, `fullName`, `bio`, `company`, `location`, `profileUrl` |
| Public contact | `email`, `website`, `twitterUsername`, `linkedin`, `socialAccounts` |
| Profile metrics | `followers`, `following`, `publicRepos`, `accountAgeYears` |
| Repository signals | `totalStars`, `totalForks`, `topLanguages`, `mostStarredRepo` |
| Optional sections | repositories, organizations, starred projects, profile README, pinned repositories, achievements, contributions |
| Research fields | `developerTier`, `activityStatus`, `leadScore`, `leadTier`, `leadReasons` |
| Audience source | repository, organization, and source type when using discovery modes |

Only data available for the selected public profile and enabled options is returned. Missing contact or activity fields are not fabricated.

### Reliability and incomplete results

Each profile and each repository/organization discovery source has a `profileTimeout` budget (90 seconds by default). If optional enrichment fails or reaches that budget after the identity was collected, the Actor returns the valid core profile with `enrichmentWarnings`. Missing repository metrics are unavailable, not invented zeros; a positive `minStars` filter defers an unresolved profile instead of claiming it failed the threshold. No result event is charged for that deferred profile.

`SUMMARY` in the run's key-value store distinguishes `SUCCEEDED`, `PARTIAL`, `EMPTY`, and `FAILED`, with failed profiles, audience source errors and `profilesWithEnrichmentWarnings`. Successful platform status can therefore include a `PARTIAL` summary. Failed profiles are listed in `ERRORS` and are not exported or charged as result rows.

Before the platform time limit, the Actor stops starting new work and saves unstarted profiles and discovery sources as `RETRY_INPUT`. Start a new run with that input to continue; add your token, cookies or custom proxy settings again if needed, since credentials are excluded. This continuation is manual and does not automatically launch or charge another run. Use a run timeout of at least 120 seconds for useful collection; very short runs can return only continuation input. A discovery deadline retains completed pages but does not automatically resume the remaining pages of that source. Increase `profileTimeout` and run timeout if you need a larger audience.

A nonexistent/suspended profile, invalid token, GitHub access restriction or rate limit can still prevent collection. An authorized token is required for restricted stargazer discovery; proxy changes do not grant repository permissions.

### Quick start

#### Collect specific profiles

```json
{
  "profileUrls": [
    "https://github.com/torvalds",
    "octocat"
  ],
  "extractRepos": true,
  "includeSocialAccounts": true,
  "includeLeadScore": true
}
```

#### Research a repository audience

```json
{
  "repoUrls": ["https://github.com/octocat/Hello-World"],
  "repoLeadsSource": "contributors",
  "maxLeadsPerRepo": 100,
  "minLeadScore": 40
}
```

#### Research public organization members

```json
{
  "orgUrls": ["apify"],
  "minFollowers": 10,
  "exportFormat": "csv"
}
```

### Example output

This example is fictional and illustrates the typical structure. Actual fields vary by profile and selected options.

```json
{
  "success": true,
  "username": "maya-chen-example",
  "fullName": "Maya Chen",
  "bio": "Software engineer building developer tools",
  "company": "Northstar Labs",
  "location": "Toronto, Canada",
  "followers": 3856,
  "following": 142,
  "publicRepos": 42,
  "accountAgeYears": 8.4,
  "developerTier": "established",
  "activityStatus": "active",
  "totalStars": 12734,
  "totalForks": 982,
  "topLanguages": ["Python", "TypeScript", "Go"],
  "mostStarredRepo": {
    "name": "signal-kit",
    "stars": 4210
  },
  "leadScore": 82,
  "leadTier": "hot",
  "leadReasons": [
    "strong public project signals",
    "active developer profile",
    "established account"
  ],
  "leadSource": {
    "type": "stargazers",
    "repo": "example-org/example-repo"
  }
}
```

### Optional profile depth

Keep runs lightweight or enable only the sections you need:

- Repository aggregates and an optional full repository list.
- Language distribution across sampled public repositories.
- Public social accounts and organizations.
- A sample of starred repositories.
- Profile README and pinned repositories.
- Public achievements and recent contribution signals.
- Optional public contact discovery and basic email-domain checks.

Deeper options can require more requests and may reduce throughput. Start with the default profile fields, then enable additional sections for shortlisted profiles.

### Understanding the research score

`leadScore` is an optional 0–100 prioritization aid based on available public profile and repository signals. `leadReasons` explains the high-level factors present in a result.

The score is not a measure of personal worth, job performance, identity, financial capacity, or legal eligibility. Do not use it as the sole basis for employment, credit, housing, insurance, education, or other high-impact decisions. Review relevant profiles manually and apply your own documented criteria.

### Collection limits and diagnostics

This Actor requires authorized repository access for its restricted stargazer workflow. Select contributors/forkers for supported public audience research, or supply a token with the required repository access for stargazers. Do not assume that anonymous access or proxy changes grant those permissions. See [GitHub access restrictions](https://docs.github.com/en/rest/activity/starring#new-access-restrictions).

Profiles and repositories are validated as GitHub identifiers/URLs and deduplicated without case sensitivity. Whitespace, commas and semicolons can separate multiple values. No GitHub token is required; public rate limits still apply. An optional token can improve capacity. Proxy rotation does not guarantee unlimited throughput.

Repository metrics use one page of up to `maxRepos` public repositories (maximum 100), sorted by most recently updated. `totalStars`, `totalForks`, `mostStarredRepo`, language and activity signals refer to that sample. Inspect `reposSampled`, `repositorySampleLimit`, `repositorySampleComplete` and `repositoryMetricsScope`. The legacy `firstCommitYear` field estimates the earliest sampled repository/account creation year, not a verified first commit.

`SUMMARY` is written even when output is empty: delivered/failed/filtered counts, discovery errors and `SUCCEEDED`, `PARTIAL`, `EMPTY` or `FAILED`. `ERRORS` records profile failures without paid error rows. A run fails if all attempted profiles fail. Filtered empty results succeed. Successful rows in mixed runs are retained and billed once. Source errors after an audience page are reported rather than treated as complete coverage.

Billing: $0.0019 per successfully exported profile plus the $0.00005 start event and platform/proxy usage. Failed profiles and filtered results do not incur result events. Contact fields depend on source availability. `enrichmentWarnings` identifies unavailable repository aggregation; other optional sections may be missing or empty when not exposed by the source.

### Filters

Filter before saving results with:

- `minLeadScore`
- `minFollowers`
- `minRepos`
- `minStars`
- `hireableOnly`
- `withEmailOnly`

Filters depend on the corresponding field being available. For example, a stars filter requires repository aggregation.

### Exports and automation

Results are saved to the run's Apify Dataset and can be downloaded as JSON, CSV, Excel, XML, or RSS. Use `exportFormat: "csv"` for a flatter row designed for spreadsheet and CRM workflows.

For n8n, use the community package [`n8n-nodes-apivault-github`](https://www.npmjs.com/package/n8n-nodes-apivault-github) to start the Actor and pass dataset results to the next workflow step.

### Pricing

The active result price is **$0.0019 per successfully collected profile**:

| Successful profiles | Result charge |
|---:|---:|
| 1 | $0.0019 |
| 100 | $0.19 |
| 1,000 | $1.90 |
| 10,000 | $19.00 |

Apify platform usage and a small Actor Start charge may apply according to the pricing shown before each run. Profiles excluded by filters or unsuccessful lookups are not billed as successful result events.

### FAQ

#### Are email and LinkedIn guaranteed?

No. Contact fields are returned only when a public source exposes them. Many developers intentionally keep these fields private.

#### Can I collect every stargazer, forker, contributor, or organization member?

The Actor collects the available audience up to your configured limit. Results can vary because profiles may be private, removed, duplicated, unavailable, or excluded by filters.

#### Do I need a GitHub token?

Not for small public-profile runs. An optional read-only token can provide higher authorized request limits for larger workloads. Use the minimum permissions required and never paste credentials into logs or support messages.

#### What does `totalStars` mean?

It is aggregated across the public repositories included in the configured sample, not necessarily every repository ever associated with the account.

#### Can I use the results for outreach?

Use public contact information responsibly. Respect consent, opt-outs, applicable privacy and anti-spam laws, platform terms, and reasonable contact frequency. Avoid bulk unsolicited messaging.

### Responsible use

- Collect only the fields needed for a legitimate purpose.
- Do not attempt to identify private individuals or infer sensitive traits.
- Do not use the output for harassment, surveillance, credential attacks, or automated spam.
- Secure exported contact data and delete it when no longer needed.
- Follow GitHub's terms and applicable privacy laws, including GDPR and CCPA where relevant.

### Support

Open an issue on the Actor page with a sample input and run ID. Remove API tokens, cookies, private contact lists, and other secrets before sharing diagnostics.

GitHub is a trademark of GitHub, Inc. This Actor is an independent tool and is not affiliated with or endorsed by GitHub.

### Developer and community research with an explicit scope

Choose the public professional question you intend to investigate:
inspect a known account, review a small repository audience, or compare
available public project signals. Collect only the fields needed for
that question. A public developer profile is not a verified personal
identity, complete CV or measure of job performance.

| Research task | First configuration | Preserve with the result |
| --- | --- | --- |
| Inspect one known account | Core profile, optional depth off | Username, profile URL and source status |
| Review recent public projects | Explicit small maxRepos | Sample size and repositoryMetricsScope |
| Study a repository community | Authorized supported audience and a small limit | Audience source and incomplete-source diagnostics |
| Prepare a spreadsheet review | CSV export with unnecessary sections off | Profile identity and evidence scope |
| Investigate available contact routes | Only published evidence needed for the task | Missing fields and source warnings |

#### Start with one core public profile

The official example account keeps the first request easy to inspect.
Optional repository aggregation and research scoring are disabled.
A public result does not imply that every contact or social field is
available for other accounts.

```json
{
  "profileUrls": [
    "octocat"
  ],
  "extractRepos": false,
  "includeLanguageStats": false,
  "includeLeadScore": false,
  "includeOutreach": false
}
```

#### Inspect a small recent-repository sample

The configured sample can differ from the profile's publicRepos count.
Stars, forks and languages derived from these repositories describe
that sample rather than every contribution associated with the person.

```json
{
  "profileUrls": [
    "octocat"
  ],
  "extractRepos": true,
  "includeRepoList": true,
  "maxRepos": 5,
  "includeLanguageStats": true,
  "includeLeadScore": false,
  "includeOutreach": false
}
```

#### Export a compact spreadsheet record

CSV flattens supported fields for review. Disabling commit-email
discovery avoids that optional research path. Do not treat a missing
email field as evidence that the account has no contact channel.

```json
{
  "profileUrls": [
    "octocat"
  ],
  "extractRepos": false,
  "includeLeadScore": false,
  "includeOutreach": false,
  "emailFromCommits": false,
  "exportFormat": "csv"
}
```

#### Research a small supported repository audience

Contributors are the explicit audience here. Source permissions and
availability still apply. A maximum of three is a limit, not a promise
of three qualifying profiles or complete repository community coverage.

```json
{
  "repoUrls": [
    "https://github.com/octocat/Hello-World"
  ],
  "repoLeadsSource": "contributors",
  "maxLeadsPerRepo": 3,
  "extractRepos": false,
  "includeLeadScore": false,
  "includeOutreach": false
}
```

### Keep repository and contact observations in context

Profile counts, sampled repository aggregates and recent contribution
signals answer different questions. An unavailable enrichment section
must not become a fabricated zero or a statement about someone's
ability, motivation or employment status. Manual professional review
remains necessary for decisions involving people.

Public contact fields can be intentionally sparse. A profile link,
social account or source-published email is a route to review, not
permission to contact the person or a guaranteed working inbox.
DNS checks do not establish email deliverability. Keep only the
information needed for your legitimate research workflow.

### Source access and secrets in automated research

Small public-profile requests do not require you to provide a GitHub
token. Some audience operations require authorized repository access,
and source rate limits can still affect collection. A proxy change
does not grant permissions. Keep optional tokens and cookies in
private configuration, not shared README examples or support output.

RETRY_INPUT deliberately excludes supplied credentials. If the
continued job requires authorized access, supply the necessary secret
again through your own configuration. Do not publish a filled retry
payload or infer that a redacted continuation contains everything
needed to access a restricted audience.

### Budget and recovery for a profile research file

Active rates checked on 20 October 2026 are **$0.0019 per successfully
delivered profile**, **$0.00005 per start memory unit** with a minimum
of one, and user-paid platform/proxy usage. Five profiles with one
start unit have $0.00955 in event fees. This is an event calculation,
not a measured total-run quote or a promise of five matched accounts.

Deeper repository and contact options can use more requests and time.
Failed or filtered profiles have no successful-profile result event;
their processing can still consume resources. Set a bounded audience,
an appropriate run timeout and a platform spending cap before scaling.

Save completed run and dataset IDs. A download failure should first
be recovered by reading that existing dataset. Repeating collection
is a new run and can bill the same profile again. Manual continuation
collects the deferred scope; it is not a cross-run monitoring database.

### More questions about GitHub profile research

#### Is leadScore an objective measure of developer quality?

No. It is a prioritization heuristic using available signals, not an
assessment of personal worth, job performance or hiring suitability.
Keep the score reasons and apply independent, appropriate review.

#### Can I use the result as a complete contribution history?

No. Enabled sections and available source windows bound the collected
evidence. Repository aggregates refer to the configured sample.

#### Does a successful run mean every optional section succeeded?

No. Check SUMMARY, enrichmentWarnings, sourceErrors and deferred work.
A useful core profile can survive an incomplete optional check.

#### Does this automatically send outreach or notifications?

No. The Actor returns data and optional research fields. Any external
message or notification is a separate action in your own workflow.

### n8n and developer integrations

Use this Actor in your automation or application with the existing community integrations below. An Apify account and API token are required; Actor and platform charges follow the [current pricing](https://apify.com/apivault_labs/github-profile-scraper/pricing).

- **n8n community node:** [n8n-nodes-apivault-github](https://www.npmjs.com/package/n8n-nodes-apivault-github). Install package name `n8n-nodes-apivault-github` in a self-hosted n8n instance that permits community packages.
- **Python client and examples:** [GitHub](https://github.com/apivault-labs/github-profile-scraper-python).
- **n8n source and usage:** [GitHub](https://github.com/apivault-labs/apivault-labs/tree/main/community-nodes/n8n-nodes-apivault-github).

These are community packages. Publication on npm does not establish n8n verification or availability in n8n Cloud. Review the linked package README for supported inputs and setup.

#### Rate-limit diagnostics and repository coverage

A non-rate-limit HTTP403 is an access denial; rotating proxies does not grant permission. On primary or secondary GitHub rate limits, the run stops starting new REST requests and records a safe `rateLimit` object in SUMMARY, including `retryNotBefore` and `retryAfterSeconds`. Already in-flight requests may finish. The Actor defers work instead of ignoring Retry-After or reset headers. Respect the indicated time before using RETRY_INPUT; supply credentials separately. See [GitHub rate-limit guidance](https://docs.github.com/en/rest/using-the-rest-api/rate-limits-for-the-rest-api).

`repositoryMetricsStatus` is `complete`, `truncated`, `unavailable` or `not_requested`; `repositoryMetricsTruncated` flags a capped sample. Existing sample counters and scopes remain available. A sample's observed stars are a lower bound: it can satisfy `minStars`, but an incomplete or unavailable sample below the threshold is unresolved and appears in ERRORS/RETRY_INPUT, without a result fee. A complete sample below the threshold is filtered normally. An account reporting zero public repositories has a known zero, rather than an unavailable aggregation. Retrying incomplete samples with the same maxRepos can remain unresolved; this release does not add full repository pagination.

# Changelog

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

# Actor input Schema

## `profileUrls` (type: `array`):

GitHub profile URLs (https://github.com/NAME) or bare usernames. Leave empty if you only use Repo lead mode below.

## `repoUrls` (type: `array`):

Paste repository URLs (https://github.com/OWNER/REPO or OWNER/REPO). The Actor collects the selected public audience up to your configured limit and creates a profile record for each available username.

## `repoLeadsSource` (type: `string`):

Contributors and forkers are available public audiences. GitHub restricts stargazer listings to repository admins/collaborators and requires an authorized token. Public activity does not prove buying intent.

## `orgUrls` (type: `array`):

Collect publicly listed organization members up to maxLeadsPerRepo. Hidden members are unavailable. Source errors are recorded in SUMMARY.

## `maxLeadsPerRepo` (type: `integer`):

Maximum public audience usernames per repository or organization. Only successfully exported, filter-passing profiles are charged. API limits can restrict availability.

## `extractRepos` (type: `boolean`):

Aggregate one bounded sample of public repositories sorted by most recently updated. Stars, forks and languages apply to this sample, not all repositories. Adds one API call per profile.

## `includeRepoList` (type: `boolean`):

Export the sampled repos array with per-repository fields. Limited by maxRepos; not the complete account history.

## `maxRepos` (type: `integer`):

Cap on repos sampled per user (sorted by stars, GitHub page ceiling = 100).

## `includeLanguageStats` (type: `boolean`):

Estimate language distribution across the sampled public repositories. This deeper option requires additional processing per profile.

## `includeSocialAccounts` (type: `boolean`):

Fetch all linked social accounts from the profile. LinkedIn is surfaced as a dedicated field and boosts the lead score.

## `includeOrganizations` (type: `boolean`):

Include the public organizations the user belongs to.

## `includeStarred` (type: `boolean`):

Include a sample of the repositories the user has starred (signals interests / tech stack).

## `maxStarred` (type: `integer`):

Cap on starred repos returned per user.

## `includeReadme` (type: `boolean`):

Include the text of the user's profile README (the special USER/USER repo shown on their profile page).

## `includeAchievements` (type: `boolean`):

Include publicly displayed profile achievements and account highlights when available.

## `includePinnedRepos` (type: `boolean`):

Include the repositories the user pinned to their profile, enriched with stars, forks, language and topics. Best paired with repo aggregation.

## `includeContributions` (type: `boolean`):

Include the user's total public contribution count over the last year (a strong activity signal for recruiting).

## `emailFromCommits` (type: `boolean`):

Look for additional email addresses exposed in the developer's public project activity. Use this only for a legitimate purpose and follow applicable privacy and anti-spam rules. Requires additional processing per profile.

## `verifyEmail` (type: `boolean`):

Add a basic email-domain status for discovered addresses. This is a technical signal, not a guarantee that a mailbox exists or will accept a message.

## `exportFormat` (type: `string`):

default = full JSON record. csv = flat, sales-friendly row for Google Sheets / HubSpot / Pipedrive.

## `includeLeadScore` (type: `boolean`):

Add a 0-100 lead score with tier (cold/warm/hot/scorching) and reasons, computed from followers, stars, repos, account age, email, LinkedIn, company and hireable status.

## `includeOutreach` (type: `boolean`):

Add a ready-to-send outreach icebreaker and a bestContact picker (email > LinkedIn > website > Twitter).

## `minLeadScore` (type: `integer`):

Drop profiles below this lead score. 0 = keep all.

## `minFollowers` (type: `integer`):

Drop profiles with fewer followers. 0 = keep all.

## `minRepos` (type: `integer`):

Drop profiles with fewer public repos. 0 = keep all.

## `minStars` (type: `integer`):

Drop profiles with fewer total stars across their repos. Requires repo aggregation. 0 = keep all.

## `hireableOnly` (type: `boolean`):

Keep only profiles flagged as available for hire.

## `withEmailOnly` (type: `boolean`):

Keep only profiles that expose a public email (hottest leads).

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

Optional read-only personal access token for higher authorized request limits on larger workloads. Use the minimum permissions required. The value is treated as a secret.

## `githubCookies` (type: `string`):

Advanced optional session value for users who understand the security implications. Leave empty for normal public-data runs. Never share this value in logs, screenshots, support messages, or reusable task templates.

## `maxConcurrency` (type: `integer`):

How many profiles to fetch in parallel.

## `timeout` (type: `integer`):

Max wait time per API request.

## `profileTimeout` (type: `integer`):

Time budget per profile and per repository/organization discovery source. If optional enrichment exceeds the budget, valid core profile data is kept with enrichmentWarnings. Discovery retains completed pages and reports its deadline in SUMMARY.

## `maxRetries` (type: `integer`):

Retry attempts when a request is temporarily rate-limited or unavailable.

## Actor input object example

```json
{
  "profileUrls": [
    "https://github.com/sindresorhus",
    "torvalds"
  ],
  "repoUrls": [],
  "repoLeadsSource": "contributors",
  "orgUrls": [],
  "maxLeadsPerRepo": 1000,
  "extractRepos": true,
  "includeRepoList": false,
  "maxRepos": 100,
  "includeLanguageStats": false,
  "includeSocialAccounts": true,
  "includeOrganizations": false,
  "includeStarred": false,
  "maxStarred": 30,
  "includeReadme": false,
  "includeAchievements": false,
  "includePinnedRepos": false,
  "includeContributions": false,
  "emailFromCommits": false,
  "verifyEmail": false,
  "exportFormat": "default",
  "includeLeadScore": true,
  "includeOutreach": true,
  "minLeadScore": 0,
  "minFollowers": 0,
  "minRepos": 0,
  "minStars": 0,
  "hireableOnly": false,
  "withEmailOnly": false,
  "maxConcurrency": 5,
  "timeout": 15,
  "profileTimeout": 90,
  "maxRetries": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Structured GitHub profile records from the default Dataset.

# 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 = {
    "profileUrls": [
        "https://github.com/sindresorhus",
        "torvalds"
    ],
    "repoUrls": [],
    "orgUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/github-profile-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 = {
    "profileUrls": [
        "https://github.com/sindresorhus",
        "torvalds",
    ],
    "repoUrls": [],
    "orgUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/github-profile-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 '{
  "profileUrls": [
    "https://github.com/sindresorhus",
    "torvalds"
  ],
  "repoUrls": [],
  "orgUrls": []
}' |
apify call apivault_labs/github-profile-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/github-profile-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/HCPOl6k3LqnOVdFns/builds/efcjYwzCEhDOR1vBi/openapi.json