pi0 (π0) hosted API availability: who serves pi 0 today, and every real option

No third party serves pi 0 over an API as of 2026-10-26. Every major host was checked on that date. Hugging Face model data for the pi 0 port reads no inference provider. Replicate, fal, DeepInfra, Together, and NVIDIA's build portal list no pi 0 route anywhere. The one first-party door is the Physical Intelligence API beta, opened October 13, 2026. It is a waitlist. It has batched onboarding, managed fine-tuning plus hosted inference, and no published pricing. The open weights are real and public. Running the model yourself is the working path today. As of 2026-10-26 this platform has no public listing for a pi 0 class route either. The models index is the live catalog.

Last verified: 2026-10-26

What it is

Pi 0 (written pi-zero, pi0, or the Greek pi with a zero) is the first generalist robot policy from Physical Intelligence. The publisher's post announced it on October 31, 2024. It is a vision-language-action model. Camera images and a plain task sentence go in. Joint commands that move the arm come out. The paper describes the build. A pre-trained vision-language backbone, PaliGemma, carries the scene and language knowledge. A small action expert of about 300 million parameters turns that into smooth motion through flow matching. The whole model is about 3.3 billion parameters. It emits action chunks: batches of up to 50 future joint commands, computed in one pass. In the paper's runs it drove robots at up to 50 Hz on dexterous tasks such as folding laundry and assembling boxes.

The weights and the code have been public since February 4, 2025. The publisher released them in the openpi repo under the Apache-2.0 license. This page verified that by reading the license file itself. The release is honest about its limits, in the publisher's own words: this is an experiment, the model was built for their robots, and it may or may not work for yours. The repo ships a base checkpoint pre-trained on more than 10,000 hours of robot data. It also ships task-tuned checkpoints for the DROID setup and several ALOHA tasks. Names like pi0-DROID mark the ones meant for fine-tuning. Pi0-FAST-DROID is meant for direct inference.

One name in that list matters to anyone comparing options: pi0-FAST. It is the same backbone with a different action head, one that generates actions as discrete tokens. The publisher notes better language following. And a cost: about 4 to 5 times higher inference cost than pi 0, in their experience. That number comes from the open-sourcing post itself.

Search results mix all of these, so the table earns its place. The board computer mix-up is the most common one on bare "pi zero" queries.

The license position needs two statements, because two artifacts carry two different terms. In the repo, code and weights ship Apache-2.0. The community port on Hugging Face, under the LeRobot group, carries a Gemma license tag in its own model data. That tag rides along from the PaliGemma backbone, which brings Google's model terms with it. And the tokenizer the model needs sits behind a license gate on the Hub. 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 pi 0 class is not currently offered here. As of 2026-10-26 there is no public listing for a pi 0 class route. 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 "pi0 api" wants someone else's GPU to answer one question: does this model work on my task? That question has four real paths today. Only one of them involves a waitlist.

The first path is evaluation without hardware. The repo wants an NVIDIA GPU with more than 8 GB of memory. It wants Ubuntu 22.04 as the operating system. And it wants a tolerance for research code. A hosted per-call route would answer the question in an afternoon, with a camera stream and a small budget. That route does not exist at any third party as of 2026-10-26. That is why the other paths carry the load.

The second path is the first-party beta. Physical Intelligence built its API for the team that has robots and demos but no machine learning setup. Upload data. They fine-tune on their compute. The result serves through their gateway. The beta post names deployments that ran this way. One is an autonomous wheel loader with no operator inside. Another is a dual-arm robot that deburrs its own parts. The cost is the door itself: a waitlist, batched onboarding, unpublished terms, and no per-call catalog. A buyer who needs one call against pi 0 this week gets nothing from the beta. A buyer building a serious application gets a real offer with an unknown price.

The third path is rented machines. The big clouds do not serve pi 0. They teach you to run it on their GPUs. Amazon's own physical AI blog, read on 2026-10-26, walks through fine-tuning pi 0 on SageMaker HyperPod with EKS orchestration, on nodes of eight H100 GPUs. It reports the tuned models cutting action-prediction error by 89.7 percent on the DROID dataset and 88.9 percent on LIBERO, against the base checkpoint. That is the shape of the cloud offer today. Excellent machines by the hour, with the model work left to you.

The fourth path is waiting, and it is more reasonable than it sounds. The action-policy market has exactly one priced offer anywhere: Google's Gemini Robotics ER 2. That is a reasoning model, not an action policy. Its per-million-token rates double on January 1, 2027, per Google's pricing page read on 2026-10-26. Every real action policy, pi 0 included, is unpriced everywhere. A team whose task is not blocked this quarter can let the beta mature and the market form.

One more thing the search results reveal, worth knowing before you click anything. The pages that rank on "pi0 api" today are not offers. On 2026-10-26 the first page was the repo, the publisher's beta post, the paper, news stories, a hardware vendor's guide, and a training-data vendor's page. That last kind sells demo datasets for fine-tuning. A real service, but it is not inference. When a query has no product behind it, the commercial layer that grows in the gap is adjacent services. Read each result with that filter. A page about pi 0 is not a page that serves pi 0.

Where the model itself fits, from the paper and the repo: pi 0 is a fine-tuning base first. The publisher reports that 1 to 20 hours of demos from one's own platform was enough for useful task tunes in their tests. The DROID-tuned checkpoints suit a Franka-class arm with cameras. It is the wrong tool for fast reactive control, where the controller must answer many times per second. A small dedicated policy fits that job. The wider class has its own explainer, vision-language-action models explained. The onboard-versus-hosted tradeoff has numbers in jetson versus cloud robot inference.

API usage

Two things exist today: a waitlist page and a repo. This section shows the three calls that matter. The first checks a live catalog. That is how listing state is verified, not guessed. The second is the publisher's own remote client, the working self-host path. The third is this platform's action route, a public contract that answers 404 for any pi class id until a listing exists. Field by field, the contract is written up in the action route guide.

curl

The catalog check is one request. It is the same check this page ran in spirit on every host surveyed: read the live list, never trust a stale blog post.

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 pi 0 class id is in it. That is the whole check. Repeating it later is how you learn whether that changed, without depending on any page's date.

The action call itself, when a pi 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 client on the robot side. On the GPU machine, Ubuntu 22.04 with more than 8 GB of NVIDIA memory, start the policy server from the openpi repo. It listens on port 8000 by default. On the robot machine, install the openpi-client package and speak to it:

from openpi_client import image_tools
from openpi_client import websocket_client_policy

# The server was started with scripts/serve_policy.py from the
# openpi repository and listens on the GPU machine, port 8000.
client = websocket_client_policy.WebsocketClientPolicy(
    host="gpu-box.local", port=8000
)

for step in range(num_steps):
    # Resize images on the robot side to cut bandwidth, and keep
    # them uint8. The publisher's docs use 224 pixels for pi 0.
    observation = {
        "observation/image": image_tools.convert_to_uint8(
            image_tools.resize_with_pad(img, 224, 224)
        ),
        "observation/wrist_image": image_tools.convert_to_uint8(
            image_tools.resize_with_pad(wrist_img, 224, 224)
        ),
        "observation/state": joint_positions,  # unnormalized; the
        # server applies the norm stats for the checkpoint
        "prompt": "pick up the green cube",
    }
    action_chunk = client.infer(observation)["actions"]
    for action in action_chunk:
        arm_step(action)             # your arm driver, one row per tick

This is the publisher's documented pattern, not a reimplementation. The observation keys, the 224-pixel resize, and the raw state all come from the repo's own example. The answer is a chunk of actions whose length belongs to the checkpoint. Your driver plays it back at its control rate. The remote inference guide in the openpi repo carries the full recipe, including which norm stats apply per robot family.

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, and 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 lanes are 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.

The publisher's own round-trip figure for a 3-billion-parameter model of this family comes from their real-time chunking write-up. The whole loop took 139 milliseconds on a mobile robot. Of that, 97 was the model and 21 the network. On a static robot the whole loop took 108 milliseconds. Compare that to a 50-action chunk at 50 Hz, which covers about one second of motion. The round trip leaves wide margin. A chunk is the trick that lets a large model drive a fast loop, and the arithmetic belongs to whoever states the chunk length and the control rate.

From the paper itself: zero-shot task skill after pre-training, instruction following, and new skills through fine-tuning. The tasks include laundry folding, table cleaning, and box assembly, at control rates up to 50 Hz. A research record is not a product promise, and the publisher says so plainly in the repo.

The rented-GPU path has its own published result, dated to Amazon's blog read on 2026-10-26. Tuned pi 0 models cut action-prediction error by 89.7 percent on DROID and 88.9 percent on LIBERO against the base checkpoint. Training ran on a single eight-GPU H100 node. That number says the model tunes well. It does not say any cloud serves it. None does.

Two honest gaps close this section. Community threads on the publisher's repo describe slower-than-hoped pi0-FAST runs. That fits the publisher's own 4-to-5-times cost note for that variant, and it is one more reason the flow-matching pi 0 is the default choice for self-hosting. And no benchmark anywhere predicts success on your robot. The norm-stats match between the checkpoint and your arm is the quiet variable. The platform's embodiment stats guide covers it.

Getting started

1. Read the primary sources. The paper, the openpi repo, the open-sourcing post, and the API beta post 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. The publisher's stated range is 1 to 20 hours of demos from your robot for a useful task tune.
3. If you want the managed path, apply to the beta. The waitlist is the only first-party door. Onboarding is batched and pricing is unpublished. Ask for numbers before you commit engineering time.
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 lanes sit on the pricing page. The model family lives on the VLA page, and the models index is the live catalog. When a pi 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.