What do AI labs pay for code?

This is the only page on this site with money on it, apart from the calculator. That is deliberate. Everywhere else the numbers would go stale and there would be no way for you to check them.

The rates

Pricing is per million tokens, and the two things in your repository are priced separately.

Those are standing rates on the programme this site points at, last checked on 14 September 2026. They are paid to the code owner rather than split with anyone. They sit in the licensing agreement and can change on thirty days’ notice, never retroactively.

If you want to check the arithmetic against your own repositories, the repo value calculator applies exactly these figures.

Why the lower-rated thing is worth more

Source is priced higher per token. History is worth more in total, because there is so much more of it.

A repository’s commit history typically runs to something like twenty times the token volume of its final source. Every commit carries a diff, a message, and a position in a sequence. Years of that adds up to far more text than the code it produced.

a repository, by token volume
  │
  ├── source ......  ~5%   @ $100/M ──► the smaller number
  │
  └── history .....  ~95%  @  $40/M ──► most of the money

This has one practical consequence and it is the most useful thing on this page: do not tidy your history before offering a repository.

Squashing commits, rewriting a branch, or starting a clean repository to make the work look presentable deletes the majority of what you are being paid for. The instinct to clean up before showing someone your code is exactly wrong here.

What that comes to on a real archive

Rather than invent a scenario, here is what published network-level figures look like on the programme this site points at, as of the date above.

Across the network: about 600,000 US dollars paid out to date, across 380 repositories. That is a little over 1,500 dollars per repository, against roughly 13.6 billion tokens, of which about 4.5 per cent was source and 95.5 per cent was history.

One agency on that network: about 130,000 dollars to date across 22 repositories, on roughly 3.1 billion tokens with a similar split.

Two things to take from that. First, the per-repository figure is meaningful but not life-changing, and anyone presenting this as a windfall is selling you something. Second, the arithmetic is dominated by history in both cases, which is the same conclusion from a different direction.

┌─ WORTH CHECKING ─────────────────────────────────────────────────────┐
│                                                                      │
│  Private, finished, owned by you, and doing nothing.                 │
│                                                                      │
│  [ See what your repos are worth ]                                   │
│                                                                      │
└──────────────────────────────────────────────────────────────────────┘

The bit that gets left out

Your codebase does not get valued exactly as you hand it over. It gets prepared first, and preparation includes writing the tests the project never had.

That work is done at no cost to you, and the volume it adds counts towards what you are paid. Which produces a slightly odd but genuinely true outcome: the repository you submit comes back as a better asset than the one you offered, and you are paid on the larger version.

It also means an honest back of the envelope estimate tends to come in below the real number rather than above it, which is an unusual direction for this kind of thing to run.

What moves your number

Volume of history. Years of real commits on a codebase that was actually maintained. This is the big one.

Repository size. Obvious, but less decisive than people assume, because a large repository that is mostly vendored framework code is counted down to what is actually yours.

What gets excluded. Generated files, vendored dependencies, binaries, data dumps, and third-party code do not count. Neither does anything that was previously public or forked from something public, because it is already collected.

Language scarcity. There is an enormous amount of public JavaScript in the world and much less public code in the older stacks quietly running large companies. Scarcity is the whole economic argument, and it cuts in favour of unfashionable languages.

What it does not depend on

Code quality, in the sense you are worrying about. Nobody is grading your naming. Realism is the point, and a codebase full of pragmatic workarounds written under deadline is more useful as training data than something immaculate, not less.

The honest caveats

Licensing is demand-driven. Your code being eligible does not mean it will be licensed, and nothing here is a guarantee of a sale. The timeline is real: preparation takes from a few hours to about four weeks, presentation to buyers typically runs two to sixteen weeks after that, and payment lands within fifteen days of the buyer paying.

You also carry a real obligation. You are warranting that you own or have the right to license everything you submit. If that turns out to be wrong you can be asked to return payments and cover the resulting claims, and that liability is uncapped, because buyers are relying on the same assurance. That is not a reason to avoid this. It is a reason to be certain about ownership before you submit anything, which is why who owns the code you wrote for a client matters more than any figure on this page.

What to read next

• What disqualifies a repo, the filter to run before you get attached to a number
• Repo value calculator, the same rates applied to your own archive
• Your MIT-licensed repo is worth nothing, on why public code is not part of this at all