# GitHub Scraper — Repos, Issues, PRs & Code (`khadinakbar/github-deep-scraper`) Actor

Scrape GitHub deeply — repos, issues, PRs, code search, contributors, releases, READMEs, commits, users, trending. 11 modes in one actor for AI coding agents (Claude Code, Cursor, Copilot). Optional PAT for 5K req/hr. MCP-ready, flat JSON output.

- **URL**: https://apify.com/khadinakbar/github-deep-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Developer tools, MCP servers, Automation
- **Stats:** 1 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.

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

## GitHub Scraper — Repos, Issues, PRs & Code

**GitHub Scraper is the GitHub data layer for AI coding agents.** One actor, 11 modes, official REST + GraphQL APIs. Built for Claude Code, Cursor, GitHub Copilot, Aider, and any agent that needs rich GitHub context in a single tool call instead of stitching five narrow scrapers together.

### What it does

Scrapes GitHub deeply through 11 selectable modes:

| Mode | Returns | Required input |
|---|---|---|
| `repo` | Full repo metadata — 50+ fields (stars, forks, languages, topics, license, default branch, latest release) | `repo` |
| `repo-search` | Repos matching a search query — full GitHub search qualifier syntax (`language:`, `stars:>1000`, `user:`, `topic:`) | `query` |
| `issues` | Issues with labels, assignees, milestones, optional comment thread | `repo` |
| `prs` | Pull requests with reviewers, files changed, mergeable status, optional reviews + comments | `repo` |
| `code-search` | Code search across all of GitHub — file path, repo, sha, text matches (**requires GITHUB_TOKEN**) | `query` |
| `contributors` | Contributors with login, contribution count, full profile (email, company, location, bio) | `repo` |
| `releases` | Releases with assets, download counts, release notes, prerelease flag | `repo` |
| `readme` | Full README — raw markdown + GFM-rendered HTML | `repo` |
| `commits` | Commit history with author, message, SHA, parents, optional file diffs + stats | `repo` |
| `user` | User or organization profile + their repos + organizations + social accounts | `user` |
| `trending` | Trending repos by language and timeframe (daily / weekly / monthly) | none |

### When to use it

- **AI coding agents** that need to ground answers in real repo state — issue history, PR reviews, contributor expertise, recent commits.
- **OSS research** — analyze hundreds of repos for tech stack, activity, bus factor, dependency drift.
- **DevRel sourcing** — find maintainers, contributors, and active issue commenters for partnership outreach.
- **Recruiter pipelines** — identify high-signal devs by contribution patterns and language depth.
- **Competitive intelligence** — track competitor open-source releases, issue volume, PR velocity.

### When **not** to use it

- Private repositories or GitHub Enterprise Server (use the official `gh` CLI with auth instead).
- Real-time GitHub events — use GitHub webhooks for that.
- LinkedIn-style enrichment of GitHub users — see `linkedin-profile-email-scraper` for that.

### Price

- **`apify-actor-start`** — $0.00005 per run start.
- **`result`** — $0.005 per record returned for: `repo`, `repo-search`, `issues` (without comments), `prs` (without reviews/comments), `contributors`, `releases`, `readme`, `user`, `trending`.
- **`deep-result`** — $0.01 per record for heavier modes: `code-search`, `commits` with `includeFiles=true`, PRs with `includeReviews=true` or `includeComments=true`, issues with `includeComments=true`.

A typical agent call (50 repos in `repo-search`) costs about **$0.25**. A deep run (100 PRs with reviews + comments) costs about **$1.00**. The actor stops at `maxResults` (default 50, hard cap 1000) so one run stays under $10 — the x402 default prepay limit for agentic payments.

### Authentication

Without a token, GitHub's REST API allows **60 requests/hour**. With a token: **5,000/hour**. Code search **requires** authentication.

Set the `GITHUB_TOKEN` environment variable in **Apify Console → Settings → Environment variables → Add → Secret**:

1. Create a fine-grained Personal Access Token at https://github.com/settings/tokens?type=beta
2. Grant `public_repo` (read-only) scope; that's enough for everything public.
3. Paste the token as `GITHUB_TOKEN` in the actor's environment variables. Apify masks it automatically.

The actor never logs the token — `apify/log` auto-redacts.

### Example inputs

#### Full metadata for one repo

```json
{
  "mode": "repo",
  "repo": "facebook/react"
}
````

#### Top 50 TypeScript MCP repos

```json
{
  "mode": "repo-search",
  "query": "language:typescript stars:>500 mcp",
  "maxResults": 50
}
```

#### Open issues with full conversation threads

```json
{
  "mode": "issues",
  "repo": "apify/actors-mcp-server",
  "state": "open",
  "includeComments": true,
  "maxResults": 100
}
```

#### Recent merged PRs with reviews

```json
{
  "mode": "prs",
  "repo": "vercel/next.js",
  "state": "closed",
  "includeReviews": true,
  "since": "2026-04-01",
  "maxResults": 200
}
```

#### Code search across GitHub

```json
{
  "mode": "code-search",
  "query": "StreamableHTTPServerTransport language:typescript",
  "maxResults": 100
}
```

#### Daily trending Rust repos

```json
{
  "mode": "trending",
  "language": "rust",
  "timeframe": "daily"
}
```

#### Last 30 days of commits with file diffs

```json
{
  "mode": "commits",
  "repo": "anthropics/claude-code",
  "since": "2026-04-28",
  "includeFiles": true,
  "maxResults": 200
}
```

### Output shape

Every record has `mode`, `type`, `url`, and `scrapedAt` (ISO 8601 UTC). Mode-specific fields follow. Items are flat, nulls are explicit, dates are ISO 8601. Average item size is under 500 tokens — built to fit inside an agent's context window when sampling 3-20 results.

Sample `repo` record:

```json
{
  "mode": "repo",
  "type": "repo",
  "owner": "facebook",
  "name": "react",
  "fullName": "facebook/react",
  "description": "The library for web and native user interfaces.",
  "url": "https://github.com/facebook/react",
  "homepage": "https://react.dev",
  "language": "JavaScript",
  "topics": ["react", "frontend", "javascript", "library"],
  "stars": 229000,
  "forks": 46900,
  "watchers": 6700,
  "openIssues": 980,
  "license": "MIT",
  "archived": false,
  "defaultBranch": "main",
  "createdAt": "2013-05-24T16:15:54Z",
  "updatedAt": "2026-05-28T11:20:01Z",
  "pushedAt": "2026-05-28T03:42:11Z",
  "languages": { "JavaScript": 8294122, "TypeScript": 311024, "HTML": 24189 },
  "latestRelease": { "tagName": "v18.3.1", "publishedAt": "2025-04-26T17:42:00Z" },
  "scrapedAt": "2026-05-28T18:14:32Z"
}
```

### Use with MCP

The actor exposes itself as `apify--github-deep-scraper` in the Apify MCP server. Hit it from any MCP client:

```
https://mcp.apify.com?tools=khadinakbar/github-deep-scraper
```

From Claude Code or Cursor, configure the Apify MCP server with your Apify token, then the tool is discoverable through standard MCP `list_tools` calls. Anthropic agents budget per call — typical agent runs stay under the $1 x402 default prepay limit when `maxResults` is set sensibly.

### Reliability and rate limits

- Built-in retry with exponential backoff for 5xx errors.
- 429 backoff respects GitHub's `Retry-After` header.
- 403 rate-limit responses wait until `X-RateLimit-Reset` (or fail clean if the wait exceeds 60 s).
- Latest rate-limit state is persisted to the actor's key-value store (`RATELIMIT-latest`) for inspection.
- ETag headers are surfaced via the KV store collection `ETAG` to enable downstream conditional caching.

### FAQ

**Why one actor with 11 modes instead of 11 separate actors?**
Agents call tools by name. Having one tool that covers all GitHub surfaces means the agent picks correctly the first time. Eleven separate actors mean eleven tool-description shootouts and eleven chances to pick the wrong one.

**Do I need a GitHub token?**
For most modes, no — but you'll be capped at 60 requests/hour. Set `GITHUB_TOKEN` to lift that to 5,000/hour. For `code-search`, a token is required (GitHub's API forces this).

**Does it work for private repositories?**
No. Use the official GitHub CLI (`gh`) for private repos. This actor is designed for public data only.

**What about GitHub GraphQL?**
The actor uses REST v3 for stable, paginated endpoints. A future version may switch heavy multi-field reads to GraphQL to halve API quota usage.

**How fresh is the data?**
Real-time. Every run hits GitHub's live API.

**Can I run multiple modes in one call?**
No — one mode per run. Chain runs from your orchestrator (Apify task, n8n, Zapier, agent loop) when you need composite data.

### Legal

This actor accesses GitHub's official REST and GraphQL APIs and the public github.com/trending HTML page. All endpoints used are public; no authentication is required to access them (a token is recommended for higher rate limits). You are responsible for complying with GitHub's [Terms of Service](https://docs.github.com/en/site-policy/github-terms/github-terms-of-service) and [Acceptable Use Policy](https://docs.github.com/en/site-policy/acceptable-use-policies/github-acceptable-use-policies). The actor does not scrape private repositories or any data behind login. It does not bypass any technical protection measure. Personal data extracted (contributor names, emails published on profiles) must be handled in accordance with applicable data-protection law (GDPR, CCPA). Apify and the actor author make no warranty about data accuracy, completeness, or fitness for any purpose.

### Changelog

- **2026-05-29 v0.2** — Reliability hardening. Graceful 404/422/451/409 → structured `not-found`/`search-error` records instead of failed runs. Canary check at run start. Pre-flight validation. Trending mode now flags invalid language slugs explicitly. 36/36 brutal test matrix green.
- **2026-05-28 v0.1** — Initial release. 11 modes. REST v3. PAT-aware rate-limit handling. Premium PPE pricing.

***

### Related actors

- [Google Patents Scraper](https://apify.com/khadinakbar/google-patents-scraper) — search patents, citations & inventor portfolios across USPTO/EPO/WIPO when you need IP context alongside open-source.
- [Hugging Face Scraper](https://apify.com/khadinakbar/huggingface-all-in-one-scraper) — models, datasets & Spaces for AI research and benchmarking work that pairs with GitHub repo intel.
- [Y Combinator Scraper](https://apify.com/khadinakbar/ycombinator-scraper) — YC company profiles, founders & jobs to enrich repo-author identification and dev-tool competitive scans.
- [Google SERP Scraper](https://apify.com/khadinakbar/scrape-google-serp) — Google search results for any keyword when you need to combine repo signal with web-wide ranking.
- [ImportYeti Scraper](https://apify.com/khadinakbar/importyeti-scraper) — US Customs import/supplier graph for industrial intelligence beyond the software layer.

Built by [@khadinakbar](https://apify.com/khadinakbar).

# Actor input Schema

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

Which GitHub surface to scrape. One actor, 11 modes. Pick exactly one. 'repo' = full metadata for one repo (50+ fields). 'repo-search' = keyword/qualifier search. 'issues'/'prs' = list issues/PRs for a repo with comments, labels, reviews. 'code-search' = search code across GitHub (REQUIRES GITHUB\_TOKEN env var). 'contributors' = repo contributors with profile data. 'releases' = release history with assets. 'readme' = full README markdown + rendered text. 'commits' = commit history with author, files, stats. 'user' = user/org profile + their repos. 'trending' = trending repos by language and timeframe. NOT for private repos or GitHub Enterprise.

## `repo` (type: `string`):

GitHub repository in 'owner/name' format (e.g., 'facebook/react'). Required for modes: repo, issues, prs, contributors, releases, readme, commits. Accepts full URL too — 'https://github.com/facebook/react' is normalised. NOT used for repo-search, code-search, user, trending modes.

## `query` (type: `string`):

Free-text query with GitHub search qualifiers (e.g., 'language:typescript stars:>1000 web framework'). Used by modes: repo-search, code-search. Supports all GitHub search operators (language:, stars:, forks:, user:, org:, path:, extension:, in:). NOT a repository identifier — for that use the 'repo' field.

## `user` (type: `string`):

GitHub user or organization login (e.g., 'torvalds' or 'apify'). Required for mode 'user'. Returns profile, repos, organizations, and (if available) social accounts. NOT a repo path — for that use 'repo' field.

## `language` (type: `string`):

Optional language filter for trending mode (e.g., 'python', 'rust', 'typescript'). Lowercase, hyphenated for multi-word. For repo-search use 'language:python' inside the query field instead. Empty = all languages.

## `timeframe` (type: `string`):

Time window for trending mode. 'daily' = today's trending repos, 'weekly' = this week, 'monthly' = this month. GitHub publishes these lists at github.com/trending. Only used by mode 'trending'. Default: daily.

## `state` (type: `string`):

Filter issues or PRs by state. 'open' = only open, 'closed' = only closed, 'all' = both. Only used by modes 'issues' and 'prs'. Default: open. GitHub's UI default is open, so leave as 'open' for most agent use.

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

Only return items updated/created at or after this ISO 8601 date (e.g., '2026-01-01' or '2026-01-01T00:00:00Z'). Used by modes 'issues', 'prs', 'commits'. Empty = no lower bound.

## `maxResults` (type: `integer`):

Maximum number of records to return. Each record = one PPE 'result' ($0.005) or 'deep-result' ($0.01) charge. Default 50. Hard cap 1000 to keep one run under $10 for x402 agents. Set lower to control cost; the actor will stop early when it reaches the cap.

## `includeComments` (type: `boolean`):

When true, fetches comments for each issue or PR (extra API call per item). Increases run cost but gives the full conversation thread. Only affects modes 'issues' and 'prs'. Default: false. Set true when an agent needs sentiment, decisions, or context from threads.

## `includeReviews` (type: `boolean`):

When true, fetches reviews and review comments for each PR (extra API call per PR). Returns reviewer login, state (APPROVED/REQUEST\_CHANGES/COMMENTED), submitted\_at, body. Only affects mode 'prs'. Default: false. Set true when an agent needs review-status or reviewer breakdown.

## `includeFiles` (type: `boolean`):

When true, includes the list of files changed per commit with additions/deletions/status. Charged as 'deep-result' ($0.01) instead of 'result'. Only affects mode 'commits'. Default: false. Set true when an agent needs to reason about diffs.

## Actor input object example

```json
{
  "mode": "repo",
  "repo": "facebook/react",
  "query": "language:typescript stars:>5000 mcp",
  "user": "torvalds",
  "language": "typescript",
  "timeframe": "daily",
  "state": "open",
  "since": "2026-01-01",
  "maxResults": 50,
  "includeComments": false,
  "includeReviews": false,
  "includeFiles": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with one record per result. Shape depends on `mode` field (repo, repo-search, issues, prs, code-search, contributors, releases, readme, commits, user, trending). Soft errors (404/422/451/409) emit a single record with `type: "not-found"` or `type: "search-error"`, a numeric `_status`, and a `_note` describing the cause.

## `rateLimit` (type: `string`):

Latest X-RateLimit headers captured from GitHub. Inspect to debug 403/429 issues or to confirm a GITHUB\_TOKEN is being applied. Schema: { remaining, reset, limit, scrapedAt }.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "mode": "repo",
    "repo": "facebook/react",
    "query": "language:typescript stars:>5000 mcp",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/github-deep-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "repo",
    "repo": "facebook/react",
    "query": "language:typescript stars:>5000 mcp",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/github-deep-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "repo",
  "repo": "facebook/react",
  "query": "language:typescript stars:>5000 mcp",
  "maxResults": 50
}' |
apify call khadinakbar/github-deep-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Scraper — Repos, Issues, PRs & Code",
        "description": "Scrape GitHub deeply — repos, issues, PRs, code search, contributors, releases, READMEs, commits, users, trending. 11 modes in one actor for AI coding agents (Claude Code, Cursor, Copilot). Optional PAT for 5K req/hr. MCP-ready, flat JSON output.",
        "version": "0.1",
        "x-build-id": "4dcGdJA84Gm22kFMo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~github-deep-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-github-deep-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/khadinakbar~github-deep-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-github-deep-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/khadinakbar~github-deep-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-github-deep-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Scraping mode",
                        "enum": [
                            "repo",
                            "repo-search",
                            "issues",
                            "prs",
                            "code-search",
                            "contributors",
                            "releases",
                            "readme",
                            "commits",
                            "user",
                            "trending"
                        ],
                        "type": "string",
                        "description": "Which GitHub surface to scrape. One actor, 11 modes. Pick exactly one. 'repo' = full metadata for one repo (50+ fields). 'repo-search' = keyword/qualifier search. 'issues'/'prs' = list issues/PRs for a repo with comments, labels, reviews. 'code-search' = search code across GitHub (REQUIRES GITHUB_TOKEN env var). 'contributors' = repo contributors with profile data. 'releases' = release history with assets. 'readme' = full README markdown + rendered text. 'commits' = commit history with author, files, stats. 'user' = user/org profile + their repos. 'trending' = trending repos by language and timeframe. NOT for private repos or GitHub Enterprise.",
                        "default": "repo"
                    },
                    "repo": {
                        "title": "Repository (owner/name)",
                        "type": "string",
                        "description": "GitHub repository in 'owner/name' format (e.g., 'facebook/react'). Required for modes: repo, issues, prs, contributors, releases, readme, commits. Accepts full URL too — 'https://github.com/facebook/react' is normalised. NOT used for repo-search, code-search, user, trending modes."
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text query with GitHub search qualifiers (e.g., 'language:typescript stars:>1000 web framework'). Used by modes: repo-search, code-search. Supports all GitHub search operators (language:, stars:, forks:, user:, org:, path:, extension:, in:). NOT a repository identifier — for that use the 'repo' field."
                    },
                    "user": {
                        "title": "User or organization login",
                        "type": "string",
                        "description": "GitHub user or organization login (e.g., 'torvalds' or 'apify'). Required for mode 'user'. Returns profile, repos, organizations, and (if available) social accounts. NOT a repo path — for that use 'repo' field."
                    },
                    "language": {
                        "title": "Programming language filter",
                        "type": "string",
                        "description": "Optional language filter for trending mode (e.g., 'python', 'rust', 'typescript'). Lowercase, hyphenated for multi-word. For repo-search use 'language:python' inside the query field instead. Empty = all languages."
                    },
                    "timeframe": {
                        "title": "Trending timeframe",
                        "enum": [
                            "daily",
                            "weekly",
                            "monthly"
                        ],
                        "type": "string",
                        "description": "Time window for trending mode. 'daily' = today's trending repos, 'weekly' = this week, 'monthly' = this month. GitHub publishes these lists at github.com/trending. Only used by mode 'trending'. Default: daily.",
                        "default": "daily"
                    },
                    "state": {
                        "title": "Issue / PR state",
                        "enum": [
                            "open",
                            "closed",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter issues or PRs by state. 'open' = only open, 'closed' = only closed, 'all' = both. Only used by modes 'issues' and 'prs'. Default: open. GitHub's UI default is open, so leave as 'open' for most agent use.",
                        "default": "open"
                    },
                    "since": {
                        "title": "Since (ISO 8601 date)",
                        "type": "string",
                        "description": "Only return items updated/created at or after this ISO 8601 date (e.g., '2026-01-01' or '2026-01-01T00:00:00Z'). Used by modes 'issues', 'prs', 'commits'. Empty = no lower bound."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of records to return. Each record = one PPE 'result' ($0.005) or 'deep-result' ($0.01) charge. Default 50. Hard cap 1000 to keep one run under $10 for x402 agents. Set lower to control cost; the actor will stop early when it reaches the cap.",
                        "default": 50
                    },
                    "includeComments": {
                        "title": "Include comments (issues/PRs)",
                        "type": "boolean",
                        "description": "When true, fetches comments for each issue or PR (extra API call per item). Increases run cost but gives the full conversation thread. Only affects modes 'issues' and 'prs'. Default: false. Set true when an agent needs sentiment, decisions, or context from threads.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include reviews (PRs)",
                        "type": "boolean",
                        "description": "When true, fetches reviews and review comments for each PR (extra API call per PR). Returns reviewer login, state (APPROVED/REQUEST_CHANGES/COMMENTED), submitted_at, body. Only affects mode 'prs'. Default: false. Set true when an agent needs review-status or reviewer breakdown.",
                        "default": false
                    },
                    "includeFiles": {
                        "title": "Include file diffs (commits)",
                        "type": "boolean",
                        "description": "When true, includes the list of files changed per commit with additions/deletions/status. Charged as 'deep-result' ($0.01) instead of 'result'. Only affects mode 'commits'. Default: false. Set true when an agent needs to reason about diffs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
