Ten placements free. Then $1 a month each.

A placement is an image your team changes without an app release. People, agents, apps, and platforms are never counted, and every workspace has every feature.

Placements 11 to 100 are $1 each a month. A placement is one image slot your team changes without a release; its light and dark versions, locales, and experiment arms are the same placement.

A month

$30

Storage and delivery are included up to 250 MB and 10 GB a month. A large audience adds delivery at $0.20 per GB: about $2.40 per 100,000 devices for each artwork change.

The whole price list.

Three meters, each with a free allowance every month, and everything that never appears on a bill.

Placements
First 10 free. Then $1 a month each; $0.50 each past 100; $0.25 past 500, or a quote. A placement counts while it is in a published release. Icons, vectors, and catalog images are not placements.
Stored artwork
First 250 MB free. Then $1 per GB a month, counting originals and the prepared sizes across every kept release.
Delivery
First 10 GB a month free. Then $0.20 per GB that connected apps download. A device that already holds the image downloads nothing.
Never counted
People, agents and MCP calls, apps, platforms, variants and experiment arms, releases and restores, release checks from installed apps, the SDKs and the audit.

In every workspace.

There is no plan to upgrade to. The free workspace and the one delivering a terabyte run the same product.

  • Signed releases, verified byte for byte
  • Restore any earlier release
  • Bundled fallbacks when delivery fails
  • Placement contracts with size checks
  • WebP optimization and prepared sizes
  • Lottie animations
  • Public delivery, cached by CDNs
  • Members and roles, no seat limits
  • Expo, SwiftUI, and Compose SDKs, MIT
  • The audit skill for Claude Code and Codex
  • A spend cap with notices at 80 percent
  • Agent and MCP reads Planned

Control the bill.

You set the cap.

Every workspace has a monthly spend cap you choose. The console tells you at 80 percent and we email the owner. At the cap, new uploads and new publishes pause until you raise it or the month turns.

Published delivery is never interrupted.

The current release, its images, every bundled fallback, and restore keep working in connected apps at the cap and past it. A budget question in the console never becomes an outage in your app.

Past the line, a quote.

Above about 200 placements or a terabyte of delivery a month, volume delivery, invoicing, a named contact, and custom allowances are agreed from your measured usage.

Agents are users, not seats.

Most teams meet Assetlib through a coding agent running the audit. What the agent does next is priced the same way as anything a person does: by the work, never by the call.

The audit skill is free and stays local.

It reads your app's images and references and prints a report. No account, no upload, nothing changed on disk. Install it in Claude Code or Codex, or point any agent at the skill file.

Reading a workspace over MCP is free on every workspace.

Placements, their contracts, release history, where an image is used: an agent that knows these connects more placements and prepares better drafts. That makes the workspace more useful, so it is not metered. Planned.

Agent writes use the meters, not a separate price.

An agent that uploads artwork or prepares a release consumes stored artwork and, once published, delivery, exactly as a person would. No per-call fees, no agent seats. Publishing stays a human decision until a workspace owner says otherwise.

Inference we run for you would be metered on its own.

Generating or restyling artwork with a model we pay for would be sold as credits with a visible price, never folded into the free allowances. Not offered today.

Founding pilot.

The integration done beside us in two working sessions, $100 of metered usage, and your per-unit rates held for twelve months. $399, once, by invoice.

Request a pilot

Opens an email to tylerzhaodev@gmail.com. Tell us the app, the framework, and the images your team changes most often. We take a few pilots at a time and reply within two business days.

Included

  • A session to choose and connect the first placements, with their fallbacks
  • A session to run a publish and a restore on your installed build
  • $100 of metered usage
  • Email support within one business day for thirty days
  • The written record of what changed, so you can judge the result
  • Your per-unit rates held for twelve months

Not included

  • App development or custom integration work
  • New SDK features or framework support
  • Migration of a whole image library; quoted separately at $150 a working hour
  • A production service level; the SDKs are developer previews

Questions about paying.

The ones we expect. For integration questions, the homepage and the guide cover the SDK.

How does billing work?

Usage is metered per workspace and billed monthly against the three meters. Add a card when a workspace passes its free allowances and set the cap at the same time; until then there is nothing to pay. Pilots and quotes are invoiced.

Why are people and agents never counted?

Because they are not what Assetlib does. A workspace with two people and five agents publishes more artwork than one with ten people, and a seat price would undercount the first and tax the second. The bill follows the work: placements managed, bytes stored, bytes delivered. That is also why there is no "Pro" tier to unlock; every workspace has every feature.

Figma meters MCP access by plan. Linear gives it away. Which are you?

Linear. Linear's MCP makes agents file more issues into the place Linear already charges for, so it costs Linear little and adds value; Figma's MCP hands design context to coding agents, which is the job a paid Dev seat used to do, so Figma caps it. An agent reading an Assetlib workspace connects more placements and prepares better drafts, which is the thing we bill. Reading is free; writes use the same meters as a person; only inference we pay for would ever be metered separately.

What counts as a placement under management?

A named image slot in your code, with a size contract and a bundled fallback, that appears in an app's current published release: a promo card, a seasonal illustration, an onboarding frame, an empty state. Icons, vectors, and the images in a catalog are not placements, so an app with eight hundred imagesets is not eight hundred placements; the audit proposes at most three to start. The first ten in a workspace are free, the next ninety are $1 each, the next four hundred $0.50, and past five hundred $0.25 or a quote. Drafts and archived placements are not counted, and neither are the Roam, Daylight, and Still sample workspaces.

How are segments and A/B tests priced?

A placement is one slot however many variants it carries: light and dark, locales, segments, experiment arms. None of them is a second placement. What an experiment costs is what it delivers. Each device downloads only its assigned arm, so a two-arm test on 300,000 devices is about 300,000 downloads to start and half that again when the winner rolls out, roughly 54 GB, or about $9 at the delivery rate, plus a few cents of storage for the extra artwork. Assignment comes from the experiment or flag tool you already use; those connectors (LaunchDarkly, Amplitude Experiment, OpenFeature) are planned, and the rule holds when they ship.

How do I estimate delivery?

Multiply devices by artwork changes. Each change sends about 120 KB to each active device that opens the app, so 100,000 devices and one change is about 12 GB, or $2.40 past the free 10 GB. An app with 300,000 devices changing artwork six times a month pays about $41 in delivery on top of its placements. Below about 50,000 devices, delivery is usually free.

How do I keep the bill predictable?

Set the cap. It is a hard monthly maximum on the metered charges, and the console shows the three meters against it. Delivery to installed apps continues at the cap; what pauses is new work in the console. Most teams know their bill to the dollar from the placement count alone, because storage and delivery are small next to it until an app has a large audience.

What exactly is the founding pilot?

Two guided working sessions with us, one to choose and connect the first placements with their fallbacks and one to run a publish and a restore on your installed build, plus $100 of metered usage and your per-unit rates held for twelve months. It costs $399, once, by invoice. It does not include app development, new SDK features, migration of a whole image library, or a production service level; the SDKs are developer previews.

Why pay for this rather than an image CDN?

Hosting bytes is not what you are paying for; at these rates the bytes are nearly free. The placement price pays for the release workflow around them: placement contracts, compatibility checks, signed releases, history, restore, and the bundled fallbacks that keep an app working when delivery fails. If an image CDN already covers your workflow, keep it.

Ten placements free.Then a dollar each.Bring every agent.

Connect one placement in an app you already maintain, publish, and restore. The meters start at zero and the cap is yours.