Docs

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

  1. Get an API key. Sign up with GitHub or Google and copy your key.

  2. 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.

  3. 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.

  4. 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 agentHow Chappe reaches it
ChatGPT dotMCP Events, through a ChatGPT plugin you create
Claude CodeA scheduled task (routine) with an API trigger
CodexA GitHub Actions workflow started by repository_dispatch
Your own serviceA signed webhook
Your teamA 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 429 with a Retry-After header. 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:

  1. Sign in to your console the way you signed up.

  2. 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.

  3. 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:line locations 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.

Sample, trimmed
{
  "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.

  1. 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
  2. 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 /mcp only. Access tokens last an hour and are refreshed for up to 90 days.

  3. Enable the plugin for your dot. A dot uses only the plugins enabled for it.

  4. 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.

  5. 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.

  1. 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 to claude/ branches.

  2. Add an API trigger. Copy the Fire URL, then choose Generate token and copy the token. It is shown once.

  3. 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_routine endpoint 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>"}'
  4. 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.

  1. 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
  2. In the repository’s Settings, under Secrets and variables, Actions: add the secrets OPENAI_API_KEY (for Codex) and CHAPPE_API_KEY, and the variable CHAPPE_API_URL set to https://chappe-api.inxpanse.com. Under Actions, General, Workflow permissions, allow GitHub Actions to create pull requests: the workflow opens the draft with the built-in GITHUB_TOKEN.

  3. 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.

  4. 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_dispatch endpoint 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>"}'
  5. Send a test event from the page the console shows next, or with POST /v1/endpoints/{id}/test. A chappe-codex run 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.

kindurltokenDefault mode
webhookYour HTTPS URLNone. The answer carries a signing_secret, shown oncenotify
slackA Slack incoming webhook URLNone. The URL is the secret, so Chappe stores it encryptednotify
claude_routineThe scheduled task’s Fire URLThe task’s API tokenaction
github_dispatchowner/name of the repositoryA GitHub token with Contents write on itaction

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.

FieldWhat it holds
typetrack.created, track.corrected, track.state_changed (a retraction has state retracted), track.disputed, deadline.reminder, or endpoint.test
track_id, state_versionWhich change, and which version of what Chappe knows about it
recommended_actionsThe 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
projectid, repo, relevance, and hits: the identifiers that matched, with their path:line
tracktitle, 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
branchThe fixed branch name for this change, so updates land in the same pull request
linksThe 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, or agent_run when no pull request came of it.
  • result: done, skipped or failed. url is optional.
  • details, every field optional: agent (claude_code, codex, other), tests (passed, failed, not_run), files_changed, lines_changed, duration_seconds, up to five issues (step_unclear, step_wrong, extra_change_needed, not_applicable, tests_failed, build_failed, agent_error, other), and a note of 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

CallWhat it does
POST /v1/projectsRegister a project (name, repo, fingerprint); returns project_id and the impact report
PUT /v1/projects/{id}/fingerprintReplace the fingerprint
GET /v1/projects/{id}/impactEvery change’s relevance to the project, and uncovered_vendors
POST /v1/projects/{id}/deliver-currentPush 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/eventsEvent stream; cursor, limit (up to 500), project_id
POST /v1/endpointsRegister a delivery endpoint
GET /v1/endpointsYour endpoints and ChatGPT subscriptions, without secrets
POST /v1/endpoints/{id}/testSend a test event
POST /v1/reportsReport what your agent did and the pull request’s status
GET /healthHealth check, no key needed
/mcpMCP 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_instructions return 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.