sam2.1-base: SAM 2.1 hiera base-plus, Meta's volume segmentation tier, documented as a metered API

sam2.1-base is this platform's name for a metered lane serving SAM 2.1 hiera base-plus, the volume tier of Meta's improved Segment Anything checkpoints from September 29, 2024. The model is real, public, and open weight today. On this platform the sam2.1-base model id answers directly: an October 6, 2026 vision request returned masks with a whole image count and its wallet debit. It is listed in the models index and on the pricing page as of October 6, 2026. No other metered API serves this tier. Live checks on October 5, 2026 found every commercial SAM lane running the large tier, the older SAM 2, or SAM 3 and 3.1. This page covers what the base-plus tier is, where it sits among the four tiers and five releases, what promptable segmentation does for a robot, and the per-image call contract the lane serves.

Last verified: 2026-10-05

What it is

SAM 2.1 base-plus is a segmentation model: an image in, masks out. A mask is a per-pixel answer to which pixels belong to this object. The model takes prompts, so a click or a box points at one object. It also runs with no prompt at all, in the mode Meta calls automatic mask generation. There it masks every object in the frame. Both modes ship in the repository, and have since the first generation of the family.

The 2.1 line is an improvement pass on SAM 2, not a new architecture. Meta's SAM 2.1 release post describes what changed. Extra training data simulates visually similar and small objects, where SAM 2 struggled. Occlusion handling improves from longer frame sequences and memory-encoding tweaks. The checkpoints landed September 29, 2024, retrained across all four tiers. The SAM 2 paper covers the base design: a transformer with streaming memory, more accurate than the original SAM and 6 times faster.

The identity facts, each with its owner:

The four tiers, and where base-plus sits

The family is one model at four sizes. Every tier uses the same Hiera image encoder at a different width:

Base-plus is the middle-weight pick. It gives up about 1.3 accuracy points to the large tier. It runs about 1.6 times faster on the publisher's own benchmark. Below it, tiny and small give up more accuracy for more speed. Community guides point at them for constrained hardware. The large tier has its own page. For robot work that masks every frame a camera produces, the volume tier is the natural home, and that is the tier this lane serves.

The version map

The Segment Anything line went through five releases in under three years, licensing included. From the official sources:

Two rows of that table matter most to a buyer. The prompt axis changed at SAM 3. The older line takes spatial prompts: points, boxes, masks. SAM 3 added concept prompts, short noun phrases like "yellow school bus". Meta's Model API docs describe the current rules: text prompts only on the served SAM 3.1, one concrete object per phrase, several requests for several object types. The license axis changed in the same release. SAM 2.1 is the last line with the plain Apache grant covering the weights, stated in those words in the SAM 2 announcement. The full license story lives on the vision lane page.

The posture on this platform, stated plainly: the row is on the public list with its per-image rate set, the alias serves, confirmed by the October 6, 2026 request, and the rate renders on the pricing page. The models index is the live catalog, and the vision category page covers the family.

Use cases

A mask is the answer a robot needs before most manipulation code can run. These are the jobs the base tier fits.

• Grasp targeting. A mask gives the exact boundary of the object in the frame. From a boundary you get a grasp frame, a suction placement, or a collision check that is not a bounding-box guess. Pixel edges, not box edges, are what a gripper actually needs.
• Scene parsing at control rate. The automatic mode masks everything it finds, every frame, with no prompt to manage. Your code then filters: biggest mask in the workspace, mask nearest the arm, masks that moved since the last frame. That mask-then-filter order is simpler than prompt engineering inside a loop.
• Object counts and presence checks. Is the bin empty. Are there exactly six parts on the tray. Mask counts answer presence questions without training a detector per part.
• Data labeling. The same model that serves a loop can label one. Automatic masks plus your own filters turn raw frames into training data for the next model. The repository ships the training code under the same license.
• Mask plus depth equals position. A mask tells you which pixels belong to the object. A depth map tells you how far away those pixels are. Together they give the object's position in space, which is what a reach-and-avoid plan consumes. The depth half rides the same vision route here, and the da3-small page covers it.

For the other half of the loop, deciding what the robot does with what it sees, the VLA lane serves the action models.

Run the weights yourself, or call the hosted lane

The weights are Apache 2.0 and ungated, so self-hosting is a real option, and the hosted lane above is the other one.

Run the weights yourself when the data must stay inside your boundary, or when you want to fine-tune on your own scenes. The Hugging Face card shows the shortest path. The mask-generation pipeline in the transformers library runs automatic masking in a few lines. The repository's own predictor classes cover prompted use. At 80.8 million parameters the tier is the one community guidance calls the sensible middle, small enough for one consumer GPU, large enough to hold its accuracy. The cloud-shaped version of the same path is SageMaker JumpStart, which AWS documents as carrying all four variants to deploy on your own instances. That is your endpoint to keep alive, which is the part a hosted lane takes off your plate. One caution from the repository's own design: the video predictor holds state across frames, so memory grows with clip length. Image-mode passes do not carry that behavior.

Own a call instead of a stack when you would rather not host. The lane's contract here meters per image against a prepaid wallet. It returns each call's cost with the call. Spending stops when the balance is gone. The register again, in plain words: on the public list as of October 6, 2026, and this platform is the first metered host of this tier.

API usage

The designed contract is the platform's vision route. It is POST /v1/vision, authorized by a Bearer key from the console, multipart form data in, masks out. The model id is sam2.1-base.

The day-one prompt law is the whole image. There are no point or box fields on this route. Sending one returns a 400 that names the field. The route runs the automatic mode over the whole frame, the shape a control loop wants. On a JSON answer, annotations carries the model's mask objects unchanged. The usage block carries the billed image count and the wallet debit. A binary answer returns the model's rendered bytes under its own content type, billed on the input side.

Metering is the wallet law, and it meters per image. The rate card for this row renders on the pricing page and in the facts strip above, machine-derived from the platform's model data; pages like this one never type rates by hand. Every request returns its own cost in the usage block. The prepaid wallet is the spending stop, and refused requests bill nothing. Every request body sits under the 25 MiB upload cap. A crossing request is refused with an error that names the file slot. A saturated lane answers with retry timing, and that refusal bills nothing.

The lane serves under this alias today, confirmed by the October 6, 2026 request. The tabs below are the working contract the lane ships under. The field reference lives on the run-vision page, the walkthrough on the vision route page.

curl

curl -X POST "https://api.ironstratum.com/v1/vision" \
  -H "Authorization: Bearer $KEY" \
  -F "model=sam2.1-base" \
  -F "file=@cam0.jpg" \
  -F "file=@cam1.jpg" \
  -F "response_format=json"

python

import os
import requests

resp = requests.post(
    "https://api.ironstratum.com/v1/vision",
    headers={"Authorization": "Bearer " + os.environ["KEY"]},
    data={"model": "sam2.1-base", "response_format": "json"},
    files=[("file", open("cam0.jpg", "rb")), ("file", open("cam1.jpg", "rb"))],
    timeout=30,
)
resp.raise_for_status()

answer = resp.json()
masks = answer["annotations"]        # the model's own mask objects
billed = answer["usage"]["images"]   # 2: one per file part
print(len(masks), "mask objects, billed", billed, "images")

http

POST /v1/vision HTTP/1.1
Host: api.ironstratum.com
Authorization: Bearer $KEY
Content-Type: multipart/form-data; boundary=frame-boundary

--frame-boundary
Content-Disposition: form-data; name="model"

sam2.1-base
--frame-boundary
Content-Disposition: form-data; name="response_format"

json
--frame-boundary
Content-Disposition: form-data; name="file"; filename="cam0.jpg"
Content-Type: image/jpeg

<image bytes>
--frame-boundary--

Any HTTP client works. The route is three form fields and a file upload, the shape a web form uses. No SDK requirement, no JSON body to encode.

Benchmarks

Every number in this section is the publisher's own, from the repository's tier table, read October 5, 2026. Speed was measured on an A100 with torch 2.5.1 and cuda 12.4. Scores are the J&F metric on the SA-V test, MOSE val, and LVOS v2 sets.

Two honest reads of that table. First, the 2.1 improvement is real but incremental. The same table's SAM 2.0 base-plus row scores 74.7 on SA-V test against 78.2 here. The gains concentrate on small, visually similar objects and occlusion. Second, the tiers trade what the sizes suggest. From base-plus to large you buy about 1.3 SA-V points and 1.6 times the runtime. From base-plus to tiny you sell about 1.7 points and buy about 1.4 times the speed.

What the publisher's numbers do not cover: your scenes. Community fine-tuning guides report the stock model struggling on fine-grained boundaries, like car doors against car bodies, until tuned on domain data. The repository ships training code for exactly that. Test on your own frames before committing to a tier.

This platform's own measurements are not on this page; every number below carries its named owner. Numbers publish here only after they are measured and held.

Getting started

1. Read the primary sources. The repository carries the tier table, the license, and both prediction modes. The model card carries the download and the pipeline usage. The SAM 2.1 release post carries what changed.
2. Prototype on the open weights. Apache 2.0 and ungated mean the automatic-mask pipeline runs today on your own GPU. The self-serve section above carries the paths.
3. Watch the index, not this page. The models index is the live catalog. The pricing page renders the rate card for every listed row.
4. Open the console when you build. The signup flow opens the wallet, the keys, and the billing history. Each key revokes alone, and the loaded wallet balance is the spend bound.