Build a packaging quote page with an AI agent in minutes

What you can build

The goal is a page a real buyer can land on, upload packaging artwork or a die file, and get an instant price — without you building an upload pipeline, a detection model, or a pricing engine. All of that already exists on PackOS. Your job is the front door: a page with the right copy for your audience and a single embedded component that captures the file and hands it off.

Because the component is a standard web element, any agent that can write HTML can assemble the page — you are generating markup and pasting one snippet, not wiring an API. Developers who want the headless, no-UI flow instead can read adding packaging quoting to your agent over MCP and the headless API; this article is the fastest visible path.

The three pieces a quote page needs

Strip the task down and there are exactly three moving parts, and an agent handles all three:

1. The page. Headline, a sentence of context, and a place for the widget. This is ordinary HTML an agent writes from a prompt — no PackOS-specific knowledge required.
2. The embed. One script tag that loads the component, and the <packos-upload> element carrying your public partner key. This is the only PackOS-specific line on the page.
3. The key. A public partner key (prefixed pk_) that identifies you for attribution. It is safe to ship in client HTML — it is public by design and carries no ability to move money or read data.

Prompt an agent to generate the page

Start with the wrapper. A prompt as short as the one below is enough for a capable coding agent to produce a clean, responsive page you can host anywhere static files go:

Build a single-page static site that helps DTC food brands get a
custom packaging quote. One hero headline, one short paragraph of
context, and a clearly labeled area for an upload widget. Mobile-first,
no framework, no external CSS. Leave a placeholder comment where I will
paste an embed snippet.

The agent returns the HTML. You review the copy — that is the part that should sound like your audience, not like a generic template — and then you add the one line that makes it functional.

Drop in the upload web component

Replace the placeholder the agent left with the embed. It is two lines: the component script, and the element itself with your key. The data-* attributes let you scope the surfaces you want (for example, which packaging formats to accept):

<!-- load the component once, ideally near </body> -->
<script src="https://embed.packos.ai/v1/upload.js" async></script>

<!-- place this where the quote form should appear -->
<packos-upload
    key="pk_live_your_public_partner_key"
    formats="labels,pouches,cartons"
    accept=".pdf,.ai,.svg">
</packos-upload>

That is the entire integration. When a visitor drops a file on the component, the file and your public key are sent to PackOS; the upload, detection, and quote all happen there, and the visitor is carried into the quote experience. You did not touch a server. You can also have the agent emit the snippet directly in the same turn — the element is plain HTML.

Register for a partner key

You need a key before the embed does anything real. Registration is designed to be programmatic and instant — no sales call, no waiting on a human — so an agent can complete it as part of the same build. The designed contract is a single POST that returns a sandbox key you can start testing with immediately:

# register and receive a sandbox partner key (early access)
curl -X POST https://api.packos.ai/v1/partners/register \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Acme Packaging Guides",
    "contact_email": "you@example.com",
    "origins": ["https://your-quote-page.example.com"]
  }'

# -> { "partner_key": "pk_sandbox_…", "mode": "sandbox" }

The same call from JavaScript, if your agent is scripting the setup rather than shelling out:

const res = await fetch("https://api.packos.ai/v1/partners/register", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    name: "Acme Packaging Guides",
    contact_email: "you@example.com",
    origins: ["https://your-quote-page.example.com"]
  })
});
const { partner_key } = await res.json();
// paste partner_key into the <packos-upload key="…"> element

You register and test with nothing verified — building and embedding are fully self-serve. You'll link a payout account when you're ready to cash out, but nothing on the build side waits on that. The agent-facing details, including the machine-readable .well-known/packos-partner.json discovery document, live in the developer docs.

What the embed does and does not do

The component is deliberately a thin client, and that is the trust story worth understanding before you ship it:

• It does collect the visitor's file and read your public partner key, then hand off to PackOS.
• It does not run the upload pipeline, the AI detection models, or the pricing engine on your page — those stay on PackOS infrastructure. Your page never holds customer files or any secret.
• It does not carry a secret key or any credential that can move money. The pk_ key is public by design; the payout side is authenticated separately and never touches the page.

Practically, the worst case for a leaked key is misattributed credit, not a data or money incident — and origin-checking on qualified events limits even that. You can let an agent generate and publish the page without handing it anything sensitive.

How attribution and commission work

When a visitor uploads through your page, the event is tied to your key under a 60-day last-touch attribution window. Commission is a hybrid — a bounty on a qualified quote plus a rev-share on any resulting order — with the exact rates published to partners at signup rather than guessed at here. A qualified quote just means a real upload that clears our quality checks: an actual file that passes detection, not a bare click or a junk upload. Full mechanics are in how an AI agent earns commission with PackOS.

Agents register, embed, and earn on their own — the whole flow is self-serve and agent-native. When there's a balance to cash out, you connect a payout account and take it as fiat (Stripe Connect) or USDC. A short holding window and a small minimum apply, and a payout reverses if the underlying order is later refunded — the specifics live in the program terms rather than the prose here.

What's live and what's early access

To keep this honest: PackOS instant quoting is live today at Quick Quote, and you can see the underlying pipeline in how instant packaging quotes work. The partner program — the register endpoint, the embed key, attribution, and payouts — is in early access and pre-general-availability. That means the endpoints and the embed contract described here are the designed interface, and the commission rates and payout flow are program policy that partners see at signup. Nothing above promises earnings; it describes how the program is built to work. Join the early partner list to get a key and the current terms.