# GitHub Activity Stream — AI Agent Dev Monitoring API (`logiover/github-activity-stream`) Actor
Keyless GitHub activity stream for AI agents: commits, pull requests, issues, releases and events for any repo, org or user. Time-windowed, paginated, thousands of events per run. Actors, additions, labels, states and URLs per row. No API key, no browser.
- **URL**: https://apify.com/logiover/github-activity-stream.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $3.50 / 1,000 results
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Activity Stream — Commits, PRs, Issues & Releases API (No API Key)
    
Stream public activity from **GitHub** — commits, pull requests, issues, releases and user events — for any **repo, org or user**, normalized into one flat schema. Every event becomes a structured row with **type, repo, actor, title, state, additions/deletions, labels, tagName and URL**, time-windowed and paginated so a single run returns thousands of events. Built for AI coding agents, dependency monitors and release trackers that need current dev activity — not stale training-set snapshots. **Direct HTTP + JSON, no browser, no login, no API key** (keyless GitHub REST API, with an optional token for higher throughput).
> ### 🏆 Why this GitHub Activity Stream scraper?
>
> **4 modes (repo / org / user / bulk)** · **thousands of events per run** · one normalized schema across commits, PRs, issues & releases · time-windowed (`since`) delta runs · proxy IP rotation to beat the keyless rate cap · export to JSON / CSV / Excel. The unofficial **GitHub activity API alternative** for AI-agent dev grounding, release tracking and dependency monitoring.
***
### ✨ What this Actor does / Key features
- 📦 **Commits** — first-line message as `title`, author and date, paginated with a `since` window.
- 🔀 **Pull requests** — `additions`, `deletions`, `commits`, `merged`, `state` and `labels` straight from the PR object.
- ❗ **Issues** — open/closed `state` and `labels` (pure issues; PRs are pulled separately so you never double-count).
- 🏷️ **Releases** — `tagName`, `name`, `isPrerelease` flag and publish date for every release.
- 👤 **User events** — a user's public event feed (pushes, PRs, issues, reviews) — up to 90 days of history.
- 🏢 **Org-wide scan** — list an org's public repos (sorted by recent activity) and pull activity from each in one run.
- 📅 **Time-windowed deltas** — the `since` filter keeps only events after a date, ideal for daily/weekly monitoring runs.
- 🤖 **AI-agent friendly** — predictable fields, ISO 8601 dates, nullable values; drop straight into a prompt or a vector store.
- 🌐 **Proxy IP rotation** — Apify datacenter proxy rotates the source IP per request to spread GitHub's keyless 60 req/hr/IP limit.
- 🔁 **Retry & backoff** — 403 (rate-limit) and 5xx trigger exponential-backoff retry; deleted/private repos exit gracefully.
- 🔑 **Optional token** — supply a free GitHub Personal Access Token to raise the limit from 60 to 5000 req/hr for heavy use.
- 💰 **Pay-per-result** — charged per saved event, never per run; empty results (deleted/private repo) are free.
### 🚀 Quick start (3 steps)
1. **Configure** — pick a `mode` (`repo`, `org`, `user` or `bulk`) and its target (a `microsoft/vscode` slug, an `org` like `kubernetes`, or a `user` like `torvalds`). Add a `since` date and trim `eventTypes` if you only want, say, releases.
2. **Run** — click **Start**. The Actor resolves your targets, paginates each activity endpoint through a rotating proxy IP, and streams normalized events into your dataset.
3. **Get your data** — open the **Output** tab and export to **JSON, CSV, Excel or XML**, or pull it via the Apify API. Use the **Overview** view to scan everything or **By type** to pivot on commit/PR/issue/release.
### 📥 Input
Pick a `mode` and give it a target. Everything else is optional — leave `since` empty for full history (capped by `maxPerType`), or set it for a delta window.
#### Example — single repo, one week of activity
```json
{
"mode": "repo",
"repos": ["microsoft/vscode"],
"eventTypes": ["commits", "pulls", "issues", "releases"],
"since": "2026-06-29",
"maxPerType": 200
}
```
#### Example — org-wide scan (monitor an ecosystem)
```json
{
"mode": "org",
"org": "kubernetes",
"maxOrgRepos": 15,
"eventTypes": ["pulls", "releases"],
"since": "2026-06-01"
}
```
#### Example — user public activity + bulk multi-repo
```json
{
"mode": "user",
"user": "torvalds",
"maxPerType": 100
}
```
```json
{
"mode": "bulk",
"repos": ["facebook/react", "vercel/next.js", "microsoft/typescript"],
"eventTypes": ["releases"],
"since": "2026-06-01"
}
```
| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | enum | `repo` | What to monitor: `repo` (one repo, highest volume), `org` (all of an org's public repos), `user` (a user's public events), `bulk` (many repos in one run). **Required.** |
| `repos` | array | `[]` | `owner/repo` slugs for **repo** and **bulk** mode, e.g. `microsoft/vscode`, `facebook/react`. |
| `org` | string | — | GitHub organization slug for **org** mode, e.g. `kubernetes`, `vercel`. |
| `user` | string | — | GitHub username for **user** mode, e.g. `torvalds`. |
| `eventTypes` | array | all | Which activity types to collect: `commits`, `pulls`, `issues`, `releases`. Fewer types = faster. |
| `since` | string | — | ISO date (`YYYY-MM-DD` or full ISO). Only events after this date. Leave empty for full history. |
| `maxPerType` | integer | `200` | Cap per event type per repo (commits, PRs, issues, releases each). Range 1–1000. |
| `maxOrgRepos` | integer | `20` | Cap on how many repos to scan in **org** mode. Range 1–200. |
| `ghToken` | string | — | Optional GitHub Personal Access Token — raises the rate limit from 60 to 5000 req/hr. Public scope is enough. |
| `useApifyProxy` | boolean | `true` | Route through the Apify datacenter proxy (IP rotation) to spread the keyless 60 req/hr/IP limit. |
> **Tip — always set `since` for monitoring.** Without it you pull full history (capped by `maxPerType`). For a recurring digest, set `since` to your last run time so each run is a clean delta. Commits are the highest-volume (and slowest) type — trim `eventTypes` to `["releases"]` or `["pulls","releases"]` when you don't need them.
### 📤 Output
One row per activity event — commit, pull request, issue or release — streamed to the default dataset, exportable to JSON, CSV, Excel or XML. Here is a trimmed sample pull-request record:
```json
{
"repo": "microsoft/vscode",
"type": "pull",
"number": 210543,
"title": "Fix terminal rendering on macOS",
"action": null,
"state": "closed",
"actor": "user123",
"createdAt": "2026-06-28T10:00:00Z",
"updatedAt": "2026-07-01T15:00:00Z",
"additions": 142,
"deletions": 38,
"commits": 3,
"labels": ["bug", "terminal"],
"merged": true,
"isPrerelease": null,
"tagName": null,
"url": "https://github.com/microsoft/vscode/pull/210543",
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
A **release** row carries `type: "release"`, `tagName: "1.21.0"` and `isPrerelease: false`. A **commit** row carries `type: "commit"` with the first-line message as `title`. A **user event** carries the GitHub event `type` (e.g. `PushEvent`, `PullRequestEvent`). PR-only stats (`additions`, `deletions`, `commits`, `merged`) are `null` on non-PR rows.
📋 Full field reference (click to expand)
| Field | Description |
|-------|-------------|
| `repo` | `owner/repo` slug the event belongs to |
| `type` | Event type: `commit`, `pull`, `issue`, `release`, or a GitHub event name (`PushEvent`, …) in user mode |
| `number` | PR / issue number (null for commits & releases) |
| `title` | PR / issue title, release name, or first-line commit message |
| `action` | Event action for user-mode events (e.g. `opened`, `closed`); null otherwise |
| `state` | `open` / `closed` for PRs & issues; null for commits |
| `actor` | Author / actor username (null when GitHub anonymizes the commit) |
| `createdAt` | Creation timestamp (ISO 8601) |
| `updatedAt` | Last-updated timestamp (ISO 8601) |
| `additions` | Lines added (pull requests only) |
| `deletions` | Lines removed (pull requests only) |
| `commits` | Commit count in the PR (pull requests only) |
| `labels` | Array of label names (PRs & issues) |
| `merged` | Whether the PR was merged (pull requests only) |
| `isPrerelease` | Whether the release is a pre-release (releases only) |
| `tagName` | Release tag, e.g. `1.21.0` (releases only) |
| `url` | Canonical GitHub URL for the event |
| `scrapedAt` | Scrape timestamp (ISO 8601) |
### 💡 Use cases
- **Weekly dev-summary agent** — run `repo` mode with `since: <7 days ago>` on a watched repo; let an LLM turn the commits/PRs/releases into a shipped-this-week digest.
- **Release tracking** — watch `releases` for a dependency org (`kubernetes`, `vercel`), alert on new versions and draft upgrade notes from the release bodies.
- **Security-commit detection** — filter commit/PR `title` for `security|cve|vuln|fix|patch` to surface security work before it hits an advisory feed.
- **Dependency-health scoring** — pull issue counts, label distribution and PR merge velocity to score a repo's maintenance health before you adopt it.
- **Contributor monitoring** — track a key maintainer's public events (`user` mode) to spot activity shifts or bus-factor risk.
- **Org-wide radar** — scan an entire org's repos (`org` mode) for recent activity to map where the work is actually happening.
- **RAG over dev activity** — embed commit messages and PR titles into a vector store and answer "when did X get fixed?" with citations to the exact commit.
### 👥 Who uses it
AI-agent & LLM builders grounding coding/DevOps agents · platform & DevRel teams tracking ecosystem activity · dependency-security and supply-chain analysts · release managers and upgrade-planning teams · open-source maintainers and community managers · data teams building developer-intelligence dashboards and RAG pipelines.
### 💰 Pricing
This Actor runs on a simple **pay-per-result** model — you pay per saved activity event, with no separate Apify platform fees to calculate. Runs that yield zero events (deleted, empty or private repo) are free. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current per-result rate.
### ❓ Frequently Asked Questions
**Is it legal to scrape GitHub activity?**
This Actor only reads publicly available data through GitHub's public REST API — the same activity anyone can browse on github.com. You are responsible for using the data in line with GitHub's Terms of Service and applicable laws.
**Does GitHub have a public API — why use this instead?**
GitHub does have a public REST API, but each object type (commits, PRs, issues, releases, events) is a **separate endpoint** with its own pagination, schema and rate limits, and the keyless limit is only 60 requests/hour/IP. This Actor is a **GitHub activity API alternative** that merges all types into one normalized schema, handles pagination and backoff, and rotates proxy IPs — so you get a single clean event stream instead of stitching endpoints together yourself.
**What about rate limits?**
Keyless GitHub is 60 requests/hour/IP. The Actor routes every request through the Apify datacenter proxy, rotating the source IP to effectively spread that cap, and it backs off and retries on 403s. For org-wide scans or frequent runs, supply a free `ghToken` to raise the limit to 5000 req/hr.
**Can I run it without an API key or token?**
Yes — that is the default. No GitHub account, login or API key is required; keyless mode plus proxy IP rotation covers monitoring a handful of repos. The optional `ghToken` is purely a throughput booster for heavy workloads.
**How do I export the data to CSV or JSON?**
Run the Actor, then export the resulting dataset as CSV, JSON, Excel or XML from the Apify Console — or pull it programmatically via the Apify API and dataset endpoints.
**How much data can I get in one run?**
Thousands of events. Big repos yield hundreds of commits/PRs alone; `org` mode multiplies that across up to `maxOrgRepos` repos. Commits, issues and PRs go as far back as `maxPerType` and `since` allow; releases return all of them.
**How far back can I go?**
Commits, issues and PRs: as far as repo history goes, capped by `maxPerType`. Releases: all of them. **User events** are limited by GitHub itself to the last ~90 days of public activity (10 pages max).
**Why don't commit rows have additions/deletions?**
GitHub's `/commits` list endpoint doesn't return per-commit line stats — only the detail endpoint does, and fetching each commit's detail would multiply requests heavily. Pull-request rows **do** carry `additions`, `deletions` and `commits` straight from the PR object; for per-commit stats, post-process by fetching the specific commit URLs.
**Does it work for private repos?**
No — it targets public monitoring using unauthenticated public endpoints (or a token's public scope). Private-repo access would require a token with full `repo` scope, which is outside this Actor's design.
**Can AI agents call this directly?**
Yes — that's the primary design target. Wrap it in an MCP server or Apify tool integration; the agent passes a repo and a time window and receives normalized activity, with no GitHub API juggling or rate-limit handling on the agent side.
### 🔗 More developer & AI-intelligence scrapers by logiover
Building a developer-intelligence or AI-agent grounding stack? Pair GitHub Activity Stream with the rest of the suite:
| Focus | Actor |
|---|---|
| 🐙 GitHub repos | [GitHub Repository Scraper](https://apify.com/logiover/github-repository-scraper) |
| 📦 npm packages | [npm Package Intelligence Scraper](https://apify.com/logiover/npm-package-intelligence-scraper) |
| 🤗 AI models | [Hugging Face Hub Intelligence Scraper](https://apify.com/logiover/huggingface-hub-intelligence-scraper) |
| 🛡️ Security | [CVE Security Advisory Monitor](https://apify.com/logiover/cve-security-advisory-monitor) |
| 📄 Research papers | [arXiv Paper Scraper](https://apify.com/logiover/arxiv-paper-scraper) · [Semantic Scholar Research Scraper](https://apify.com/logiover/semantic-scholar-research-scraper) |
| 🏢 Company intel | [Company Deep Research Scraper](https://apify.com/logiover/company-deep-research-scraper) |
| 📰 News | [News Intelligence Scraper](https://apify.com/logiover/news-intelligence-scraper) · [Google News Scraper](https://apify.com/logiover/google-news-scraper) |
| 📚 Docs & KB | [Docs Knowledge Base Scraper](https://apify.com/logiover/docs-knowledge-base-scraper) |
| 🔎 Web research | [AI Deep Research](https://apify.com/logiover/ai-deep-research) · [AI Web Search](https://apify.com/logiover/ai-web-search) |
| 💬 Discussions | [Discussion Intelligence Scraper](https://apify.com/logiover/discussion-intelligence-scraper) |
👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.
### ⏰ Scheduling & integration
Schedule this Actor on Apify to monitor dev activity daily or weekly — set `since` to your interval for clean delta runs. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI tools and webhooks through the Apify API. Wrap it in an **MCP server** so AI agents can call it as a tool, or connect it to **Make, n8n or Zapier** to build automated release-alert and dependency-monitoring pipelines.
### ⭐ Support & feedback
Found a bug or need an extra field? Open an issue on the **Issues** tab — response is usually fast. If this Actor saves you time, a **★★★★★ review** on the Store page genuinely helps and is hugely appreciated. 🙏
### ⚖️ Legal
This Actor queries the public GitHub REST API (keyless, or with a user-supplied token) and extracts only publicly available data. Activity data is owned by the respective repository owners and contributors. Use it for legitimate dev monitoring, dependency tracking, release intelligence and AI-agent grounding, and comply with GitHub's Terms of Service and any applicable local laws.
***
### 📝 Changelog
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
#### 2026-07-06
- ✨ README overhaul: richer output sample, ready-to-run example scenarios, cross-promo links to related logiover scrapers, and clearer quick-start.
#### 2026-07-02 — v1.0
- Initial release.
- 4 modes: `repo`, `org`, `user`, `bulk`.
- 4 event types: commits, pulls, issues, releases (+ user public events).
- `since` time window, pagination, `maxPerType` / `maxOrgRepos` caps.
- Optional `ghToken` (60→5000 req/hr).
- Apify datacenter proxy default (IP rotation).
- Pay-per-result (`result` event per saved event).
# Actor input Schema
## `mode` (type: `string`):
What to monitor.
• **repo** — activity for one repo (commits + PRs + issues + releases) (highest volume per target). Default; empty input returns activity for a popular default repo.
• **org** — all public repos of an org, each with activity
• **user** — a user's public events + their repos
• **bulk** — many repos/orgs in one run
## `repos` (type: `array`):
Array of `owner/repo` slugs for **repo** or **bulk** mode, e.g. `microsoft/vscode`, `facebook/react`. Leave empty to get recent activity for a popular default repo.
## `org` (type: `string`):
GitHub organization slug for **org** mode, e.g. `kubernetes`, `vercel`.
## `user` (type: `string`):
GitHub username for **user** mode, e.g. `torvalds`.
## `eventTypes` (type: `array`):
Which activity types to collect (repo/org/bulk modes). Defaults to all. Fewer = faster.
## `since` (type: `string`):
Only events after this date (YYYY-MM-DD or full ISO). Leave empty for all history (capped by maxResults).
## `maxPerType` (type: `integer`):
Cap per event type per repo (commits, PRs, issues, releases each).
## `maxOrgRepos` (type: `integer`):
Cap on repos to scan in org mode.
## `ghToken` (type: `string`):
Optional GitHub Personal Access Token (raises rate limit from 60 to 5000 req/hr). Leave empty for keyless (proxy rotation spreads the 60/hr/IP limit).
## `useApifyProxy` (type: `boolean`):
Route through Apify datacenter proxy (IP rotation). GitHub keyless is 60 req/hr/IP; rotation effectively removes the cap.
## Actor input object example
```json
{
"mode": "repo",
"repos": [
"microsoft/vscode"
],
"org": "kubernetes",
"user": "torvalds",
"eventTypes": [
"commits",
"pulls",
"issues",
"releases"
],
"since": "2026-06-01",
"maxPerType": 100,
"maxOrgRepos": 10,
"ghToken": "",
"useApifyProxy": true
}
```
# Actor output Schema
## `results` (type: `string`):
Full dataset of normalized GitHub activity events.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"mode": "repo",
"repos": [
"microsoft/vscode"
],
"org": "kubernetes",
"user": "torvalds",
"eventTypes": [
"commits",
"pulls",
"issues",
"releases"
],
"since": "",
"maxPerType": 100,
"maxOrgRepos": 10,
"useApifyProxy": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/github-activity-stream").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"mode": "repo",
"repos": ["microsoft/vscode"],
"org": "kubernetes",
"user": "torvalds",
"eventTypes": [
"commits",
"pulls",
"issues",
"releases",
],
"since": "",
"maxPerType": 100,
"maxOrgRepos": 10,
"useApifyProxy": True,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/github-activity-stream").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",
"repos": [
"microsoft/vscode"
],
"org": "kubernetes",
"user": "torvalds",
"eventTypes": [
"commits",
"pulls",
"issues",
"releases"
],
"since": "",
"maxPerType": 100,
"maxOrgRepos": 10,
"useApifyProxy": true
}' |
apify call logiover/github-activity-stream --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=logiover/github-activity-stream",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
Download the OpenAPI definition: https://api.apify.com/v2/acts/JEAk1UnP1K5V1BXk9/builds/CtWrcvIdRK74H15se/openapi.json