Quiver Arrow 2 API: Pricing, Telos and Setup
Quiver Arrow 2 is $4/$20 per 1M tokens; Arrow 2 Telos is $6/$30 with 1.05M context. SVG generate, vectorize, animate. On RouterPlex once listed.

QuiverAI shipped Arrow 2 and Arrow 2 Telos on 7 September 2026. They generate, vectorize, edit, and animate SVG, not chat. The API IDs are arrow-2 and arrow-2-telos — not arrow-2.0.
Arrow 2 is $4 per 1M input tokens and $20 per 1M output. Telos is $6 / $30, with a 1,050,000-token context window against Arrow 2's 131,072. Output includes reasoning tokens. There is no fixed price per SVG on either ID.
They are not on RouterPlex yet. Both IDs land on this catalog once they are listed, at Quiver list rates, 0% markup, on the same prepaid key as the rest of the lineup. Create a RouterPlex account now if you want that key ready the day the row appears. Until then there is no RouterPlex ID to paste into Cursor.

Sources: Quiver's announcement (7 September 2026), Arrow 2, Arrow 2 Telos, the model comparison, API pricing, text to SVG, image to SVG, and the API introduction, checked 17 September 2026.
Two models, two jobs #
Quiver's own split is the useful one. Do not pick Telos because the name sounds smarter.
arrow-2 | arrow-2-telos | |
|---|---|---|
| Job | Speed and cost per asset. Everyday generation and vectorization. | Harder briefs. Dense geometry, long instructions, extra refinement. |
| Context | 131,072 tokens | 1,050,000 tokens |
| Max output | 65,536 tokens | 65,536 tokens |
| Input | Text, image, SVG | Text, image, SVG |
| Output | SVG | SVG |
| Input / 1M | $4.00 | $6.00 |
| Cached input / 1M | $0.40 | $0.60 |
| Cache write / 1M | $5.00 | $7.50 |
| Output / 1M | $20.00 | $30.00 |
| vs Arrow 2 | — | 50% higher in every token category |
Quiver's line: choose Arrow 2 when speed and cost per asset are the priority; choose Telos when the brief benefits from additional refinement. Editing and animation are supported when enabled for your key. Presence in the docs is not the same as authority on a given API key.
What the announcement actually shows #
The 7 September post is a quality and speed claim, not a benchmark table. Quiver lists cleaner geometry (fewer, more precise control points) and stronger composition (spacing and alignment without exhaustive prompting). The useful evidence is the samples.
Illustrations from a reference
Start with a reference and Arrow 2 produces variations that keep the palette, shape language, and graphic treatment.

That is the product for brand systems: not a photoreal raster, an editable SVG you can recolor.
Illustrative diagrams
For diagrams, emphasis has to survive the generation. Quiver's anatomical studies highlight targeted muscle groups in red while the surrounding line work stays readable.

If you needed a labeled figure in a docs site or a print spec, this is the job. If you needed a paragraph of explanation, you still need a chat model.
Technical drawings
Technical drawings fail when seams and closures drift across variations. Quiver's jacket concepts keep panel construction consistent so the three directions are comparable.

Vectorization
Raster in, editable SVG out. The announcement uses a hand-drawn horned mask; the output is a path you can scale, recolor, and drop into a design tool.

The native route is POST /v1/svgs/vectorizations. Image inputs are a URL or base64 (PNG, JPEG, WebP, GIF, or SVG). Decoded limits: 12,582,912 bytes, 4096×4096 pixels, or 16,777,216 total pixels. auto_crop is a fallback when you did not crop the subject yourself.
Micro animations
Arrow 2 can animate the shapes and groups already present in an SVG: logo reveals, loading states, product illustrations, animated icons. Quiver says it is suited to interface motion and flat, structured artwork — not a general video model. Native route: POST /v1/svgs/animations, when that operation is enabled on the key.
Arrow 2 Telos #
Telos is the long-context sibling, not a different file format.

Same SVG output. Same 65,536 max output. The extra you pay for is a 1.05M context window and, per Quiver, more room to explore complex styles and requirements. The token rates are exactly 1.5× Arrow 2. If the prompt is short and the asset is simple, Telos is a more expensive Arrow 2, not a free upgrade.
Arrow 2 API pricing #
Quiver's published list, checked 17 September 2026. All figures are USD per 1 million tokens and apply across supported Responses and SVG operations.
| Model | Input | Cached input | Cache write | Output |
|---|---|---|---|---|
arrow-2 | $4.00 | $0.40 | $5.00 | $20.00 |
arrow-2-telos | $6.00 | $0.60 | $7.50 | $30.00 |
Cached input and cache writes replace the ordinary input rate; they are not stacked on top of it. Output includes reasoning. Quiver's worked example of 10,000 uncached input + 2,000 output, no cache:
| Model | Input | Output | Total |
|---|---|---|---|
| Arrow 2 | $0.04 | $0.04 | $0.08 |
| Arrow 2 Telos | $0.06 | $0.06 | $0.12 |
That is a token-count example, not a sticker price per SVG. Each HTTP request in a Responses tool loop is metered separately, so one finished asset can incur several charges.
Arrow 1-series models are still the fixed-price rows if you wanted a known debit per file:
| Model | SVG generation | Vectorization |
|---|---|---|
| Arrow 1.1 | $0.20 | $0.15 |
| Arrow 1.1 Max | $0.25 | $0.20 |
| Arrow 1.0 | $0.30 | $0.30 |
Quiver bills API usage from a prepaid API balance, not from App subscription credits. App plans (Go $8 / Basic $20 / Pro $40 per month) include weekly app usage only. The API default minimum purchase is $10. Credits expire one year after purchase. A token-priced request holds $1 before it runs, then settles actual usage. Insufficient balance returns 402.
When these IDs land on RouterPlex, the billed rate is the live catalog row, not a screenshot in this post. No per-token markup. Prepaid balance. Hard per-key budget. The request stops at $0.
Arrow 2 specifications #
| Capability | Arrow 2 | Arrow 2 Telos |
|---|---|---|
| Model ID | arrow-2 | arrow-2-telos |
| Provider | QuiverAI | QuiverAI |
| Class | SVG foundation model | SVG foundation model, long context |
| Context window | 131,072 | 1,050,000 |
| Max output | 65,536 | 65,536 |
| Input / output | Text, image, SVG → SVG | Text, image, SVG → SVG |
| Native SVG routes | generate, vectorize, edit, animate | generate, vectorize, edit, animate |
| Responses API | When open_responses is in supported_operations | Same |
| Chat completions | No | No |
| Billing | Token usage | Token usage |
| On RouterPlex | When listed | When listed |
GET /v1/models is the live catalog. Appearing in docs does not grant access; the key must authorize the model and the operation.
Two contracts, neither of them chat #
| Need | Route |
|---|---|
| Generate an SVG from a prompt | POST /v1/svgs/generations |
| Vectorize a raster | POST /v1/svgs/vectorizations |
| Edit or animate an SVG | POST /v1/svgs/edits or /animations |
| Let Arrow call your functions | POST /v1/responses (Open Responses, stateless) |
Responses is not Chat Completions. Quiver supports the OpenAI JS SDK only through client.responses.create with baseURL: "https://api.quiver.ai/v1". Hosted tools, store: true, and previous_response_id are rejected. Replay the conversation in input. Streaming is HTTP JSON or SSE; WebSockets are not supported.
Sandbox keys (sk_test_...) hit the same host, never dispatch a model, bill nothing, and mark every SVG with data-quiver-sandbox="true". Do not cache those as production assets.
Call shape (Quiver today, not RouterPlex) #
This curl talks to Quiver. It will not work on api.routerplex.com today. You need a Quiver key from platform.quiver.ai.
curl --request POST \--url https://api.quiver.ai/v1/svgs/generations \--header "Authorization: Bearer $QUIVERAI_API_KEY" \--header "Content-Type: application/json" \--data '{"model": "arrow-2","prompt": "Centered flat monochrome icon of a geometric compass, navy on transparent, no text"}'
Vectorize with POST /v1/svgs/vectorizations and an image.url or image.base64. The Node SDK is npm install @quiverai/sdk. Prompting notes Quiver actually documents: name the subject, the style, the palette, the composition, and any lettering; put extra style rules in instructions rather than stuffing the prompt.
Do not point the OpenAI chat client at this host and send messages. There is no chat adapter to fall through to.
On RouterPlex, once it is listed #
RouterPlex: Arrow 2 and Arrow 2 Telos will be live here once they are listed on this catalog. Quiver general availability is not that bar. We are not publishing a catalog ID, a playground route, or a /v1/chat/completions example for a model we cannot sell yet.
When the rows exist they will be Quiver list price, 0% markup, prepaid, hard per-key budget. They will still be SVG models, not a drop-in for the OpenAI-compatible chat API. Do not paste arrow-2 into Cursor or Claude Code and expect a coding agent.
Until then, the image and generation routes already on this key are still chat or image models, not SVG foundation models. Muse Spark is a cheap raster generator with a contributor licence, not a substitute. Jev is typed decisions, also waiting on public access. Volume chat routes live on the cheapest models ledger.
Create a RouterPlex account if you want the prepaid key ready the day arrow-2 and arrow-2-telos land. Use Quiver's app or API platform if you need SVG this week. This page will name the RouterPlex route the day the catalog row exists.
Common questions
Frequently asked questions
How much does the Arrow 2 API cost?
Quiver lists Arrow 2 at $4 per 1M input tokens and $20 per 1M output tokens. Cached input is $0.40 and cache writes are $5.00 per 1M. When the ID lands on RouterPlex it will bill those list rates with no markup.
How much does Arrow 2 Telos cost?
Arrow 2 Telos is $6 per 1M input and $30 per 1M output — 50% higher than Arrow 2 in every token category, including cache. Telos also has a 1,050,000-token context window against Arrow 2's 131,072.
Is Arrow 2 on RouterPlex?
Not yet. Quiver opened Arrow 2 and Arrow 2 Telos on 7 September 2026. Both IDs will be live on RouterPlex once they are listed on this catalog. There is no RouterPlex model ID to call today.
Is the API model ID arrow-2.0?
No. Quiver's docs are explicit: the ID is arrow-2, not arrow-2.0. Telos is arrow-2-telos.
Can I call Arrow 2 with the OpenAI SDK chat completions endpoint?
No. Arrow 2 emits SVG, not chat strings. Quiver's native routes are POST /v1/svgs/generations, /vectorizations, /edits, and /animations. The Responses path is POST /v1/responses under the Open Responses contract. Pointing an OpenAI chat client at arrow-2 will not return an SVG.
Is there a fixed price per SVG?
Not on Arrow 2 or Telos. Those two bill measured tokens. Quiver's worked example of 10,000 uncached input and 2,000 output is $0.08 on Arrow 2 and $0.12 on Telos. Arrow 1.1 is still the fixed-price row: $0.20 per generated SVG and $0.15 per vectorization.
Run the smallest paid test.
Add $5, cap the key, and verify the result with your own workload. No subscription, and credit never expires — a first top-up of $25+ is matched with $25 extra.



