Docs

Start here

What the platform sells

GET/v1/planson https://api.auray.ai/v1

Takes no key and charges nothing, for the same reason /status does: the price cards are drawn before anybody has an account, and every figure here is already on the pricing page.

Takes no key and charges nothing, for the same reason /status does: the price cards are drawn before anybody has an account, and every figure here is already on the pricing page. Every active plan is listed; the plan this platform's own accounts hold is never active and never sold, so it is never listed. A plan we moved or created is reflected within a minute; the money path itself is gated on the new figure within fifteen seconds. When the plans table cannot be read this answers the four built-in plans rather than an error, because a pricing page that fails during an incident is worse than one showing yesterday's prices. A plan's chat.max_output_tokens is its ceiling per turn; a turn on a model that cannot write that much inside one turn's time is sent the model's own instead, which GET /openai/v1/models prints per model for the caller's plan. Cached at the edge for sixty seconds with five minutes of stale service. An answer built on a fallback — any of the plans, their moved figures, the moved prices, the promotions, the offers or the payment switch could not be read — is sent with no-store instead and stored nowhere, and X-Auray-Fallback names what it fell back on: read it before keeping the answer anywhere yourself.

#Authentication

No key needed — this document is public.

#Example request

curl https://api.auray.ai/v1/plans

#Responses

#200 OK

OK. Plans in ladder order, cheapest first.

FieldTypeRequiredDefaultDescription
objectstringno—One of "list".
dataobject[]no—
data[].idstringno—The plan id an account's plan holds.
data[].basestringno—Which of the four built-in plans its limits come from. Equal to id for those four.
data[].rankintegerno—Ladder position, cheapest first.
data[].sellablebooleanno—Whether the plan is on sale. free is never on sale. Whether a checkout would open right now is buyable.
data[].buyablebooleanno—Whether a checkout for this plan would open right now: on sale, with a price on the payment provider that takes checkouts, and that price equal to monthly_usd. The checkout asks the same question, so a card can be a minute behind a refusal and never behind a sale.
data[].monthly_usdintegerno—What the cards show. The invoice comes from the payment provider's own price.
data[].yearly_discount_pctintegerno—How much paying for a year at once saves on twelve months, in percent. 0 means the plan is not sold by the year. 0 to 50.
data[].yearlyobjectno—The plan paid for a year at once, or null when it is not sold by the year. Credits still arrive every month: the plan's credits_per_month, twelve times. May be null.
data[].yearly.centsintegeryes—What a year costs, in US cents: monthly_usd × 12 less discount_pct.
data[].yearly.per_month_centsintegeryes—A twelfth of cents: what a year works out to a month.
data[].yearly.discount_pctintegeryes—The saving on twelve months, in percent; equal to yearly_discount_pct.
data[].yearly.buyablebooleanyes—Whether a checkout for a year would open right now, as buyable says for a month.
data[].nameobjectno—Keyed by language: en, id.
data[].taglineobjectno—
data[].featuresobjectno—
data[].featuredbooleanno—Whether this is the one plan the cards raise above the rest, with a filled button (and, when it carries no badge words of its own, the default badge). At most one plan in the list is featured, and there may be none. We choose it, so it can move between plans without a new release.
data[].badgeobjectno—This plan's badge, keyed by language, ready to print: a few words of at most 40 characters each, never a figure. Any number of plans may carry one at once; the featured plan with no words of its own carries the default. null on a plan that is neither featured nor given words. May be null.
data[].badge.enstringyes—
data[].badge.idstringyes—
data[].credits_per_monthintegerno—
data[].trial_daysintegerno—Days of free trial a first subscription to this plan starts with; 0 means none. A card is taken up front, and the trial is given once per account and once per card, only by the card payment provider: a card already saved on the account that has had a trial gets none, and one first entered at checkout that has had a trial runs it without trial_credits.
data[].limitsobjectno—What the plan allows, keyed by product, as the figures in force: a move of ours is reflected, a promotion's lift is not (it is under promotion.lifts). api is what one API key of the plan may do — whether it may generate, how many keys and webhook endpoints the account may hold, and each rate bucket's burst and per-minute refill — and session is the desktop session's buckets. A key that may not generate has empty generate and interactive buckets whatever the figures say.
data[].limits.billingobjectyes—
data[].limits.billing.rollover_monthsintegeryes—How many months of this plan's credits a wallet may carry into the next grant. Plan figure rollover.multiple.
data[].limits.billing.trial_creditsintegeryes—Credits a first trial pays while it runs, in place of the month; once per card, so a card that has had a free trial before earns none. Plan figure trial_credits.
data[].limits.photoobjectyes—
data[].limits.photo.enabledbooleanyes—Whether this plan may generate images at all. Plan figure photo.enabled.
data[].limits.photo.max_concurrentintegeryes—Photo jobs in flight per account. Plan figure photo.max_concurrent.
data[].limits.photo.max_draftsintegeryes—Photo drafts an account may keep. Plan figure photo.max_drafts.
data[].limits.photo.max_imagesintegeryes—The most images one photo job may ask for: what the model makes in one job on every plan that carries Photos, 0 where it does not. No longer a plan figure.
data[].limits.photo.max_resolutionintegeryes—The largest photo render, in pixels on the long side: the model's largest on every plan that carries Photos, 0 where it does not. No longer a plan figure.
data[].limits.videoobjectyes—
data[].limits.video.enabledbooleanyes—Whether this plan may render video at all. Plan figure video.enabled.
data[].limits.video.max_concurrentintegeryes—Video clips in flight per account. Plan figure video.max_concurrent.
data[].limits.video.max_draftsintegeryes—Video projects an account may keep. Plan figure video.max_drafts.
data[].limits.video.tiersstring[]yes—The video tiers this plan may render: every tier when enabled is true, none when it is false.
data[].limits.video.max_duration_secondsintegeryes—The longest clip, in seconds: the model's longest on every plan that carries video, 0 where it does not. No longer a plan figure.
data[].limits.musicobjectyes—
data[].limits.music.enabledbooleanyes—Whether this plan may generate music at all. Plan figure music.enabled.
data[].limits.music.max_concurrentintegeryes—Music jobs in flight per account. Plan figure music.max_concurrent.
data[].limits.music.max_draftsintegeryes—Music drafts an account may keep. Plan figure music.max_drafts.
data[].limits.music.max_duration_secondsintegeryes—The longest song, in seconds: the model's longest on every plan that carries music, 0 where it does not. No longer a plan figure.
data[].limits.music.lyricsbooleanyes—Whether songs may have vocals: true on every plan that carries music. No longer a plan figure.
data[].limits.threedobjectyes—
data[].limits.threed.enabledbooleanyes—Whether this plan may generate 3D at all. Plan figure threed.enabled.
data[].limits.threed.max_concurrentintegeryes—3D jobs in flight per account. Plan figure threed.max_concurrent.
data[].limits.threed.max_draftsintegeryes—3D drafts an account may keep. Plan figure threed.max_drafts.
data[].limits.threed.tiersstring[]yes—The 3D tiers this plan may run: every tier on a plan that carries 3D, none where it does not. No longer a plan figure.
data[].limits.externalobjectyes—
data[].limits.external.max_concurrentintegeryes—Jobs on catalogue models (every model somebody else runs) in flight per account. Plan figure external.max_concurrent.
data[].limits.external.modalitiesstring[]yes—What catalogue models this plan may run, by what they make; empty means no catalogue model at all. Plan figure external.modalities.
data[].limits.external.max_job_creditsintegeryes—The most one catalogue job may cost on this plan, whatever the model's own ceiling. Plan figure external.max_job_credits.
data[].limits.external.max_draftsintegeryes—Playground forms, one per model, an account may keep. Plan figure external.max_drafts.
data[].limits.chatobjectyes—
data[].limits.chat.enabledbooleanyes—Whether this plan may chat at all; embeddings follow it. Plan figure chat.enabled.
data[].limits.chat.max_concurrentintegeryes—Chat turns streaming at once per account, counted before the reserve. Plan figure chat.max_concurrent.
data[].limits.chat.max_output_tokensintegeryes—The output ceiling per chat turn, which is what the turn's reserve is priced against. Plan figure chat.max_output_tokens.
data[].limits.chat.context_budgetintegeryes—How much conversation one chat turn may send, in bytes of UTF-8 text (not tokens), 64 a message beside its text and 128 a turn: the newest message counts first and is always sent; the oldest messages past it are left out. Plan figure chat.context_budget.
data[].limits.codeobjectyes—
data[].limits.code.enabledbooleanyes—Whether this plan may run Code at all. Plan figure code.enabled.
data[].limits.code.max_projectsintegeryes—Code projects an account may keep; each one is a volume. Plan figure code.max_projects.
data[].limits.code.max_concurrentintegeryes—Code machines running at once per account. Plan figure code.max_concurrent.
data[].limits.code.agent_max_output_tokensintegeryes—The output ceiling per round of Code's agent, which prices the round's reserve. Plan figure agent.max_output_tokens.
data[].limits.directorobjectyes—
data[].limits.director.enabledbooleanyes—Whether this plan may talk to the AI Director in Cinema Studio at all. Plan figure director.enabled.
data[].limits.director.max_output_tokensintegeryes—The output ceiling per round of the AI Director, which prices the round's reserve. Plan figure director.max_output_tokens.
data[].limits.director.auto_cap_maxintegeryes—The most a person may set as the AI Director's Auto mode cap for one chain of turns, in credits. Plan figure director.auto_cap_max.
data[].limits.director.auto_continue_maxintegeryes—How many turns in a row the AI Director's Auto mode carries a chain on by itself before the person's Continue. Plan figure director.auto_continue_max.
data[].limits.apiobjectyes—
data[].limits.api.may_generatebooleanyes—Whether an API key of this plan may generate (the generate and interactive buckets). Plan figure api.may_generate.
data[].limits.api.keys_maxintegeryes—Developer keys an account may keep. Plan figure api.keys_max.
data[].limits.api.webhooks_maxintegeryes—Webhook endpoints an account may register. Plan figure api.webhooks_max.
data[].limits.api.readobjectyes—
data[].limits.api.writeobjectyes—
data[].limits.api.generateobjectyes—
data[].limits.api.interactiveobjectyes—
data[].limits.api.egressobjectyes—
data[].limits.api.warmupobjectyes—A new account's warm-up: for hours after sign-up its API keys and its desktop session get percent of every bucket's burst and rate. A longer warm-up gives a new account less.
data[].limits.sessionobjectyes—
data[].limits.session.readobjectyes—
data[].limits.session.writeobjectyes—
data[].limits.session.generateobjectyes—
data[].limits.session.interactiveobjectyes—
data[].limits.communityobjectyes—
data[].limits.community.comments_per_minuteintegeryes—How many comments one account may post in the Community in a minute. Plan figure community.comments_per_minute.
data[].limits.community.reports_per_hourintegeryes—How many reports one signed-in account may file in the Community in an hour. Plan figure community.reports_per_hour.
data[].limits.community.publishes_per_hourintegeryes—How many works one account may publish to the Community in an hour. Plan figure community.publishes_per_hour.
data[].limits.studioobjectyes—
data[].limits.studio.max_projectsintegeryes—Cinema Studio projects an account may own, counted when one is started or taken over. Plan figure studio.max_projects.
data[].limits.studio.max_itemsintegeryes—Items one Cinema Studio project may hold, the Trash counted, by the plan of the account that owns the project. Plan figure studio.max_items.
data[].limits.studio.max_elementsintegeryes—Cinema Studio elements an account may own, every version counted. Plan figure studio.max_elements.
data[].limits.studio.max_canvasesintegeryes—Canvases one Cinema Studio project may hold, by the plan of the account that owns the project. Plan figure studio.max_canvases.
data[].limits.studio.max_membersintegeryes—People one Cinema Studio project may seat, its owner counted, by the plan of the account that owns the project. Plan figure studio.max_members.
data[].limits.studio.enabledbooleanyes—Whether this plan may own Cinema Studio projects and elements at all; off, what an account owns stays, read-only. Plan figure studio.enabled.
data[].limits.studio.callsbooleanyes—Whether a project whose owner holds this plan may hold calls. Plan figure studio.calls.
data[].limits.studio.publishbooleanyes—Whether an account on this plan may publish its projects to the Community; withdrawing always works. Plan figure studio.publish.
data[].promotionobjectno—The offer running on this plan now, or null. It is what the next buyers of the plan get, not what the plan grants: the plan's own figures above are unchanged by it. An offer with no places left is not listed. One place per account: an account that has held a place of this offer before (one that ended, or was given back after a refund or a dispute, included), or that holds another offer's place, takes none, whatever audience admits. On Free (plan free) nothing is bought: a place is taken when an account on Free with a confirmed email address uses Auray while the offer runs, one place per account and per email inbox, and its term counts in UTC calendar months. May be null.
data[].promotion.codestringyes—The offer's code.
data[].promotion.planstringyes—The plan id the offer is on; equal to this plan's id.
data[].promotion.unlimited_creditsbooleanyes—Whether a place waives charges on the products in waives.
data[].promotion.waivesstring[]yes—The products whose jobs a place waives. Catalogue models (external) are not waived unless the offer names them; empty for an offer that only raises limits. A place waives only what its plan runs, with the offer's lifts: a product this plan's limits close is not opened by being named here.
data[].promotion.waives_modelsobjectyes—The models a place waives by name beside the products in waives, by product: catalogue slugs (external), chat slots (chat, code), the embedding model (embeddings), or one of our own four under its own product (photo, music, video, threed) by its catalogue address, such as krea2 under photo. A job on one of these models is waived; every other model of the product is charged. An explicit list: a model added to the catalogue later is not waived unless the offer is changed to name it. On code, a model covers the agent’s turns on it and not a machine’s time. {} for an offer that waives whole products only, or only raises limits.
data[].promotion.model_namesobjectyes—The name a customer reads for each slug in waives_models, e.g. {"auray-serverless-bytedance-seedance-2-0": "ByteDance Seedance 2.0"}. A slug this build does not know is absent.
data[].promotion.seatsintegeryes—How many places the offer has.
data[].promotion.seats_leftintegeryes—How many places are still to be taken; always above zero here.
data[].promotion.recurringbooleanyes—True when a place holds while the offer runs (and, once it closes, to the end of the holder's billing period — on Free, of the UTC month it closed in) — duration_kind subscribed; false for any other duration.
data[].promotion.starts_atstringyes—When the offer began taking places. An existing offer admits a subscription made before it — on Free, an account made before it. May be null.
data[].promotion.ends_atstringyes—When the offer stops taking new places, or null for no set end. May be null.
data[].promotion.liftsobjectyes—The plan figures a place raises, by key, e.g. {"music.enabled": true, "video.max_concurrent": 3}.
data[].promotion.audiencestringyes—Who may take a place: new — a subscription made while the offer runs, on its first paid invoice; existing — a subscription made before the offer began (starts_at), when it pays for this plan; all — any paid invoice of any subscription to this plan, whenever it was made. On Free, by when the account was made: new — at or after starts_at; existing — before it; all — any account on Free. One of "new", "existing", "all".
data[].promotion.with_trialbooleanyes—Whether the paid invoice that ends a free trial may take a place. False means an offer and a trial do not stack at the trial's conversion: that invoice takes none, and a later payment of the same subscription can where audience admits it. Always false on Free, which has no trial.
data[].promotion.duration_kindstringyes—How long a place holds from the paid invoice that took it: periods — duration_count billing periods; days — duration_count days; calendar — to the end of that calendar month (UTC); subscribed — while the plan is held and the offer runs. On Free, from when the account's use took it, in UTC calendar months: periods — to the end of the duration_countth month counted from that one; days — duration_count days; calendar — to the end of that month; subscribed — while the account stays on Free and the offer runs. One of "periods", "days", "calendar", "subscribed".
data[].promotion.duration_countintegeryes—The number of billing periods — on Free, calendar months — or days for periods and days; null for the other two. 1 to 36. May be null.
data[].promotion.credits_capintegeryes—The offer's shared credits budget: the most credits of waived jobs every holder together is given. When it runs out the offer ends early — it takes no new places, and every holder's jobs are charged from then, to the end of their term. Null for an offer with no such budget. 1 to …. May be null.
data[].promotion.credits_leftintegeryes—What is left of credits_cap for everyone in the offer, never below zero; null when there is no credits_cap. 0 to …. May be null.
data[].promotion.per_seat_credits_capintegeryes—The most credits of one place's jobs the offer waives; past it that holder's jobs are charged. Null for no such cap. 1 to …. May be null.
data[].promotion.budget_cappedbooleanyes—Whether a budget kept in money (not served) also bounds the offer: when true, the offer can end early before credits_left reaches zero, with the same effect.
trial_offeredbooleanno—Whether the payment provider that takes checkouts now gives the free trial a plan's trial_days describes. Only one of the two providers does, so a card promises a trial only while this is true. null when the switch between them could not be read, which promises nothing. May be null.
pricesany[][]no—The per-generation prices we have moved off their published constants, as [key, credits] pairs such as ["photo.per_image.1024", 2], sorted by key. Empty when nothing is moved or the table cannot be read, which means the published prices apply. What a plan's credits make is counted from these.
price_keysobject[]no—Every price our own models are charged by, at its figure in force: our move where there is one, else the published constant — the table the submit prices from, so a 3D tier's credits (threed.<tier>) can be read before a job is charged them. In a fixed order. A value is credits except where its description says otherwise: music.seconds_per_credit is seconds of audio one credit buys, video.reference_multiplier_pct a per cent. When the moved prices cannot be read these are the constants.
price_keys[].keystringyes—The price's key, <product>.<key>: photo.base, threed.textured, video.fast.10.
price_keys[].valueintegeryes—The figure in force.
price_keys[].overriddenbooleanyes—Whether a move of ours supplied it rather than the published constant.
price_keys[].addressstringyes—The registry id of the model this price is charged on: krea2, minimax-music-3, minimax-h3, or a 3D tier's own id such as hunyuan3d-tier-textured. It is not an address you call: a model is called at its catalogue address, auray-ai/krea-2-turbo/text-to-image for krea2.
price_keys[].descriptionstringyes—What the figure is, in words.
api_lanesobjectno—Per product, the figure that admits API traffic at busy times. A plan's limits.<product>.max_concurrent is one account's ceiling in the app and the API together; through keys an account runs at most the smaller of that and this figure, and only while there is room — the next job queues, or a product that does not queue answers 429 lane_busy, uncharged. Keyed photo, music, threed, video and external (catalogue models, each family counted on its own). null when the figures could not be read. May be null.
request_idstringno—

Headers:

HeaderDescription
Cache-Controlpublic, max-age=60, stale-while-revalidate=300 when every read the answer rests on answered; no-store when one fell back.
X-Auray-FallbackOnly on an answer built on a fallback, which is no-store: the reads it fell back on, comma-separated, from plans, plan_overrides, price_overrides, promotions, offers and gateway. Absent when every read answered.
X-Request-Id

#Status codes

StatusMeaning
200OK. Plans in ladder order, cheapest first.

Every refusal names its code, and every code is explained at Errors.

Start typing to search every page of the documentation.

Up arrow Down arrow to moveEnter to openEscape to close