Set up Chappe
Chappe tells your coding agent when a vendor change touches your code: a deprecation, a model retirement, or a breaking, pricing or rate-limit change. Your agent scans the repository once, Chappe matches every new change against that scan, and your agent opens the draft pull request.
How it works
Get an API key. Sign up with GitHub or Google and copy your key.
Scan the repository. Your agent records which vendor SDKs, model IDs, endpoints and methods the code uses, with file and line. Your source code stays in your repository.
Connect a delivery path. Chappe pushes each change that touches those identifiers to your agent, which opens or updates a draft pull request for you to review.
Report back. The pull request’s status goes back to Chappe, so it can tell which migrations land.
The API lives at https://chappe-api.inxpanse.com. Every request sends Authorization: Bearer <your API key>. Pick the path that matches your agent:
| Your agent | How Chappe reaches it |
|---|---|
| ChatGPT dot | MCP Events, through a ChatGPT plugin you create |
| Claude Code | A scheduled task (routine) with an API trigger |
| Codex | A GitHub Actions workflow started by repository_dispatch |
| Your own service | A signed webhook |
| Your team | A Slack message |
Get an API key
Sign up at chappe-api.inxpanse.com/signup: sign in with GitHub or Google, accept the early access terms, and copy your first API key. It starts with chp_, and the page shows it only once. From there you are in your console.
- One key opens your account’s projects over REST (
/v1/…) and MCP (/mcp). - One account per person or team. With GitHub, Chappe reads only your GitHub user ID, username and primary verified email address; with Google, only your Google account ID and verified email address. It gets no access to your repositories, files or contacts, and keeps no GitHub or Google token.
- One email address has one account, and Chappe never joins sign-ins because their addresses match. To sign in with both GitHub and Google, connect the second one in your console. Until you do, a Google sign-in with your GitHub address (or the other way round) asks you to sign in the usual way first.
- Chappe stores only a SHA-256 hash of each key, so it cannot show a key again. If you lose one, create a new key in your console and revoke the lost one.
- Use one key per place: a key for GitHub Actions, one for the ChatGPT plugin, one for your laptop. Then you can revoke just the one you need to.
- Revoking a key also ends the ChatGPT sign-ins and event subscriptions made with it: sign in to the ChatGPT plugin again with another key.
- Keep keys in a secret store, such as a GitHub Actions secret or your password manager. Do not commit one, and do not paste it into a chat with an agent. If one leaks, revoke it in your console at once and tell us at contact@inxpanse.com.
- During early access an account can register up to 10 repositories, have up to 20 live keys, and make up to about 120 requests a minute. Past that, Chappe answers
429with aRetry-Afterheader. Write to us if you need more repositories.
By signing up and using a key you agree to the early access terms and acknowledge the privacy policy.
Your console
Sign in at chappe-api.inxpanse.com/app with the GitHub or Google account you signed up with. Agents never use the console; they use keys.
- Projects. Each repository your agent registered, with the changes that affect it, their deadlines, and where your code uses what changes; the changes Chappe cannot judge from the fingerprint alone, each with the reason; and the vendors in your code that Chappe does not watch. Open a change for its migration steps and the vendor’s own words. Push current changes sends the changes that already affect a project to its endpoints (your first push).
- API keys. Each key’s name, its first characters, when it was created and when it was last used. Create a named key (shown once) and revoke any key without touching the others.
- Endpoints. Where Chappe delivers, with the last delivery of each. Add a webhook or Slack endpoint, a Claude Code scheduled task or Codex in GitHub Actions, send a test event, or delete one. ChatGPT subscriptions are listed too.
- Account. Your email address, your sign-in methods and the terms you accepted. Connect or disconnect a sign-in method, turn email updates on or off, sign out here or on every device, or delete your account.
A console session ends after a day without use, and a week after you sign in. When the terms change, the console asks you to accept the new ones at your next sign-in.
Sign in with GitHub and Google
Your account can have one GitHub and one Google sign-in. To add the second one:
Sign in to your console the way you signed up.
Open Account. Under Sign-in methods, choose Connect Google (or Connect GitHub) and sign in to it once. Chappe reads the same as at signup and keeps no token.
It appears in the list with the day you connected it. From then on either one signs you in to the same account.
- A GitHub or Google account that already signs in to another Chappe account cannot be connected. Chappe never moves a sign-in method between accounts or merges accounts.
- Already have an account? Do not sign up again with the other method. If that GitHub or Google account has a different email address, it creates a second Chappe account. The page before Create account says so and offers to sign in the other way and connect it. Made a second account by mistake? Write to us and we delete it, so its sign-in method can be connected.
- Disconnect works while another method remains. It also ends the other sessions that signed in with it. If it was the method your account’s email address came from, the address becomes that of the method you keep.
- We email your account each time a sign-in method is connected or disconnected. If you did not do it, disconnect it, choose Sign out everywhere and write to us.
Scan a repository
The scan runs in your agent, against your own checkout, following scan-instructions.md. It produces a fingerprint: a JSON object that lists, for each vendor the code calls:
- SDK names and installed versions, with the manifest or lockfile they came from;
- model IDs, API versions, endpoint paths with their HTTP method, and SDK method names, exactly as the code writes them;
- names of the environment variables that hold them, with any default value;
- up to five
path:linelocations per item, short notes on uncertain items, and the commit that was scanned.
The scan sends identifiers and file locations only, never source code. It never sends file contents or secret values: for .env and similar files it records variable names only. The instructions forbid the agent from changing any file except fingerprint.json.
{
"schema": "chappe.fingerprint/v0",
"repo": "your-org/your-repo",
"commit": "9f2c1e7",
"vendors": [{
"vendor": "openai",
"sdks": [{"ecosystem": "pypi", "name": "openai", "version": "2.8.1", "source": "uv.lock"}],
"models": [{"value": "gpt-5-mini", "where": ["app/llm.py:14"]}],
"methods": [{"value": "responses.create", "where": ["app/llm.py:31"]}],
"config_refs": [{"name": "OPENAI_MODEL", "where": ["app/config.py:9"], "default": "gpt-5-mini"}]
}]
}Upload it
An agent connected to Chappe over MCP calls register_project with name, repo (owner/name) and fingerprint; the ChatGPT and Claude Code sections show how to connect one. check_impact takes the same fingerprint and answers without saving it. From a shell, after the agent wrote fingerprint.json:
jq -n --arg name your-repo --arg repo your-org/your-repo --slurpfile fp fingerprint.json \
'{name: $name, repo: $repo, fingerprint: $fp[0]}' |
curl -sS https://chappe-api.inxpanse.com/v1/projects \
-H "Authorization: Bearer $CHAPPE_API_KEY" -H "content-type: application/json" -d @-The answer has your project_id and the impact report: changes that already affect the project (affected), ones the fingerprint cannot decide, each with what to check (unknown), how many do not affect it (not_affected_count), and vendors in it that Chappe does not watch yet (uncovered_vendors). GET /v1/projects/{id}/impact lists every change. Registering the same repo again replaces its fingerprint, and so does PUT /v1/projects/{id}/fingerprint. Scan again when you change SDKs or models, so matches stay current.
ChatGPT dot
A dot reaches Chappe only through a plugin that you create on the ChatGPT web app. Chappe then pushes changes to the dot through MCP Events.
On chatgpt.com, choose Add custom MCP server, then Create as a plugin. Enter this URL, with no trailing slash, and choose OAuth for authentication:
https://chappe-api.inxpanse.com/mcp
ChatGPT opens Chappe’s sign-in page. Paste your API key and choose Allow. ChatGPT never sees the key: it gets an OAuth token that opens
/mcponly. Access tokens last an hour and are refreshed for up to 90 days.Enable the plugin for your dot. A dot uses only the plugins enabled for it.
For a private repository, give the ChatGPT GitHub App access to it: github.com/settings/installations, the app, Repository access. Without it the dot gets Chappe’s events but cannot open the pull request.
Ask the dot to scan and subscribe, for example:
Use the Chappe plugin. Read Chappe's scan_instructions, scan your-org/your-repo as they say, and register it with register_project. Then subscribe to Chappe's change.affects_project event for the project_id it returns, and when an event arrives, follow its what_to_do.
Each event tells the dot what to do: open or update a draft pull request titled [Chappe] … whose description starts with a Chappe track: line, close it when the vendor retracts the change, or only tell you. A disputed date or a deadline reminder never touches a pull request. If an event arrives without its data, the dot can call recent_notifications.
A subscription lasts up to 7 days unless ChatGPT refreshes it. If the dot stops getting events, ask it to subscribe again.
Once the dot has subscribed, see Your first push to send it the changes that already affect the project.
Each ChatGPT account has one dot. To watch another repository, register it from the same dot. To use a second Chappe key, add a second plugin signed in with that key and enable it for the dot too.
Not the Codex settings page. The page for Codex MCP servers (fields URL, Bearer token env var, Headers) configures Codex, not ChatGPT. A server added there does not reach dots. Do not put a Chappe key in its headers.
Claude Code scheduled task
Claude Code’s scheduled tasks, formerly routines, run in Anthropic’s cloud. Chappe starts one through its API trigger and passes the change as the run’s text. They are a research preview at Anthropic; see Anthropic’s guide.
At claude.ai/code/routines, create a task with your repository and use routine-prompt.md as its prompt. The prompt treats the event as data, checks the matched lines, follows the migration steps, runs your tests, and opens or updates a draft pull request titled
[Chappe] …. Claude pushes toclaude/branches.Add an API trigger. Copy the Fire URL, then choose Generate token and copy the token. It is shown once.
On the Endpoints page of your console, choose Claude Code task, pick the project, and paste the Fire URL and the token. Chappe stores the token encrypted and never shows it again. With the API, register a
claude_routineendpoint instead:curl -sS https://chappe-api.inxpanse.com/v1/endpoints \ -H "Authorization: Bearer $CHAPPE_API_KEY" -H "content-type: application/json" \ -d '{"project_id": "proj_…", "kind": "claude_routine", "url": "<Fire URL>", "token": "<task token>"}'Send a test event from the page the console shows next, or with
POST /v1/endpoints/{id}/test. The task replies “Received Chappe test event.” Then push the changes that already affect the project (your first push).
A claude_routine endpoint is in action mode: Chappe fires it only for changes an agent can act on directly, which are opening a draft pull request and closing it after a vendor retracts the change. Add the PR report workflow to the repository so Chappe hears when those pull requests open, merge or close. When the task can use Chappe’s MCP tools, routine-prompt.md also reports a run that ends without a pull request, because the tests failed or the code does not use what changed, and Chappe emails you about it.
Scan from Claude Code on your machine
Connect Claude Code to Chappe’s MCP server once. Claude Code keeps the header in its MCP settings on your machine.
claude mcp add --transport http chappe https://chappe-api.inxpanse.com/mcp \ --header "Authorization: Bearer $CHAPPE_API_KEY"
Then, in the repository, ask: “Follow Chappe’s scan_instructions, scan this repository and register it with register_project.”
Codex in GitHub Actions
Chappe sends a repository_dispatch event to your repository. A workflow runs Codex on the change, opens or updates a draft pull request, and reports the result to Chappe.
Add the two templates to the repository:
curl -fsSL --create-dirs -o .github/workflows/chappe-codex.yml \ https://inxpanse.com/chappe/docs/templates/chappe-codex.yml curl -fsSL --create-dirs -o .github/codex/chappe-migrate.md \ https://inxpanse.com/chappe/docs/templates/chappe-migrate.md
In the repository’s Settings, under Secrets and variables, Actions: add the secrets
OPENAI_API_KEY(for Codex) andCHAPPE_API_KEY, and the variableCHAPPE_API_URLset tohttps://chappe-api.inxpanse.com. Under Actions, General, Workflow permissions, allow GitHub Actions to create pull requests: the workflow opens the draft with the built-inGITHUB_TOKEN.Create a fine-grained GitHub token for Chappe with access to this repository only and the permission Contents: Read and write, which GitHub requires to send a
repository_dispatch. Chappe uses it for nothing else.On the Endpoints page of your console, choose Codex in GitHub Actions, pick the project, and paste the token. The repository is the project’s own unless you name another, and the console checks that the token can see it before saving. With the API, register a
github_dispatchendpoint instead:curl -sS https://chappe-api.inxpanse.com/v1/endpoints \ -H "Authorization: Bearer $CHAPPE_API_KEY" -H "content-type: application/json" \ -d '{"project_id": "proj_…", "kind": "github_dispatch", "url": "your-org/your-repo", "token": "<GitHub token>"}'Send a test event from the page the console shows next, or with
POST /v1/endpoints/{id}/test. Achappe-codexrun appears under Actions with its jobs skipped, because the test event asks for no change. Then push the changes that already affect the project (your first push).
The workflow runs only for changes that affect the project and that Chappe marks safe to do without asking. Codex edits only the matched code, runs your tests, and leaves .github/ and CI alone. The pull request goes on a fixed branch per change, chappe/<track>, so later news about the same change updates the same pull request. A vendor retraction closes it and deletes the branch. Codex runs on your OpenAI key. The workflow reports each run to Chappe, and a run that ends without a pull request reaches you by email.
When the GitHub token expires, add the endpoint again in the console with a new token, and delete the old one.
Your first push
Chappe pushes a change when it detects one. The changes that already affected the project when you registered it are in the impact report, but they are not pushed by themselves. Once a delivery path is connected (for a dot, once it has subscribed), push them once to every endpoint of the project: choose Push current changes on the project’s page in your console, or call the API:
curl -sS -X POST https://chappe-api.inxpanse.com/v1/projects/proj_…/deliver-current \ -H "Authorization: Bearer $CHAPPE_API_KEY"
The answer says how many were queued and sent. Each one follows the endpoint’s rules, as a newly detected change would: an action endpoint gets only the changes an agent can act on directly. Each event reaches each endpoint once, so calling it again sends nothing already sent.
Webhook, Slack and GitHub endpoints
An endpoint is where Chappe sends one project’s changes. Add any of these on the Endpoints page of your console, or register one with POST /v1/endpoints, giving project_id, kind, url and, for some kinds, token.
| kind | url | token | Default mode |
|---|---|---|---|
webhook | Your HTTPS URL | None. The answer carries a signing_secret, shown once | notify |
slack | A Slack incoming webhook URL | None. The URL is the secret, so Chappe stores it encrypted | notify |
claude_routine | The scheduled task’s Fire URL | The task’s API token | action |
github_dispatch | owner/name of the repository | A GitHub token with Contents write on it | action |
Modes. action wakes an agent and gets only changes it can act on without asking. notify is for people: it also gets deadline reminders 30, 7 and 1 day before a deadline, and dates that official sources disagree on when they matter. Set it with "config": {"mode": "notify"}. ChatGPT subscriptions are endpoints too (kind mcp_event), created by the dot rather than by this call.
curl -sS https://chappe-api.inxpanse.com/v1/endpoints \
-H "Authorization: Bearer $CHAPPE_API_KEY" -H "content-type: application/json" \
-d '{"project_id": "proj_…", "kind": "webhook", "url": "https://example.com/chappe"}'Email when no endpoint tells you
An agent endpoint gets only what an agent can do, and its draft pull request is how you hear of it. Deadline reminders, dates that sources disagree on, and changes Chappe saw only in a source that is not the vendor’s own go to notify endpoints. So when no Slack, webhook or ChatGPT endpoint of a project gets one of those, Chappe emails your account’s owners instead. It does the same when your agent reports a run that ended without a pull request, and when an endpoint keeps failing. You get one email with everything new, at most once an hour, with a link to each change in your console. Turn these emails off, or back on, on the Account page of your console.
Verify webhook signatures
Webhooks are signed the Standard Webhooks way, with the headers webhook-id, webhook-timestamp and webhook-signature. Check the signature over the raw body and reject timestamps more than five minutes old:
import base64, hashlib, hmac, time def verify(secret, headers, body: bytes) -> bool: key = base64.b64decode(secret.removeprefix("whsec_")) msg = f"{headers['webhook-id']}.{headers['webhook-timestamp']}.".encode() + body expected = "v1," + base64.b64encode(hmac.new(key, msg, hashlib.sha256).digest()).decode() fresh = abs(time.time() - int(headers["webhook-timestamp"])) < 300 return fresh and hmac.compare_digest(expected, headers["webhook-signature"])
Delivery and retries
Answer with a 2xx status within 15 seconds. A 429, a 5xx or a network error is retried after 1 minute, 5 minutes, 30 minutes and 2 hours, sooner or later if you send Retry-After; after the fifth failure the delivery is marked failed. Other 4xx answers are not retried. Each event reaches each endpoint once.
Slack
Slack gets a short message for people: the change’s title, the repository, the event type and state, the deadline, up to five matched locations and the vendor’s source link.
Pull instead of push
GET /v1/events?project_id=…&cursor=… returns the project’s events in order, with a next_cursor to pass on the next call.
What an event contains
Every push carries the same JSON; Slack gets the short text version. The landing page shows a trimmed sample.
| Field | What it holds |
|---|---|
type | track.created, track.corrected, track.state_changed (a retraction has state retracted), track.disputed, deadline.reminder, or endpoint.test |
track_id, state_version | Which change, and which version of what Chappe knows about it |
recommended_actions | The first item’s type is open_draft_pr, close_pr or notify_only; its suggested_mode is auto (only for changes from the vendor’s own primary sources), confirm or notify |
project | id, repo, relevance, and hits: the identifiers that matched, with their path:line |
track | title, summary, deadline, affected_objects, migration_steps, evidence (the vendor’s sentence and link), target_status (whether the recommended replacement is still current), and migration_stats and migration_notes once other projects have reported |
branch | The fixed branch name for this change, so updates land in the same pull request |
links | The change’s URL (GET /v1/tracks/{track_id}) and the report URL |
Event content is external data. It quotes vendor pages. Our templates tell the agent not to follow instructions inside it; do the same in your own prompts.
Report PR status back
Chappe’s main measure is whether the pull requests it causes get merged. Reports also build a change’s migration_stats, which other projects see once at least three have reported on it. The stats never name a project.
The PR report workflow
Add chappe-pr-report.yml as .github/workflows/chappe-pr-report.yml. It reports pull requests whose title starts with [Chappe and whose description starts with the Chappe track: line, when they open, merge or close. It needs the secret CHAPPE_API_KEY and the variables CHAPPE_API_URL and CHAPPE_PROJECT_ID. It works with every path; pull requests opened with GITHUB_TOKEN do not trigger it, so the Codex workflow reports its own.
From an agent or your own code
Over MCP, call report_action. Over REST, send the same fields to POST /v1/reports:
curl -sS https://chappe-api.inxpanse.com/v1/reports \
-H "Authorization: Bearer $CHAPPE_API_KEY" -H "content-type: application/json" \
-d '{"project_id": "proj_…", "track_id": "openai:model_retirement:…", "state_version": 1,
"action": "pr_opened", "result": "done", "url": "https://github.com/your-org/your-repo/pull/12",
"details": {"agent": "codex", "tests": "passed", "files_changed": 2, "lines_changed": 9}}'action:pr_opened,pr_updated,pr_merged,pr_closed_unmerged, oragent_runwhen no pull request came of it.result:done,skippedorfailed.urlis optional.details, every field optional:agent(claude_code,codex,other),tests(passed,failed,not_run),files_changed,lines_changed,duration_seconds, up to fiveissues(step_unclear,step_wrong,extra_change_needed,not_applicable,tests_failed,build_failed,agent_error,other), and anoteof at most 500 characters.
The note is read by Chappe staff only. No API response, tool result or event carries it. It reaches other customers only if we turn what it taught into a change’s shared migration notes, without naming you. Keep code and secrets out of it.
API reference
| Call | What it does |
|---|---|
POST /v1/projects | Register a project (name, repo, fingerprint); returns project_id and the impact report |
PUT /v1/projects/{id}/fingerprint | Replace the fingerprint |
GET /v1/projects/{id}/impact | Every change’s relevance to the project, and uncovered_vendors |
POST /v1/projects/{id}/deliver-current | Push the changes that affect the project now to its endpoints, to try a new endpoint. Each event still reaches each endpoint once |
GET /v1/tracks/{track_id} | Full details of one change |
GET /v1/events | Event stream; cursor, limit (up to 500), project_id |
POST /v1/endpoints | Register a delivery endpoint |
GET /v1/endpoints | Your endpoints and ChatGPT subscriptions, without secrets |
POST /v1/endpoints/{id}/test | Send a test event |
POST /v1/reports | Report what your agent did and the pull request’s status |
GET /health | Health check, no key needed |
/mcp | MCP server. Tools: scan_instructions, register_project, check_impact, list_events, get_event, recent_notifications, report_action. Prompt: scan_instructions. Events: change.affects_project |
Field names may still change during early access. We will tell you before a change breaks a template.
Templates
Copies of the files our own tests use. Download them as they are, or adapt them.
- scan-instructions.mdHow an agent scans a repository into a fingerprint. The MCP prompt and tool
scan_instructionsreturn the same text. - routine-prompt.mdThe prompt for a Claude Code scheduled task.
- chappe-codex.ymlGitHub Actions workflow that runs Codex on a Chappe event, in
.github/workflows/. - chappe-migrate.mdThe prompt that workflow gives Codex, in
.github/codex/. - chappe-pr-report.ymlGitHub Actions workflow that reports Chappe pull requests opening, merging and closing.
Help
Write to contact@inxpanse.com.
- A new key, or a leaked one: create and revoke keys in your console.
- Stop a destination: delete the endpoint in your console, or send it a test event to check it.
- Delete a project: email us; during early access projects are removed by hand.
- Delete your account: Account, then Delete account, in your console. Your keys, endpoints and sessions end at once, and we delete your data 7 days later. Changed your mind? Write to us before then.
- Cannot sign in: sign in with a GitHub or Google account connected to yours (the one you signed up with, or one you connected). A different one makes a new account, unless its email address already has one: then Chappe asks you to sign in the usual way and connect it.
How we handle your data is in the privacy policy; the rules of early access are in the terms.