Quick Answer
OpenRouter's Auto Code router, launched 6 November 2026, costs $1.98 per benchmark coding task in OpenRouter's own published results, 74 percent less per task than a single frontier model at comparable accuracy. That low per-task cost makes a small coding service viable: a $79 bug fix that takes about five Auto Code tasks costs roughly $10.44 in API charges and fees, leaving about $68.56 before your time. The service is real, the margins are real, and so are the limits: benchmark tasks are not client jobs, and you must review every line the model writes.
Quick Answer: OpenRouter's Auto Code router, launched 6 November 2026, costs $1.98 per benchmark coding task in OpenRouter's own published results, 74 percent less per task than a single frontier model at comparable accuracy. That low per-task cost makes a small coding service viable: a $79 bug fix that takes about five Auto Code tasks costs roughly $10.44 in API charges and fees, leaving about $68.56 before your time. The service is real, the margins are real, and so are the limits: benchmark tasks are not client jobs, and you must review every line the model writes.
Key takeaways:
- OpenRouter launched Auto Code on 6 November 2026. You set the model to openrouter/auto-code, and it picks the model and reasoning effort for each coding request.
- OpenRouter's published benchmark figures put Auto Code at $1.98 per Deep SWE task, 74 percent less per task than a single frontier model at comparable accuracy.
- There is no routing surcharge: you pay the list price of the model that serves each request, plus OpenRouter's 5.5 percent credit top-up fee on the Standard plan.
- A $79 bug fix, a $149 small feature, and a $299 small build are realistic starting packages, with API costs of about $10.44, $20.89, and $41.78 in the worked examples below.
- The honest costs are your time, your review, and your testing: 2 to 4 hours per bug fix, 4 to 8 hours per small feature, and the model does not remove any of that.
- Nothing here is an income promise. Client jobs vary, benchmark tasks are controlled tests, and two jobs a month is a realistic starting pace, not a salary.
What is the service?
The service is small coding work for people who have code but no developer on call: small business owners with a website or internal tool, indie founders with a side project, and non-technical operators with a script that broke. You sell fixed-price jobs, not hours, and you use Auto Code as the engine that does the first draft of the code, while you do the reviewing, testing, and delivery.
Three job types fit this model well. A bug fix is a single broken behaviour: a form that stopped submitting, a script that fails on one input, a page that loads wrong on mobile. A small feature is one bounded addition: a retry with backoff on an API call, an export button, a new field on a form with validation. A small build is a self-contained tool: a landing page with a working form, a data cleanup script, or a small dashboard that reads one spreadsheet. Anything bigger than that, a full app, a migration, or a system with real users and real data, is out of scope for this service and should be quoted separately or turned down.
The reason Auto Code fits is the unit economics. A coding agent's cost is measured in tasks, and Auto Code's published cost is $1.98 per benchmark task. A bug fix that takes five tasks costs under $11 in API charges. That is cheap enough that the API bill stops being the constraint, and your time becomes the real cost, which is exactly how a service should work: the tool is cheap, the judgment is what the client pays for.
What does it cost to run?
The cost structure has four parts, and the table below lists them as published.
| Cost | Amount | | Auto Code per benchmark coding task | $1.98 (OpenRouter published Deep SWE figure) | | Auto Code routing surcharge | $0, you pay the served model's list price | | OpenRouter credit top-up fee, Standard plan, card | 5.5 percent, $0.80 minimum per purchase | | OpenRouter minimum credit purchase | $5, so $10 buys $10 of credit for $10.80 | | Claude Opus 5.5 API, for comparison | $4 per million input tokens, $20 per million output tokens | | Single frontier model per task, implied | About $7.62, from OpenRouter's 74 percent less figure |
The implied $7.62 per task for a single frontier model is our arithmetic: $1.98 divided by 0.26, since 74 percent less means Auto Code costs 26 percent of the single-model price. OpenRouter did not publish that dollar figure directly, and your own tasks will differ from benchmark tasks, so use it to understand the scale of the claim, not as a price you will be charged.
Your other costs are small but real. You need an OpenRouter account and an API key, which are free to create, and credit, which you buy in top-ups of at least $5. A $10 top-up costs $10.80 after the 5.5 percent fee and the $0.80 minimum, and it buys $10 of credit. That $10 covers about five benchmark tasks at $1.98 each, before the fee is counted. You also need a way to run and test code, which for most small jobs is your own computer and a free code editor, and a way to take payment, such as Stripe, PayPal, or a bank transfer, each of which takes its own fee on the money you receive. None of those costs is large, but none of them is zero either, and a service that ignores them is lying about its margins.
What do you charge?
Fixed packages work better than hourly billing for this service, because clients want to know the price before they say yes, and you want to be paid for the result, not for the hours the model saved you. The table below gives three starting packages, with the task budget and the API cost for each, worked on OpenRouter's published $1.98 per task figure. These are illustrations, not promises: real jobs vary, and a bug that looks simple can take twice as many tasks as you expected.
| Package | Price | Task budget (illustration) | API cost at $1.98 per task | Top-up fee at 5.5 percent | Total direct cost | Margin before your time | | Bug fix | $79 | 5 tasks | $9.90 | $0.54 | $10.44 | $68.56 | | Small feature | $149 | 10 tasks | $19.80 | $1.09 | $20.89 | $128.11 | | Small build | $299 | 20 tasks | $39.60 | $2.18 | $41.78 | $257.22 |
Read that table carefully, because the margin column is not profit. It is what is left after the API bill and before everything else: your time, payment processing, and the jobs where the model fails and you spend an extra evening fixing it yourself. A bug fix at $79 with a $10.44 direct cost looks like an 87 percent margin, but if it takes you three hours including review and testing, you earned about $23 an hour before payment fees. That is a fair rate for starting out, and a poor rate if you could earn more doing something else. Price the packages for your time, not for the API cost, because the API cost is the smallest number in the whole business.
A realistic starting month looks like this, as an illustration only. Two bug fixes at $79 and one small feature at $149 bring in $307. The direct costs are two times $10.44 plus $20.89, or $41.77. That leaves $265.23 before your time and payment fees. The time is roughly 4 to 8 hours for the two bug fixes and 4 to 8 hours for the feature, so 8 to 16 hours of work for the month. At the low end that is about $33 an hour before fees, at the high end about $17. Those are honest numbers for a side service finding its first clients, and they are a long way from a full-time income. Do not promise yourself, or anyone else, more than that.
How do you deliver a job, step by step?
A small coding service lives or dies on its process, because the model will happily produce code that looks right and fails in ways you only find when a real user tries it. Follow the same steps every time.
First, scope the job in writing before you touch any code. Ask the client for the exact behaviour that is broken or wanted, one example of it failing or one sketch of what good looks like, and access to the code or a copy of it. If they cannot describe the job in two sentences, it is not a $79 job, and you should say so before you start.
Second, reproduce the problem yourself. Run the code, trigger the bug, and confirm you see the same failure the client sees. If you cannot reproduce it, stop and ask for more information instead of guessing. A model given a vague bug report will fix the wrong thing with confidence.
Third, let Auto Code do the first draft. Set the model to openrouter/auto-code in your coding tool or API call, describe the fix or feature, and let the router pick the model for each turn. Keep the task small: one fix, one feature, one file at a time where possible. Small tasks keep the router's choices cheap and make the result easier to check.
Fourth, review every line yourself. Read the diff, not the summary. Check that the change does what was asked and nothing else, that it handles the edge cases the client actually has, and that it does not introduce a new dependency or a security problem, such as unsanitised input or a hardcoded secret. The router's job is to pick a model, not to guarantee the code. That part is yours, and it is what the client is paying for.
Fifth, test it the way a user would. Run the existing tests if the project has them. Then test the exact scenario the client described, plus one input they did not mention. If the project has no tests, write a small one for the behaviour you changed, and leave it in the project: it is the cheapest insurance you can give a client.
Sixth, deliver with a short note. Say what changed, what you tested, and what to watch for. Include the cost of the job in your own records, how many tasks it took, and what it cost in API charges, so your pricing gets better with every job. Then ask for a testimonial while the result is fresh, because the next client will ask for proof.
What can go wrong?
Six things, and you should tell clients about the first three before they pay.
First, benchmark tasks are not client jobs. Deep SWE is a controlled test with a clear task and a clear pass condition. A client's codebase has undocumented behaviour, missing tests, and dependencies that have not been updated in two years. The $1.98 per task figure is a benchmark cost, and a real job can take twice as many tasks, or half as many. Budget for the task count to be wrong, and do not quote a fixed price on a job you have not seen.
Second, the router picks the model, not you. Auto Code weighs pass rate, speed, and cost per solved task, and it changes its mix as new models arrive. Most of the time that is a benefit. Sometimes it will pick a cheaper model for a turn that needed a stronger one, and you will spend an extra turn fixing the result. That is still cheaper than running the strongest model on every turn, but it is not free.
Third, the model can write confident, wrong code. It can invent an API that does not exist, use a library version the project does not have, or fix the symptom while leaving the cause in place. Your review is the product. If you skip it, you are selling the model's output, not a service, and the first failure will cost you the client.
Fourth, access and trust are the real barriers. Clients have to give you their code, and many will not, or should not, without a clear agreement about what you can see and what you will do with it. Get that in writing before you start, keep their code private, and never reuse one client's code for another.
Fifth, payment and scope disputes happen. A fixed-price job invites the client to add one more small thing, and then another. Put the scope in writing, charge for anything outside it, and take a deposit before you start. Half up front is a reasonable rule for a new service.
Sixth, this is a new router, and new routers change. OpenRouter launched Auto Code on 6 November 2026, and the routing mix, the benchmark results, and the cost per task will move as models are added and reruns happen. Check the published benchmark page when you reprice your packages, and do not build a price list that assumes today's $1.98 figure will hold forever.
Who should try this, and who should not?
Try it if you can already read and write code well enough to review someone else's work, and you have a way to reach people with small coding problems, such as a local business network, a freelance profile, or a community you are already part of. The first three clients are the hard part, and they will come from people who already trust you, not from a listing. Offer the first bug fix at a clear fixed price, deliver it well, and ask for a testimonial and a referral.
Do not try it if you cannot review code yourself. The whole service is the review, and a model that writes code you cannot judge is a liability, not an asset. Do not try it either if you need income this month: two or three small jobs is a realistic first month, and the revenue in the illustration above is a side income, not a salary. And do not sell it as AI magic. The honest pitch is the one that keeps clients: a small coding job, done by a person who uses a cheap, capable tool and checks every line, at a fixed price, with a test to prove it works.
Sources: OpenRouter, "Introducing the New Auto and Auto Code Routers", 6 November 2026; OpenRouter Auto Code model page, as reported 6 November 2026; Anthropic pricing page, Claude Opus 5.5 at $4 input and $20 output per million tokens, as reported 3 November 2026; OpenRouter pricing page and FAQ, 5.5 percent card top-up fee and free model limits, as reported 22 October 2026.
Internal links: Category hub: https://www.topuseai.com/blog | Related live posts: https://www.topuseai.com/blog/sell-research-agent-service-deepseek-search-075-calls | https://www.topuseai.com/blog/sell-ai-video-service-aivideofree-free-credits-12-models
Frequently Asked Questions
What is OpenRouter Auto Code?
Auto Code is a router for coding agents on OpenRouter, launched on 6 November 2026. You set the model to openrouter/auto-code, and it picks the model and reasoning effort for each request, billing you at the served model's list price with no routing surcharge.
How much does an Auto Code coding task cost?
OpenRouter's published Deep SWE benchmark figure is $1.98 per task, 74 percent less per task than a single frontier model at comparable accuracy. Those are benchmark figures, not a guarantee for client jobs, which can take more or fewer tasks.
What can I charge for a small coding service on Auto Code?
Realistic starting packages are a $79 bug fix, a $149 small feature, and a $299 small build. At OpenRouter's $1.98 per task figure, the direct API costs in the worked examples are about $10.44, $20.89, and $41.78, before your time and payment fees.
Do I need to know how to code to sell this service?
Yes. The service is the review: reading the diff, checking edge cases, and testing the result. If you cannot judge the code yourself, you are selling the model's output, not a service.
How do I get my first clients?
Start with people who already trust you, such as a local business network, a freelance profile, or a community you belong to. Offer one fixed-price bug fix, deliver it well, and ask for a testimonial and a referral.
What is the biggest risk in this service?
Scope and quality. A job that looks simple can take twice as many tasks as expected, and the model can write confident code that is wrong. Scope every job in writing, review every line, test the exact scenario the client described, and never promise an income figure.



