PostHog

Fetch CI checks for a report's implementation PR

Fetch the CI status (GitHub Actions check runs and legacy commit statuses) of the pull request the report's implementation task opened, via the team's GitHub integration.

Fetch comments for a report's implementation PR

Fetch the pull request's conversation comments and inline review comments, merged chronologically, via the team's GitHub integration.

Fetch the diff for a commit artefact

Fetch the unified diff of a `commit` artefact's branch against the repository default branch via the team's GitHub integration — using the branch's current tip so the diff reflects the latest state of the work, not just the single recorded commit.

Get a channel

API for task channels — the shared feeds tasks are kicked off in. Listing lazily provisions the requester's personal "#me" channel; creation is resolve-or-create by normalized name so clients can map channel-like surfaces onto backend channels.

Get a loop

API for managing loops — named, cloud-executed agent automations triggered by schedule, GitHub events or authenticated API calls. See `products/tasks/docs/LOOPS.md`.

Get a run by ID

Return the full `SignalScoutRun` row. Status, timing, and error flow from the linked `tasks.TaskRun`. Strictly team-scoped — a UUID belonging to another team returns 404.

Get a single artefact

Get one artefact by id, content parsed (and reviewers enriched) the same way as the list.

Get a team's quota-limit state

Return the current quota-limit state for the team identified in the URL, keyed by `QuotaResource` value. Used by the LLM gateway to gate billable products on AI credits exhaustion.

Get active breakpoints (External API)

External API endpoint for client applications to fetch active breakpoints using Project API key. This endpoint allows external client applications (like Python scripts, Node.js apps, etc.) to fetch the list of active breakpoints so they can instrument their code accordingly. Authentication: Requires a Project API Key in the Authorization header: `Authorization: Bearer phs_<your-project-api-key>`. You can find your Project API Key in PostHog at: Settings → Project → Project API Key

Get active task session storage access

API for managing task runs. Each run represents an execution of a task.

Get app sandbox status

Get breakpoint hits

Retrieve breakpoint hit events from ClickHouse with optional filtering and pagination. Returns hit events containing stack traces, local variables, and execution context from your application's runtime. Security: Breakpoint IDs are filtered to only include those belonging to the current team.

Get channel instructions

The channel's latest CONTEXT.md instructions. A channel with no published instructions reads as a blank version 0 — publish against base_version 0 to create version 1.

Get iframe connection info for a running app

Get repository readiness

Get autonomy readiness details for a specific repository in the current project.

Get scout metadata

Return the project's scout metadata: whether it is enrolled, the current announcement banner (e.g. an alpha run-limit notice, or null when unset), and the enforced run limits with current usage. Limits reflect what the coordinator actually applies at dispatch, so a user can see the real throttle rather than what they assume they set. All values come from the `signals-scout` flag payload, so the banner and caps can change with no deploy.

Get task

Retrieve a single task by ID.

Get task run

Retrieve a single run for a specific task.

Get task run logs

Fetch the logs for a task run as JSONL. If the run resumes from another (state.resume_from_run_id), each ancestor's log is concatenated first (oldest ancestor → ... → this run) so resume consumers see a single continuous history and can find the most recent git_checkpoint event regardless of which run emitted it.

Get the channel's CONTEXT.md generation task

API for task channels — the shared feeds tasks are kicked off in. Listing lazily provisions the requester's personal "#me" channel; creation is resolve-or-create by normalized name so clients can map channel-like surfaces onto backend channels.

Get the current project profile

Return the team's deterministic project profile. For the internal scout token the response reflects the newest non-expired cached row or a freshly-built one (lazy compute on cache miss); `force_refresh=true` skips the cache and rebuilds from authoritative sources. Public read callers (session auth or a `signal_scout:read` PAK) get the newest cached profile, or 404 if none has been built yet — they never trigger a rebuild. Read this at the start of a run to orient on the team's product mix, integrations, warehouse sources, signal coverage, and existing inbox surface.

Get the team's active onboarding wizard cloud run

Returns the most recent onboarding wizard cloud run for the current project when it is still running (or completed within the last day), so the setup-progress FAB can rehydrate after a drop-flow signup that started the run server-side. Returns 204 when there is none.

list

List a report's artefacts

List every artefact on a report — the full work log: signal findings (the evidence behind the report), status judgments (safety / actionability / priority, repo selection, suggested reviewers — the newest row of each status type is canonical), and log entries (code references, commits, task runs, notes). `suggested_reviewers` content is enriched with PostHog user info at read time.

List a report's signals

Fetch all signals for a report from ClickHouse, including full metadata.

List a run's emitted findings

Return the findings a `SignalScoutRun` emitted to the inbox, newest first — one row per emit with its `description` (the finding text as surfaced), `weight`, `confidence`, `severity`, and the deterministic `source_id` that joins back to the underlying signal. Lets a team and its agents see *what* a run surfaced without parsing `emitted_finding_ids` or scanning the signal store. Strictly team-scoped — a run UUID belonging to another team returns 404.

List blind-spots skills and which one is active

List the `review-hog-blind-spots-*` skills visible to the requesting user — the canonical skill plus the customs they authored — flagging the one active for them. The canonical skill is auto-seeded active on the first read; a custom skill the user has not selected shows as inactive.

List channel feed messages

A channel's system announcements in chronological order.

List channels

All live public channels plus the requester's personal #me channel (created on first list).

List distinct task repositories

Return the set of repositories referenced by non-deleted, non-internal tasks in the current project. Used to populate repository filter pickers without being constrained by task list pagination.

List external customer analytics accounts

List accounts with external IDs and their active relationship assignments. Requires a project secret API key with the `account:read` scope.

List living artifacts for a task run

Returns stable, versioned artifact handles created by the run's task.

List loop runs

Run history for a loop, newest first, cursor-paginated.

List loops

List loops visible to the caller: personal loops they own, plus every team loop. The response also carries `max_loops_per_team` and `total_loop_count` so a client can show remaining capacity and disable creation at the cap without hardcoding the limit.

List marketing data sources

Check the platform → data-warehouse side of every native marketing integration: connection state, sync recency, row counts, required-table status, and schema-mapping coverage. Read-only.

List mentions of the requester

Thread messages that @-mention the requester, newest first, restricted to tasks they can see.

List pinned tasks

Return the visible tasks pinned by the requester in the current project.

List project members for reviewer routing

Return the people who can review work on this project — one row per member with access to it, each with their `user_uuid`, `email`, `first_name`/`last_name`, and resolved GitHub `login` (null when they have no linked GitHub identity). The cold-start reviewer-routing path: when a finding's owner can't be read off a fetched entity's `created_by` and there's no cached `reviewer:<area>` memory or inbox precedent, list members, match the owner by email/name, then put their resolved `github_login` in `suggested_reviewers` on `emit-report` / `edit-report`. Pass `search` to narrow a large roster; the result is capped at 200. Strictly team-scoped.

List recent emitted findings across all runs

Return the team's recently emitted scout findings across *every* run, newest first — the cross-run counterpart to the per-run `emissions` action. Each row carries its `run_id`, so you can regroup by run without first listing runs and fanning out one `emissions` call each. Pass `skill_name` to scope to a single scout, and `date_from` / `date_to` (a half-open window on `emitted_at`) to bound or paginate — set `date_to` to the oldest emission's `emitted_at` to walk back past the limit. Pure Postgres, no ClickHouse round-trip. Capped at 200 rows (default 50).

List recent reviews

Recent ReviewHog reviews on this project: actively running reviews first (with the in-flight turn's stage), then the most recent completed ones — at most `limit` rows (default 5), plus `has_more` for whether a larger `limit` would reveal more. By default only the requesting user's reviews; `scope=everyone` lists every review on the project.

List recipients opted out of a message category

Get opt-outs filtered by category or overall opt-outs if no category specified

List review perspectives and their enablement

List the `review-hog-perspective-*` skills visible to the requesting user — the canonical perspectives plus the customs they authored — joined with their enable state. The 3 canonical perspectives are auto-seeded enabled on the first read; a custom perspective the user has not switched on shows as disabled.

List review validators and which one is active

List the `review-hog-validation-*` skills visible to the requesting user — the canonical validator plus the customs they authored — flagging the one active for them. The canonical validator is auto-seeded active on the first read; a custom validator the user has not selected shows as inactive.

List scout configs

List the per-(team, skill) scout configs for this project. Each row includes its schedule (rolling `run_interval_minutes`, or a project-local `run_cron_schedule` when set), `enabled`, `emit` posture, and `tags`. A freshly authored scout skill appears here once its config is registered, either explicitly via create or by the coordinator's next tick. Pass `tags` to narrow the fleet to the scouts carrying at least one of the given labels.

List streamlit apps

List subscription deliveries

Paginated delivery history for a subscription. Requires premium subscriptions.

List suppressed email addresses for the team

List suppressed recipients for the team, most recently updated first.

List task runs

Get a list of runs for a specific task.

List the inbox reports a run's findings linked to

Best-effort reverse of the report -> signals link. For each finding the run emitted, resolve the inbox `SignalReport` (if any) its underlying signal grouped into by walking the deterministic `source_id` back through the signal store. `report` is null when the finding hasn't grouped into a report yet, was de-duplicated away, or its signal was deleted. Lets the scout UI surface which inbox report a finding contributed to — the reverse of the report's evidence list. Strictly team-scoped — a run UUID belonging to another team returns 404.

List the requester's task activity

Task lifecycle rows collapse per task. Comment notifications remain separate. Results are most-recent first and restricted to tasks the requester can see.

List thread messages

The task's thread in chronological order.

query_draft_sql_retrieve

DRF ViewSet mixin that gates coalesced responses behind permission checks. The QueryCoalescingMiddleware attaches cached response data to request.META["_coalesced_response"] for followers. This mixin runs DRF's initial() (auth + permissions + throttling) before returning the cached response, ensuring the request is authorized.

query_log_retrieve

Get query log details from query_log_archive table for a specific query_id, the query must have been issued in last 24 hours.

query_retrieve

(Experimental)

Read the connected project's identity

Resolve which project, organization and region a PostHog connection points at, so callers can build target API paths without reading `api/users/@me/` through the connection first.

retrieve

Retrieve a streamlit app

Retrieve one review's detail

One completed ReviewHog review on this project, with the latest turn's validated findings, the findings the validator dismissed (and why), and the review body published to GitHub. Project-wide, so reviews listed under `scope=everyone` can be opened too.

Retrieve subscription delivery

Fetch one delivery row by id.

retrieve_session_summaries_config

Retrieve the team's session summaries configuration (product context used to tailor single-session replay summaries).