Privacy policy

What we read, and what we keep.

iterative reads your repository during a scan and keeps the text it wrote about it. It does not keep your code. This page is the long form of that sentence, written from the code that enforces it.

Last updated 2026-10-03
01

What the App may touch

The GitHub App holds two permissions and they are the whole surface: Contents: read, to read the repository during a scan, and Issues: write, to open the issue and set its severity label.

It never opens a pull request, never pushes a commit, a branch or a status check, and never writes code into your repository. There is no route in the product that does any of those things.

Which repositories it can see is decided on GitHub's own installation screen, not in a settings page of ours, and only while the App is installed.

02

What happens to your code during a scan

The repository arrives as a tarball from GitHub's API, is read into memory, and is seeded into a workspace that exists for that one scan. Nothing uploads it: no route in the product accepts repository bytes, and the only object-storage operations the product performs are list and delete.

Deletion runs on the scan's terminal path, so a scan that failed, was cancelled or was abandoned mid-run is swept exactly like one that finished. A superseded attempt is swept again when the next one claims the scan. That is purgeScanArtifacts in packages/worker/src/artifacts.ts, called from every terminal transition in packages/worker/src/db.ts.

03

What is stored

Findings, scan records and billing rows, in a Cloudflare D1 database. Specifically:

  • Findings, as text: the bug's shape and severity, the title, the prose sections of the report, the file path and the line numbers, the short annotated excerpt the filed issue itself prints, and the replacement code the report recommends.
  • The attribution that report rests on: the commit that introduced the buggy lines, the GitHub login it is attributed to (or, when no GitHub account claims the commit, its git author name), the date, the first line of its message, and at most 40 lines of that commit's diff around the buggy lines, read through GitHub's REST API for those lines only.
  • Scan metadata: repository owner and name, the commit scanned, what triggered the scan, its state, its timestamps, its events, and the error a failed scan left behind.
  • While a scan is running, which parts of the tree it has checked: each part's file paths, and the findings that part reported, as text, so a scan that runs in several stretches picks up where it stopped. They are deleted when the scan ends.
  • A bounded window of what the analysis wrote, kept so a failed scan can be diagnosed: the first 8,000 and the last 24,000 characters of the model's output, with verbatim source values replaced by `[source elided]` before it is stored.
  • Model usage per request: the model id, token counts, cost and status. The provider's usage objects are kept verbatim, and prompt content is not part of them.
  • Identity: the GitHub user id and login of whoever signs in, which installations they may administer, and browser sessions stored as the SHA-256 of the cookie value, so a dump of that table is not a login. The OAuth access token is used once, inside the callback, and never stored.
  • Billing records: the Stripe customer id, the entitlement state, and one row per scan saying whether it was the free scan or a paid one, what a paid one was quoted and charged, the Stripe payment and refund ids, and what was refunded.
04

What is never stored

  • Your repository, in whole or in part, beyond the excerpts named above: the lines an issue in your repository already shows, the introducing commit's diff around the buggy lines, or lines a running scan reported and has not yet verified, which are deleted when the scan ends.
  • A user access token, a password or an SSH key. There is no password here to store.
  • Card numbers. Stripe holds the payment method; this product stores Stripe's ids and the state they are in.
  • Anything a scan read and did not report on.
05

Who else sees it

Five sub-processors, and they are the five the code calls:

  • GitHub: identity, the App installation, the repository read, and the issues filed.
  • Anthropic: the model that performs the analysis. This is the one place repository text leaves the scan's workspace: the analysis sends the code it is reading to Anthropic through iterative's own model routing layer. That layer forwards each request to Anthropic and keeps no copy of the code; it records only usage metadata: the model, token counts and timing.
  • Cloudflare: hosting, the database that holds the text above, and the object storage that every terminal scan transition sweeps.
  • Stripe: payments and the customer portal.
  • PostHog: product analytics, on PostHog's US cloud. Two things feed it. iterative's own servers send it a record of account events: a sign-in, an installation, a repository added or removed, a scan schedule chosen during onboarding or changed later, an issue format edited or reset to the default, a scan requested, finished or failed, an issue filed, a card saved, a charge, a declined charge, a refund, or a dispute opened or closed. Each carries GitHub's numeric ids for the person, the installation and the repository, the GitHub login, and counts such as the characters a scan read or the length of an issue format. A failed scan carries one of five fixed reasons, never the error's text, and a filed issue carries its bug shape and severity. And signed-in pages of app.iterative.sh send which page you opened and which button you pressed, with page addresses cut to their route. It never receives repository content, code, file paths, finding text, an issue's title or an issue format's text.

There is no sixth. If one is added, it is named here before it runs.

06

The websites

iterative.sh runs no third-party script: there is no analytics, no tag manager and no advertising pixel. Signed-in pages of app.iterative.sh run one analytics script, PostHog's, served from app.iterative.sh itself and reporting to app.iterative.sh, which forwards to PostHog. It stores nothing in your browser: no cookie and no local storage. The only other client JavaScript is the dashboard's own few lines that load older rows of a table from the same host as you scroll it. The one cookie is iterative_session, set after you sign in with GitHub: HttpOnly, Secure, SameSite=Lax and scoped to the app domain.

The pages load three web fonts from Google Fonts, so Google sees the request your browser makes for them, with whatever a font request carries: your IP address and user agent. Beyond that and the analytics script named above, nothing about your visit is sent anywhere.

07

How long it is kept, and how to have it deleted

Findings and scan records are kept while the installation exists, because they are what makes "never the same bug twice" hold across scans. Uninstalling the App on GitHub marks the installation removed and stops every new scan; it does not delete those rows.

To have a tenant's stored text deleted, email hi@iterative.sh. It is done by hand: there is no self-serve delete button yet, and claiming one would be the sort of thing this page exists to avoid.

The issues iterative has already opened live in your repository. They are yours. Close or delete them as you would any other issue.

08

Changes, and how to reach us

This page carries a last-updated date and a change moves it. The retention sentence beside these sections is quoted from the product's published promise; it is not reworded here.

Questions about this policy, about the permissions, or a deletion request go to hi@iterative.sh, which is this product's support route.

Do you store our code?

No. The repository is cloned into an ephemeral workspace, scanned, and the workspace is destroyed. What persists is text - a path, a line number, and prose.

Published on the landing page, quoted here without a word changed. Every section on this page names where that holds in the code.