GR00T N1 family hosted API availability: who serves GR00T today

NVIDIA serves no hosted GR00T API, and no big host serves the family either, as of 2026-10-26. NVIDIA's own build portal returned zero GR00T models and four training items when searched on that date. Hugging Face, fal, DeepInfra, and the multi-provider router list none. One specialist robot API site lists four GR00T N1.7 fine-tunes today. All four are tuned on the LIBERO test suites. All four carry a sleeping status, and no public price exists. The rental guides that rank for this query rent you a GPU, not an API. The base checkpoints are downloads you run yourself. On this platform the GR00T class is not currently offered: no public listing as of 2026-10-26. The models index is the live catalog.

Last verified: 2026-10-26

What it is

GR00T N1 is NVIDIA's open foundation model family for robot skills. It began with N1 in March 2025. It runs through N1.5, N1.6, and N1.7, the current release. It is a vision-language-action model: camera images and a task sentence go in, chunks of joint commands come out. The N1.7 checkpoint counts about 3 billion parameters. The design and the version history are described in the white paper and in the repo. Which version to pick is its own question, and it has its own page: the GR00T version chooser. This page answers a different question: can you buy the model as a call.

The name search mixes several things, so the table earns its place.

The license needs one statement here. It shapes who may offer the model at all. Every release ships the same license file, N1 through N1.7. Its section 3.3 limits use to research and evaluation. The N1.7 card and repo claim commercial terms anyway. That conflict is walked through claim by claim in the GR00T license guide. One exception sits inside the family brand. GR00T-Dreams, the family's data model, ships Apache 2.0 terms at its repo. The license file travels with every download, and the file governs your copy.

The posture on this platform, stated plainly with its date: the GR00T class is not currently offered here. As of 2026-10-26 there is no public listing for a GR00T 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 "gr00t api" wants someone else's GPU to answer one question: does this policy work on my task? That question has four real paths today. One of them is a narrow per-call offer. The other three are versions of doing it yourself.

The first path is the specialist host, and it is the newest fact on this page. A robot API site, roboticinference.com, sells one API for every robot model. Its public model list was read on 2026-10-26, then re-read minutes later with the same result. It carried 24 policies. Four were GR00T N1.7 fine-tunes: LIBERO Goal, Spatial, Object, and Long. Each carries a sleeping status with an active lifecycle, in the list's own words. The Goal entry's own notes name NVIDIA's published result: 195 of 200 tasks, or 97.5 percent. They also name a native rate of 20 Hz. The site's public list needs no login. Two honest limits come with it. Those four checkpoints are tuned for one simulated setup, a Panda arm in the LIBERO suites. They answer test-suite questions, not your arm on your bench. And the site posts no public rate card. Its pricing address returns a not-found page, checked the same day. Four fine-tunes are on the list. No price is.

The second path is NVIDIA itself, and it is a dead end for the per-call buyer. The company's posture is download-first. Its build portal was searched on 2026-10-26. It returned zero models. It carried four training items instead: two fine-tune playbooks, one synthetic-motion blueprint, and one fine-tune skill. Its platform page puts a Download Models button at the top and the bottom. Both point at the repo and the checkpoints. The named deploy target is Jetson Thor, a module you buy and own. The company that builds GR00T will sell you the recipe, the GPUs, and the Jetson module to run it on. It will not take your action call.

The third path is the rental lane, and it needs one distinction the search results never make. Renting a GPU that runs GR00T is not buying GR00T inference. The GPU cloud Spheron publishes a guide for running GR00T N1 on rented cards. It is dated May 3, 2026. It was read for this page on 2026-10-26. Its table prices the work at 17.45 per million action steps on an H100 card at 32 Hz. That rate is 115,200 steps an hour. Spheron itself dates the numbers to May 2026. Multiply it out and you get about 2.01 an hour. That is the same class of number as the card rental itself: the guide's own live-rate line reads 2.64 an hour for that card as of 2026-10-26. That is marketing math over rented hours. The same page carries the license reminder in Spheron's own words: the weights remain non-commercial research only. Rented hours are not inference. A guide that teaches you to rent an H100 and run GR00T yourself is a self-hosting guide with a billing page. One more fact from the rental lane: the closest thing to GR00T on Replicate is a community page, over a year old. It trains a GR00T model on your LeRobot dataset for roughly 10 per run. It pushes the trained model back to the Hub. It is a trainer, not an endpoint. The big-host survey across the whole robot model class lives in do the big hosts serve robot models.

The fourth path is self-hosting, and it is the working path for the base checkpoints. The floor is one GPU with 16 GB of memory or more. A 24 GB gaming card serves inference. The N1.7 checkpoint is a download of about 6 GB. It loads a gated vision-language backbone from the Hub. Request access to that backbone first, or the first run fails with an access error. You pick an embodiment tag that matches your robot. The tag sets the state and action keys, plus the stats the model applies. The base checkpoint predicts 40 action steps per pass, which fits the real-time chunking rule of thumb of 32 or more. Published speeds, all from NVIDIA's own material, all with TensorRT: about 40 Hz on an RTX PRO 6000 card, and about 28 Hz on a Jetson AGX Thor module. The model card's own table shows 35.9 Hz on an H100. The older N1.5 recipe shows LoRA tuning on two 24 GB cards. That is why so much hobby material still targets it. The Jetson path has its own page: GR00T on Jetson Thor or Orin. The cost math for onboard versus rented has its own too: Jetson versus cloud robot inference.

Where the model itself fits: GR00T is a fine-tuning base first. The tutorials target SO-100 and SO-101 arms and the LIBERO and DROID test suites. Arms in the 5 to 40 Hz class are its fit. Fast reactive control is not, where a controller must answer many times per second. One quiet variable sits in every setup: the stats match between checkpoint and arm. The normalization stats guide covers it. The wider model class has its own explainer, vision-language-action models explained. One more path is waiting, and it is more reasonable than it sounds. The only priced robot API found anywhere in this research is Google's Gemini Robotics ER 2. That one is a reasoning model, not an action policy. Its rates double on January 1, 2027, per Google's pricing page. Every action policy in the GR00T class is unpriced everywhere, as of 2026-10-26. The unit question, per call versus per robot hour, has its own page: the pricing units guide. The family's own cost page is GR00T API pricing.

API usage

Three calls matter. The first checks a live catalog: that is how listing state is read, never guessed from a blog post. The second is the publisher's own pattern, the way to run the model on a GPU you control. The third is this platform's action route, a public contract that answers 404 for any GR00T class id until a listing exists. That 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 GR00T 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 a GR00T 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 Policy API from the Isaac-GR00T repo. On the GPU machine, after the repo is installed and the gated backbone is open to you on the Hub:

from gr00t.policy import Gr00tPolicy
from gr00t.data.embodiment_tags import EmbodimentTag
import numpy as np

# GPU machine: one NVIDIA GPU with 16 GB or more, repo installed,
# Hub access to the gated Cosmos-Reason2-2B backbone requested first.
policy = Gr00tPolicy(
    model_path="nvidia/GR00T-N1.7-3B",   # ~6 GB download on first use
    embodiment_tag=EmbodimentTag.OXE_DROID_RELATIVE_EEF_RELATIVE_JOINT,
    device="cuda:0",
    strict=True,  # validates observation shapes; the docs' advice
)

observation = {
    "video": {"camera_name": np.zeros((1, 1, 224, 224, 3), dtype=np.uint8)},
    "state": {"state_name": np.zeros((1, 1, 7), dtype=np.float32)},
    "language": {"task": [["put the red cube in the bowl"]]},
}

action, info = policy.get_action(observation)
arm_action = action["action_name"]   # shape (B, T, D): T is the chunk length
next_action = arm_action[:, 0, :]    # execute the first step, re-plan after

This is the publisher's own pattern, not a rewrite. The observation format, the uint8 and float32 rules, and the get_action call all come from the repo's own policy guide. The base checkpoint returns 40 steps per pass. Your driver plays them back at its control rate, then sends the next observation. The embodiment tag must match your robot type. An unknown tag produces an error that lists every known option. The repo's standalone script runs the same loop over its demo data. Use it first if you want error numbers before you touch a robot.

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 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 of ours to publish, and none will be invented. Every figure below carries its owner and its date.

The speed figures are NVIDIA's own, read on 2026-10-26, all with TensorRT. The card's table shows 35.9 Hz on an H100 80 GB for the full pipeline, at 4 denoise steps with one camera. The readme shows about 40 Hz on an RTX PRO 6000 Blackwell at batch 1 on the LIBERO suite. It shows about 28 Hz on a Jetson AGX Thor module at maximum clocks. Two Jetson Thor numbers exist because two setups were measured. The card's table also shows 10.7 Hz for the full pipeline on Thor. On Orin it shows 4.6 Hz with only the action head compiled. Every speed claim carries its setup. Comparing across setups is how readers get burned.

The specialist's own leaderboard was read on 2026-10-26. Its measured result for the GR00T N1.7 LIBERO Goal fine-tune: 94.0 percent over 50 runs at 20 Hz, dated 2026-05-05 on the row. NVIDIA publishes 97.5 percent for the same checkpoint. A measured number on a live list, three and a half points under the paper number, is worth more to a buyer than either number alone.

The demand side, from the Hub's own records on 2026-10-26, downloads of the base checkpoints in 30 days: N1.7 at 72,458, N1.6 at 10,048, N1.5 at 1,584, and N1 at 426. The market voted about 46 to 1 for the current release over its 2025 predecessor, and about 170 to 1 over the original. That is what an unhosted family looks like from the outside: heavy download traffic, and no serving surface anywhere to catch it.

Two honest gaps close this section. No test suite predicts success on your robot. The stats match between checkpoint and arm is the quiet variable, and the embodiment stats guide covers it. Nothing is published about what the sleeping status means when a call arrives. The field is the list's own wording. It was stable across two reads on 2026-10-26. A buyer should ask the site directly before building on it.

Getting started

1. Read the primary sources. The repo, the N1.7 model card, the white paper, and NVIDIA's GR00T platform 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 card with 16 GB or more serves inference. Request access to the gated backbone on the Hub before the first run.
3. If your question is a LIBERO-class benchmark, try the specialist. Its four GR00T N1.7 fine-tunes were on its public list on 2026-10-26, and it publishes its own measured results. 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 written up 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 a GR00T 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.