Old source code is worth something for a simple reason: a team of people spent real time solving real problems, and the result is a record of how working software gets built. When the product stops, that record does not disappear. It sits in a repository nobody opens, but it still holds the design choices, the bugs, the fixes and the lessons. For AI training and research, that is exactly the kind of material that is in short supply.
This guide explains where that value comes from, what makes one codebase worth more than another, and why “it never made money” is a different question from “is it worth anything”. There are no price figures here. The honest answer to “how much” is a concrete cash offer after a review, and the factors below are what drive it.
Why does code from a dead product still have value?
A product can fail for many reasons that have nothing to do with the code. The market was too small, funding ran out, a competitor got there first, the founders moved on. In each case, the code itself may be perfectly good. It still compiles, or nearly does. It still shows how authentication was handled, how payments were wired up, how a tricky data model evolved over three years.
There are now two separate uses for software. The first is running it as a product, which needs customers and revenue. The second is learning from it, which needs only the code and its history. Odys AI Labs, the research and development arm of Odys, buys code for the second use. It uses the code for AI training and R&D: models learn to read, write and fix real software by studying how real teams wrote and fixed it.
That second use does not care whether the product is still online. A shut-down SaaS, a mobile app pulled from the store, a game that was shelved before release, an internal tool a company retired: all of them are real software written under real constraints.
Why is private, real-world code scarce?
Most of the code that AI research has used so far is public. The largest open code dataset, The Stack v2, is built from public repositories: about 67.5 TB across more than 600 languages, drawn from 104.2 million GitHub repositories. Software Heritage holds over 30 billion unique source files from about 448 million projects as of October 2026, and its stated mission is to collect all software that is publicly available in source code form.
Public text is running short as well. Researchers at Epoch AI estimate the public stock of human-written text could be fully used between 2026 and 2032. Once public material has been used, new learning has to come from somewhere else.
Private code is that somewhere else. The code behind a closed startup, a retired product or an agency’s own tool was never published, so it is not in any public dataset. Public code datasets also come with license terms and opt-outs; private code is not in them at all. That is what makes a real, private codebase scarce, and scarcity is a large part of value.
There is a second reason code matters. Research published as To Code, or Not To Code? found that code in training data improves a model’s reasoning, not just its coding, with gains reported in natural language reasoning and world knowledge as well as code performance. Code is useful well beyond programming tasks. Our guide on why real-world code matters for AI training and R&D goes deeper.
Who buys old code, and what happens to it?
On this site the buyer is Odys AI Labs. It buys the source code of software people no longer use, pays cash, and uses the code for AI training and R&D after it has been cleaned. We may also work on it with research partners. The seller’s brand and name are never used, the product is never relaunched as theirs, and we do not publish who we buy from.
Before anything moves, a written agreement is signed. Secrets, keys and personal data are removed before transfer, and we help with that. We never take databases, user records, customer data or chat logs. What is transferred is the code your team wrote, plus the material around it that explains it.
What makes one codebase worth more than another?
The factors are the same ones any careful buyer would look at: size, originality, languages, quality, history, docs and tests, and whether the rights are clear. Here is what each one means in practice.
| Factor | What raises value | What lowers value |
|---|---|---|
| Originality | Most of the code was written by your own team | Mostly copied libraries, templates or generated code |
| Completeness | A full product: backend, frontend, APIs, admin tools | Fragments, snippets or a half-started prototype |
| Size | Many thousands of original lines across real features | A small repo with a few screens |
| History | Full git history with commits, branches and pull requests | A single zip file with no history |
| Docs and tests | A test suite, README files, runbooks, architecture notes | No tests, no explanation of how anything works |
| Languages | Mainstream or less common languages used properly | Mostly markup or configuration files |
| Rights | You own it, or can sign for the company that does | Client work you have no rights to, unclear contractor terms |
None of these needs to be perfect. A codebase with modest tests but a long, honest history can be worth more than a tidy one with no history at all. Our pillar guide on how codebase value is measured explains each factor in detail and how each can be checked without anyone seeing your code.
Why original code matters most
A buyer of code for research is paying for what only your team could have written: the business logic, the data model, the fixes for problems specific to your product. The open-source libraries underneath are normal (Black Duck found open source in 98% of the commercial codebases it audited for its 2026 report), they do not stop a sale, and nobody needs them from you because they are already public. They stay under their own licenses; what is sold is the original code.
So when you think about size, think about the code your team actually wrote. Exclude the node_modules folder, vendored libraries, minified files and anything a generator produced. The guide on counting lines of code shows how to do that with free tools such as cloc and tokei.
Why history is worth so much
A single snapshot of a codebase shows what the software looked like at the end. Git history shows how it got there: which bug was fixed in which commit, why a design was changed, what a reviewer objected to in a pull request. For learning how to fix software, that sequence is the most instructive part. Our guide on why git history makes old code worth more covers how to check you still have it.
Why does “it never made money” not mean “worthless”?
Software marketplaces and brokers sell running businesses. They price on revenue or profit, so a product with no revenue usually has little to offer them, and that is fair: their buyers want income. A profitable, running software business belongs with them, not with us.
Code bought for AI training and R&D is judged on different grounds. Revenue is not one of the factors. A startup that burned through its funding and never found customers may still have built a large, well-tested, original product over several years. In fact, software still making money is exactly what we do not buy.
Consider an illustration. Suppose a two-person team built a scheduling SaaS over four years, with about 60,000 lines of their own TypeScript and Python, a test suite, a full git history and a folder of design notes. They never passed a handful of paying customers and shut the service down. On a marketplace, that product would struggle to list. As real-world code for research, it has most of what a reviewer looks for.
What rules code out, or lowers its value?
Being clear about what does not qualify saves everyone time. We pass on:
- Software that is still making money, online or offline.
- Client work the seller has no rights to.
- Open-source forks, templates and tutorial projects.
- Repositories that are mostly copied libraries or generated code.
- Databases, user records and chat logs, which we never take in any deal.
Rights are the most common gap. Code written by employees usually belongs to the company, and code from outside contractors often needs a signed assignment before the company owns it. The details depend on the country and the contracts involved; our guide on who owns the code explains the basics. This is general information, not legal advice, and a qualified lawyer can confirm the position for your specific case.
What matters less than owners expect?
Owners often underrate their own code for the wrong reasons. A few common worries that usually matter little:
- An old framework or language version. Older stacks still show real design and real fixes, and less common languages can be more interesting, not less.
- Messy code in places. Real production code is rarely tidy. Bugs and the commits that fixed them are useful material.
- An unfinished interface. If the backend, data model and logic are complete, a rough front end does not erase the work.
- Years on the shelf. Code does not rot in a repository. A sunset product from years ago can be as useful as one closed last month.
- Open-source dependencies. As above, these are normal and do not stop a sale.
How can you get a first sense of value without showing your code?
You can answer most of the important questions yourself in an afternoon, without sending a single file to anyone:
- List what you have. Every repository, where it is hosted, and whether you still have admin access.
- Estimate original size. Use cloc or tokei on your own machine, excluding third-party folders, if you want a number. Nobody needs you to run anything for an offer.
- Check history. Is the full git history still there, including branches and pull requests, or only a zip?
- Gather the extras. Docs, tests, ticket exports from Jira, Linear or GitHub Issues, design files and runbooks.
- Confirm rights. Who wrote the code, under what contract, and who can sign today.
The free code value check turns those answers into a first verdict in a couple of minutes. Our page on how we evaluate a codebase explains what we look at; how we value a codebase is explained on the call.
A word of caution. A fair buyer never needs your code before a contract and never asks you to run a script on a machine that holds your code or credentials. If anyone does, stop. The product’s old website may also still have value of its own; if it kept organic traffic, TheBlueOceanWebsites.com buys websites of former businesses.
Selling is also not the only route. Archiving, open-sourcing and deleting each have their place, and some of those choices cannot be undone. The guide to selling, archiving, open-sourcing or deleting code you no longer use lays out the trade-offs.
What to do next
- Write down every repository you still control, with its rough size and whether history is intact.
- Note who wrote the code and who can sign for it today.
- Send us a few details for a free code valuation: no code, no obligation, a concrete cash offer after review if it fits.
Frequently asked questions
Is the code of a failed startup worth anything?
Often, yes. The company failed, but the code still records how a team designed, built and fixed a real product over months or years. That kind of private, real-world code is useful for AI training and R&D, which is a different use from running the product. What matters is whether the code is original, complete, comes with history and docs, and whether you have the right to sell it.
Does old code lose value because the framework is outdated?
Less than most owners expect. An app written in an older version of a framework still shows real design decisions, real bugs and real fixes. For research use, the age of the stack matters much less than whether the code is original and complete. Code in older or less common languages can still be interesting, because less of it tends to be available.
Can I sell code from a product that never launched?
Usually, yes, if it is a complete or nearly complete product and your team wrote it. A product that never reached customers can still have a full codebase, a git history, tests and design files. What does not usually qualify is a handful of snippets, a tutorial project or a template with a few changes. Never launched and never finished are not the same thing.
Do I have to send my code to find out what it is worth?
No. A fair first assessment is made from what you tell us: the kind of product, the languages, the rough size, how much your team wrote, whether you have history, docs and tests, and who owns the rights. No code changes hands before a written agreement is signed, and nobody should ask you to install or run anything to get an offer.
Why would anyone pay for code from a product nobody uses?
Because the buyer is not trying to run the product. Odys AI Labs, the research and development arm of Odys, uses real-world code for AI training and R&D, so models learn to read, write and fix real software. For that purpose, a product that stopped is just as instructive as one still running, and private code that has never been published is the hardest kind to find.
Find out what your old code is worth right now.
Tell us about the product in about a minute. No code needed. We review the details and come back with a cash offer or a plain no.
Get my free code valuation →