SmolVLA API pricing: no public price exists, so here is the real cost per call and per robot hour

SmolVLA API pricing has no public number to look up. As of 26 October 2026, no marketplace sells hosted SmolVLA access at a published rate. The big model hosts carry none of it, and the one new platform that covers it publishes no rate. The weights are open and Apache-2.0, so the real price today is a rented GPU by the hour, or this platform's written record, which sets a per-call rate at the floor of its list. This page shows every dated check, then works the per-call and per-robot-hour math.

Last verified: 2026-10-26

What you are actually trying to price

SmolVLA is a small vision-language-action model from Hugging Face. It reads camera images, the joint positions of a low-cost arm, and a task sentence. It returns the motor commands for the next stretch of motion. The paper is called SmolVLA: A Vision-Language-Action Model for Affordable and Efficient Robotics. It was released in June 2025. The open checkpoint, lerobot/smolvla_base, carries 450 million parameters and has been downloaded more than 163,000 times. The full capability record is on the model's own page: smolvla.

One property of the checkpoint fixes its pricing unit. A call does not return text. It returns an action chunk. The checkpoint's own config file sets chunk_size to 50 and n_action_steps to 50. One served call plans 50 steps of motion. That number is not a request option. It is part of the training setup. Any hosted price for this model is therefore a price per call. One call buys about 1.7 seconds of motion on a 30 frame per second camera stream. The official LeRobot guide rolls the model out with cameras configured at 30 frames per second, which is the convention this site uses for all its robot math.

One name note before the money. Searchers mix up SmolVLA with SmolVLM. SmolVLM is a family of small vision-language models that describe images and text. SmolVLA is the robot policy built on that backbone. If a page you find talks about SmolVLM tokens and chat, it is the wrong page for robot pricing.

The host census, checked today

People search "smolvla api pricing", "smolvla api cost", "smolvla hosted api", and "smolvla inference api". Every one of those queries wants a rate card row. None of them returns one. Here is what each place that looks like a seller actually offers, checked on 26 October 2026.

Three honesty notes on this table. First, every row carries its own date because host states move. The Hugging Face inference check re-proves the original research census of 2026-10-25. That census found the same absence. Second, the last two rows are new platforms that did not exist when most "nobody hosts robot models" claims were written. One of them, abstract.inc, publishes a full rate card, read today. Its rows cover other robot models, billed per million tokens in and per million actions out. Its hour estimates are computed on a 30 Hz loop of 108,000 actions. SmolVLA has no row there. The other, Robotic Inference, covers SmolVLA but gates access by invite and publishes no rate on any page we could read. Third, the lesson in those two rows is the shelf life of absence claims. Any sentence on the web that says nobody will ever host this model is a prediction, not a fact. This page states what is true today, with dates.

What the absence is not: a license wall. The checkpoint is Apache-2.0. Anyone may serve it commercially, royalty free. What is missing is a seller who has done the serving work and published a rate.

What self-hosting costs instead

With no public rate to buy, the open weights are the path you can price today. The publisher's own materials set the envelope. The release post says the model is small enough to run on a CPU, to train on a single consumer GPU, or even a MacBook. The official docs give the one hard figure: a 20,000-step fine-tune takes about 4 hours on a single A100. And the model is a base checkpoint, so the fine-tune is not optional. The docs recommend about 50 recorded episodes of your task before training. They note that 25 episodes were not enough in the publisher's own tests.

The card-rental side of that path, named parties, read 26 October 2026 on the RunPod pricing page: the 24 GB tier rents at 0.27 to 0.89 per hour, and the serverless A100 tier at 2.72 per hour. Rates move. Treat every rate as a snapshot with a date. Two worked anchors follow from those numbers. Serving, if your card of choice is a 24 GB class part, costs the hourly rate plus your setup time. Fine-tuning at the docs' own figure costs about 4 A100 hours, which is roughly 11 in card time at the rate above.

To compare a card hour with a per-call API, you need one more input: the time one call takes on your card. The release post reports the model's async mode cuts response time by 30 percent and doubles task throughput. The publisher publishes no per-card milliseconds. So keep the comparison symbolic:

GPU cost per call  =  R x t / 3600

R: hourly rate for the card, from a dated price page
t: seconds per call, from a benchmark you trust for your setup

One sensitivity line. Idle time, restarts, and your own engineering sit on top of the raw card time, so treat the formula's output as a floor at full duty, never a bill. The deeper local-versus-hosted treatment, with amortization and break-even tables, is the VLA break-even guide.

The platform's written record

This platform keeps a written record for the smolvla model id on its action route. The facts of that record, as of 26 October 2026: the row sits in the platform's model data. Metering is per call. The rate is set at the floor of the list. The model is not on the public list, and no date attaches to that. Only listed rows render in the table below, and the models index is the live catalog. A written record is not a launch.

Budgeting that record is arithmetic on named inputs:

cost per robot hour  =  C x P
monthly spend        =  Rh x C x P
worst case           =  the prepaid wallet balance W

C:  calls per robot hour, from your loop (2,160 at the SO-arm convention)
P:  per-call rate, read off the live table for a listed row
Rh: robot hours per month
W:  wallet balance, the hard stop on spend

The numeric form. At 30 frames per second with chunks of 50, one robot hour holds 2,160 calls, so the written-record rate for the smolvla model id yields 2.16 per robot hour. Work it forward from there. A hobby arm working 10 hours a month spends about 22. A 160-hour work month runs about 346. The same site convention prices the pi0.5 class at 6.48 per robot hour and the flagship class at 10.80. This row is the budget end of the card. One sensitivity line: halve the chunk and you double the hourly bill at any fixed per-call rate; double the chunk and you halve it. The full derivation, with the hardware side, is the robot inference cost report.

The wallet floor is the point of the shape. An unattended robot loop cannot run up a credit line. A refused call bills nothing. The general argument for prepaid floors under robot and agent workloads, with documented runaway cases, is the API bill shock guide.

Per call, per action, per hour: the units

Most confusion in api cost searches is a unit error. Robot APIs that exist price per call, per token, or per action, and card renters pay per hour. None of these compare directly until you convert.

calls per robot hour  =  3600 x frame rate / chunk length

The first row is the convention this site uses throughout, and it is the same basis behind the abstract.inc hour estimates quoted above: a 30 Hz hour is 108,000 actions. That shared basis lets you set any hourly quote next to any per-call quote and check them. Divide any hourly figure by 2,160 and you recover the per-call rate. The full treatment of both units, with worked cases for every meter on the market, is the pricing units guide. The sibling pages for the other open VLAs follow the same method. See the pi 0.5 pricing page and the OpenVLA-OFT pricing page.

What to do now

1. Serve today, self-hosted. Pull the base checkpoint, record about 50 episodes of your task, fine-tune, and roll out. Your costs are the card hours plus your recording time. The publisher's docs carry the whole path.
2. Budget the fine-tune before the serve. At the docs' own figure, a full tune is about 4 A100 hours, roughly 11 in card time at today's rate. Serving after that fits a 24 GB card at 0.27 to 0.89 per hour.
3. Write your client against a published contract. This platform's action route documents every field: multipart form data in, the action chunk, the applied normalization block, and the call count with its cost on every answer. The full field list is on the action route page and in the run-action reference. Your driver can be finished and tested before any spend begins.
4. Budget metered calls from the live table. When a row is listed, its rate renders on the pricing page. You can sign up and create a key without a call from us, and the prepaid balance is the spend stop.

Frequently asked questions

Is there a SmolVLA API?

No public priced one. Checked on 26 October 2026: the Hugging Face inference surface returns no serving entry for the base checkpoint or any fine-tune. Replicate, fal, DeepInfra, together, and fireworks list none of it. The abstract.inc rate card carries six robot models and no smolvla row. Robotic Inference covers SmolVLA behind an invitation gate with no published rate. The publisher ships weights and code only. If a seller appears, the census table above is the part that goes stale first; check its dates.

What does SmolVLA cost per hour?

Three honest answers with three units. A rented 24 GB card, enough to serve, cost 0.27 to 0.89 per hour on RunPod on 26 October 2026, plus your time. A full fine-tune at the docs' figure runs about 4 hours on one A100, roughly 11 in card time at the serverless rate. And this platform's written record for the smolvla model id converts to 2.16 per robot hour at 2,160 calls, per the published derivation. Any figure you see elsewhere should state its unit, its party, and its date.

Can SmolVLA run on a laptop?

Yes, and that is the design goal. The release post says the model runs on a CPU, trains on a single consumer GPU, or even a MacBook. Its async mode cuts response time by 30 percent while doubling task throughput. The publisher's real-robot results use the SO-100 and SO-101 arms. The brain is cheap to run. What costs time is the data: the model is a base checkpoint, and the docs recommend about 50 episodes of your own task before fine-tuning.

Is SmolVLA the same as SmolVLM?

No. SmolVLM is a vision-language model family that answers questions about images and text. SmolVLA is the robot policy built on that small backbone, and its output is motor commands, not words. The names sit close together in search results. If the page you are reading discusses tokens per second and chat, it is about SmolVLM. If it discusses action chunks and arms, it is the model this page prices.

Is SmolVLA free?

The license is Apache-2.0 on the weights and the code. Downloading, fine-tuning, and serving commercially cost nothing in license fees. What you pay is compute: the card hours to fine-tune and serve, your recording time, or a per-call rate if you buy hosted access. This page's fence quotes the only public written per-call record we know of, dated today.

The short version: no public SmolVLA price exists anywhere today. The weights are open, a 24 GB card serves and an A100 tunes, and the one written per-call record works out to 2.16 per robot hour at the arm convention. Listed rates live on the pricing page. Sign up to create a key and budget metered calls.

Last verified: 2026-10-26