OpenVLA-7B hosted API availability: who serves the original OpenVLA today

No official hosted API exists for OpenVLA-7B. The base checkpoint has no per-call route at any big host, as of 2026-10-26. Google's own AI Overview put it plainly on 2026-10-25: "OpenVLA does not have an official hosted, cloud-based public web API." That sentence was checked against the source today. The maker ships weights, code, and a self-host REST script. It ships nothing you can buy per call. Hugging Face lists no inference provider for the model. Replicate, fal, DeepInfra, Together, NVIDIA's build portal, and the multi-provider router list no OpenVLA at all. One robot API site does serve four official LIBERO fine-tunes of it today, all running, with no public price. For the base model, running it yourself is the working path. As of 2026-10-26 this platform has no public listing for an OpenVLA class route either. The models index is the live catalog.

Last verified: 2026-10-26

What it is

OpenVLA-7B is the original open vision-language-action model. A Stanford and Berkeley led team released it in June 2024. The paper describes the build. A Prismatic vision-language backbone carries the scene and the words: a fused DINOv2 and SigLIP vision encoder in front, and a Llama 2 7B language model behind it. The model turns what it sees and reads into robot actions. It does this by generating action tokens. It reserves the last 256 token ids of its vocabulary as bins. One 7-number action comes out as seven plain generated tokens. Pre-training ran on 970,000 real robot episodes from the Open X-Embodiment datasets. It used 64 A100 GPUs for 15 days, per the project page.

It predicts one action per step, for arms with seven joints. The repo advises control rates around 5 to 10 Hz. It does not emit action chunks. That came later, with other methods in the family. In the paper's runs it beat the closed RT-2-X, a 55-billion-parameter model, by 16.5 percent in task success across 29 tasks, with 7 times fewer parameters. It beat a fine-tuned Diffusion Policy by 20.4 percent. Those are research results on benchmark suites. They are not a promise about your robot.

The weights and the code are public. The repository carries the training, fine-tuning, and serving scripts. The Hugging Face page carries the checkpoints. The repo's own words describe the serving piece: a lightweight script for serving OpenVLA models over a REST API. It is built to remove the need for powerful on-device compute. Community scale, read from the model's own data on 2026-10-26: 131,912 downloads in 30 days, 263 likes. The openvla group lists exactly seven checkpoints: the base model, an early v01 variant, a Prismatic-format copy, and four fine-tunes on the LIBERO benchmark suites.

That last row earns its place. On some smaller search engines, bare "openvla" queries surface the party before the model. Google separates them. Other engines do not.

The license position needs two statements, because two artifacts carry two different terms. Code in the repository ships under MIT. Model weights may inherit limits from the Llama 2 base model, and the repo's own words say: subject to the Llama Community License. None of this blocks evaluation. A team shipping a product should read both before it commits.

The posture on this platform, stated plainly with its date: the OpenVLA-7B class is not currently offered here. As of 2026-10-26 there is no public listing for an OpenVLA class route on this platform. This page promises no date and no arrival. What is published instead is the capability record you are reading, plus the platform's action route contract. Any robot client can be written against that contract today. The VLA category page holds the model family, and the models index is the live catalog.

Use cases

The reader who typed "openvla hosted" wants someone else's GPU to answer one question: does this policy work on my task? That question has four real paths today. Only one involves a third-party API, and it is narrow.

The first path is the specialist host. It is the newest thing on this page. A robot API site called roboticinference.com markets one API for every robot foundation model. It posts its served model list in the open, with no login. Read on 2026-10-26, the list carried 24 robot policies. Four were OpenVLA 7B fine-tunes: LIBERO Goal, Object, Spatial, and Long-Horizon. All four carried a running status. The site's own model notes say each is baked from the openvla group's own checkpoints. The notes also name the published baselines: about 79 percent success on Goal, 88 on Object, 85 on Spatial, and 53 on the long-horizon suite. This is the one place a buyer can call OpenVLA per call today. Two honest limits come with it. Those checkpoints are tuned for one simulated robot setup, a Panda arm in the LIBERO suites. They answer benchmark and simulation questions, not your arm on your bench. And the site posts no pricing page. The offer exists. The rate card does not, as of that date. A second seller, abstract.inc, sells robot inference billed per token and action, with a named model set that includes pi 0.5 and MolmoAct2. Its list names no OpenVLA.

The second path is the first-party door. Here the contrast with the rest of the family is stark. Physical Intelligence, the maker of pi 0, opened a waitlisted API beta in October 2026. NVIDIA runs an inference portal. Its robotics corner carries its own models, and the GR00T policy itself has no endpoint there. The OpenVLA makers ship none of that: no beta, no portal, no waitlist, no pricing page. The source surfaces are the paper, the repo, the project page, and the weights. Anyone telling you about an official OpenVLA API is describing the deploy script, which you run yourself.

The third path is rented machines. It is where the whole results page lives today. The GPU cloud Spheron posts a guide, updated within the last week when read on 2026-10-26. It walks through serving OpenVLA with vLLM on rented A100, L40S, or H100 cards. The guide is honest about that path: vLLM's OpenVLA support is experimental, and the documented production path is the plain transformers interface. The guide's argument for self-hosting is loop timing, since a 10 Hz control loop gives the whole round trip 100 ms, plus data residency. Hourly rental for a 24 GB-class card sat under one US dollar an hour at that cloud on that date. An 80 GB flagship card sat near three. That money buys hardware, not inference. A robotics platform called Konnex documents OpenVLA as a supported model too. Its doc is the same story one layer down: install steps for running the model on your own rented server, with an A10-class GPU as the stated minimum.

The fourth path is the engine gap. It explains why the market looks like this. An open serving framework called vllm-omni is built for exactly this class of model. It hosts robot policies from several families today. An open proposal on its tracker, filed August 17, 2026, asks the maintainers to add OpenVLA as the next one. The author notes that the vLLM engine itself already ships a complete OpenVLA implementation, so the model half exists. What is missing is the robot-facing half. The serve command against openvla-7b dies in the wrong loader today, per the same thread. When the people who host pi 0 and GR00T policies list a public proposal to host OpenVLA, that tells you the absence is real, recent, and tracked.

Where the model itself fits: OpenVLA-7B is a fine-tuning base first. The repo shows LoRA training, which retrains about 1.4 percent of the weights, on a single 80 GB card. It states a practical floor near 27 GB with smaller batches. Arms in the 5 to 10 Hz class are its fit. Fast reactive control is not, where a controller must answer many times per second. One quiet variable in every setup is the norm-stats match between checkpoint and arm; the embodiment stats guide covers it. The wider model class has its own explainer, vision-language-action models explained. For the onboard-versus-rented tradeoff, jetson versus cloud robot inference carries the numbers.

API usage

Three calls matter. The first checks a live catalog. That is how you check listing state, never a guess from a blog post. The second is the official self-host pattern, the maker's own server and client. Third is this platform's action route, a public contract that answers 404 for any OpenVLA class id until a listing exists. The route contract is written up in the action route guide.

curl

The catalog check is one request:

curl -sS "https://api.ironstratum.com/v1/models" \
  -H "Authorization: Bearer $KEY"

The answer is the live list of model ids this platform lists. As of 2026-10-26, no OpenVLA class id is in it. That is the whole check. Repeat it later, and you learn whether that changed, without depending on any page's date.

The action call itself, if an OpenVLA class id ever appears in that list, is a multipart POST. Its shape is fixed today:

curl -X POST "https://api.ironstratum.com/v1/action" \
  -H "Authorization: Bearer $KEY" \
  -F "model=<id exactly as the models index lists it>" \
  -F "instruction=put the red cube in the bowl" \
  -F 'state=[0.12, -0.80, 1.25, 0.40, -0.20, 0.90, 0.50]' \
  -F "image=@cam0.jpg" \
  -F "image=@cam1.jpg"

Sent today with any unlisted id, it answers 404 with the code model_not_found. That is the honest answer. It is exactly what the platform's own docs promise for ids that are not on the public list.

python

The working path this week runs the model on a GPU you control, with the publisher's own script on the serving side. On the GPU machine, start the server from the repo with its three extra packages. It listens on port 8000. On the robot side, the client is four lines of setup:

import requests
import json_numpy
import numpy as np

# The server was started with vla-scripts/deploy.py from the openvla
# repository and listens on the GPU machine, port 8000.
json_numpy.patch()

# Replace with a real 256x256x3 array from your robot camera.
robot_camera_frame = np.zeros((256, 256, 3), dtype=np.uint8)

action = requests.post(
    "http://gpu-box.local:8000/act",
    json={
        "image": robot_camera_frame,
        "instruction": "pick up the yellow block and put it in the basket",
    },
).json()

print("7-DoF action:", action)

This is the publisher's pattern, not a rewrite. The 256 pixel image size, the /act address, and the numpy-over-json patch all come from the script itself. One 7-number action per call comes back, in the checkpoint's own units. Fine-tuned checkpoints pair with their own norm-stats, and the normalization stats guide explains that pairing. If the GPU machine is not open to the web, the script's own header suggests forwarding port 8000 over ssh. That is usually all a lab bench needs.

lerobot

Here is the same loop against this platform's action route, with a LeRobot camera class for the frames. The contract is four form fields. The model id is a string you read from the models index:

import os
import requests
from lerobot.cameras.opencv import OpenCVCamera

session = requests.Session()
session.headers["Authorization"] = "Bearer " + os.environ["KEY"]

cam = OpenCVCamera(camera_index=0, fps=30, width=640, height=480)
cam.connect()

instruction = "pick up the green cube and drop it in the bowl"
state = [0.0] * 7  # your arm's joint positions, same order every call

running = True
while running:
    frame = cam.async_read()
    resp = session.post(
        "https://api.ironstratum.com/v1/action",
        data={
            "model": MODEL_ID,  # set from the models index listing
            "instruction": instruction,
            "state": "[" + ", ".join(str(s) for s in state) + "]",
        },
        files={"image": ("scene.jpg", frame, "image/jpeg")},
        timeout=5,
    )
    resp.raise_for_status()

    for deltas in resp.json()["actions"]:
        state, running = arm_step(state, deltas)  # your driver
        if not running:
            break

Written today, this client is complete and testable except for the id. That is the point of publishing the contract first. The response carries the action chunk, the norm-stats block the model applied, and a usage object. Metering on this route is per call. One served request is one billed call. A refused request bills nothing. The prepaid wallet balance is the hard stop. Rates for listed models sit on the pricing page, never in prose on pages like this one.

Benchmarks

Nothing in this section is this platform's own measurement. A route with no listing has no numbers to publish here, and none will be invented. Every figure below carries its owner and its date.

From the paper, submitted June 13, 2024: the model beat the closed RT-2-X 55B by 16.5 percent absolute task success across 29 tasks, with 7 times fewer parameters. It beat a fine-tuned Diffusion Policy baseline by 20.4 percent. It was the only generalist policy in that study above 50 percent success on every tested task group. Pre-training covered 970,000 real robot episodes, on 64 A100 GPUs for 15 days.

From the specialist host's own model data, read 2026-10-26: the four served fine-tunes carry published baselines of about 79 percent success on LIBERO Goal, 88 on Object, 85 on Spatial, and 53 on the long-horizon suite. Each is tuned to that single Panda setup. Those numbers describe simulation benchmarks. They compare with the wider family's results in the LIBERO evaluation guide.

From the open serving proposal, filed August 17, 2026, author-measured and not peer-reviewed: on one 80 GB A800, in bf16, the reference transformers path answered one robot step in 206.6 ms, or 4.84 Hz. An offline vLLM engine path answered in 145.4 ms, or 6.88 Hz. For a 5 to 10 Hz policy, that margin is the difference between usable and not. The numbers say the model can serve at control rate on one rented card. They do not say anyone serves it for you.

Two honest gaps close this section. The fine-tunes you would actually ship train in hours on one card, per the repo's LoRA recipe. But no benchmark anywhere predicts success on your robot. The norm-stats match is the quiet variable. And the base model's one-action design means it leans on the caller's control loop. The chunked successors in its own line, the OFT method among them, have their own economics on the OpenVLA-OFT pricing page.

Getting started

1. Read the primary sources. The paper, the repository, the project page, and the Hugging Face page are all public. Every identity fact on this page traces to one of them.
2. If you have the GPU, run the model this week. The python tab above is the publisher's own pattern: one server command, one small client. The repo states the practical memory floor for training near 27 GB. A 24 GB-class card serves inference per the setup guides.
3. If your question is a LIBERO-class benchmark, try the specialist host. It is the one per-call OpenVLA offer found. Its four fine-tunes were listed running on 2026-10-26, and it names its own baselines. Ask for the rate card before you commit engineering time. None was public that day.
4. On this platform, watch the live list. Create an account on the signup page and make an API key. Check the models index the way the curl tab shows. The action route contract is documented in the action route guide. Cost shapes for listed models sit on the pricing page. The model family lives on the VLA page, and the models index is the live catalog. When an OpenVLA class route ever appears there, this page's question changes from who serves it to what it costs per call. The answer will be on the pricing page, not in a blog post.