Collect the result of one submitted request.

The collect endpoint. On a request that has finished successfully it returns the partner model's own native output, byte for byte what the synchronous route's 200 carries for the same model and the same input - so the two delivery modes produce one result shape and a caller can move between them without a second parser.

OpenAPI

````yaml /router-openapi.yaml get /v2/models/{provider}/{model}/requests/{request_id} openapi: 3.0.2 info: title: Comfy Router description: >- Comfy Router's public contract: the model catalog and the model-ID-addressed invocation routes, with the error buckets they return. Projected from the canonical Comfy API contract. version: '1.0' servers:

url: https://api.comfy.org security: [] tags:
name: Comfy Router description: Comfy Router's canonical, model-ID-addressed routes. paths: /v2/models/{provider}/{model}/requests/{request_id}: get: tags:
Comfy Router summary: Collect the result of one submitted request. description: >- The collect endpoint. On a request that has finished successfully it returns the partner model's own native output, byte for byte what the synchronous route's 200 carries for the same model and the same input
so the two delivery modes produce one result shape and a caller can move between them without a second parser. operationId: getRouterModelRequestResult parameters:
$ref: '#/components/parameters/RouterProvider'
$ref: '#/components/parameters/RouterModel'
$ref: '#/components/parameters/RouterQueueRequestId' responses: '200': description: >- OK - the result stored for a request that produced one - a request that completed successfully, or a terminal one that carries both a recorded charge and a stored result - returned unchanged under the partner's own media type, exactly as the synchronous route's 200 returns it, and under the same provider-selection contract the submit accepted: without model_provider, or with model_provider and strict_mode=false (the default, translated back into this model's native contract when possible, falling back to the alternate provider's own raw response on a translation failure - logged, never silent), the shape is this model's own native output; with strict_mode=true it is the alternate provider's response returned unchanged. For most models that is JSON (RouterModelOutput); for a model whose partner answers a generation directly as bytes it is those bytes under the partner's own Content-Type. Today no such model can be queued (the submit refuses it), so this branch is declared for the SDK contract ahead of the server serving it. A client must branch on the response Content-Type and must not assume a JSON document; the per-model contract is published at `GET /v2/models/{provider}/{model}/openapi.json`. This response carries X-Content-Type-Options: nosniff, so a partner media type is taken at its word and never sniffed into something else. headers: X-Comfy-Request-Id: $ref: '#/components/headers/RouterRequestIdHeader' X-Content-Type-Options: $ref: '#/components/headers/RouterNoSniffHeader' X-Comfy-Credits-Used: $ref: '#/components/headers/RouterCreditsUsedHeader' content: application/json: schema: $ref: '#/components/schemas/RouterModelOutput' '/': schema: type: string format: binary '202': description: >- Accepted - the request has not finished. The body is the same RouterQueueStatusResponse the status read returns, so this route can be polled on its own, and Retry-After hints when to ask again. headers: X-Comfy-Request-Id: $ref: '#/components/headers/RouterRequestIdHeader' Retry-After: $ref: '#/components/headers/RouterQueuePollAfterHeader' content: application/json: schema: $ref: '#/components/schemas/RouterQueueStatusResponse' '401': $ref: '#/components/responses/RouterRequestError' '403': $ref: '#/components/responses/RouterRequestError' '404': $ref: '#/components/responses/RouterRequestError' '409': $ref: '#/components/responses/RouterRequestError' '410': $ref: '#/components/responses/RouterRequestError' '429': $ref: '#/components/responses/RouterRateLimited' '503': $ref: '#/components/responses/RouterRequestError' '504': $ref: '#/components/responses/RouterRequestError' default: $ref: '#/components/responses/RouterRequestError' security:
BearerAuth: []
ApiKeyAuth: [] components: parameters: RouterProvider: name: provider in: path required: true description: >- Lowercase provider segment of the canonical {provider}/{model} model ID - the partner whose model is being run. schema: $ref: '#/components/schemas/RouterProviderSegment' RouterModel: name: model in: path required: true description: >- Lowercase model segment of the canonical {provider}/{model} model ID - the model to run within that provider. schema: $ref: '#/components/schemas/RouterModelSegment' RouterQueueRequestId: name: request_id in: path required: true description: >- The queued request to address - the request_id the submission returned in its body. It is not the submission's X-Comfy-Request-Id: that header carries the id of one HTTP call and addresses nothing, as the RouterQueueRequestId schema spells out. schema: $ref: '#/components/schemas/RouterQueueRequestId' headers: RouterRequestIdHeader: description: >- Server-generated identifier for this call, present on every Router response - success, 4xx and 5xx alike, because an error response is exactly when a user needs an id to quote in a support request. The same value is written into the call's usage/audit event, which is what lets a complaint about a charge be joined to the charge itself instead of searched for by timestamp. required: true schema: type: string format: uuid example: 6f1a1a6e-6a53-4a5f-9d3a-2b3b0a1f9c21 RouterNoSniffHeader: description: Always nosniff, on every successful run of a Router model. required: true schema: type: string enum:
nosniff example: nosniff RouterCreditsUsedHeader: description: >- What this run cost, in Comfy credits, priced from the same rate card the charge itself is billed against - so a caller needs no price table of its own, and on a run that reached the provider through more than one billed call it is their sum rather than the last one. It reports a price, not a settled ledger entry. On a model Comfy bills while your request is still open, the value is published only once the usage event was accepted by billing; on a model that submits and then polls, it is the price the asynchronous worker will bill, recorded before that charge settles - so a run whose billing later fails can still have carried this header. Treat it as what you will be charged, not as proof you were, and reconcile against the usage and billing API rather than against this header alone. Absent whenever no cost was reported: a request billed against your own provider key, a partner whose response does not carry every dimension its price is computed from, a usage event that matched no billable metric, or a charge that did not reach billing - so a missing header means "not reported" and must not be read as "free", and a report that sums absent headers as zero will not reconcile. A run that was rated and genuinely cost nothing reads 0, which is a reported cost rather than a missing one, so branch on whether the header is present rather than on whether its value is non-zero. Coverage is partial today and widening, so do not assume the header is present for every model. On a response that also carries Idempotent-Replayed: true this restates what the original run cost, and that run is charged once however many times you retry the key - so do not add the header up across retries of one Idempotency-Key. Absent on an error response, with one exception: a synchronous content_policy_violation from a model whose charges_on_policy_rejection is yes, for which Comfy recorded usage because the provider refused the model's generated output, carries the amount Comfy recorded (a same-key replay of that refusal does not). As everywhere else, an absent header on a refusal means "not reported", not "free"; the settled figure is in your usage records. required: false schema: type: string example: '12.5' RouterQueuePollAfterHeader: description: >- Seconds to wait before polling this queued request again. It is Router's own estimate of when asking again is worth the round trip: while the request waits it grows with its place in the queue, while it runs it grows with how long it has been running, and it stops growing at 10. required: false schema: type: integer minimum: 1 example: 3 RouterErrorTypeHeader: description: >- Coarse, machine-readable bucket for the failure, set by Router on every error response. It carries the same value as RouterErrorResponse.error_type, and on the 422 it is the only machine-readable bucket, because that body is the FastAPI detail[] shape and has no error_type field of its own. A client can therefore branch on this header alone, before deciding which of the two Router error bodies it received. required: true schema: $ref: '#/components/schemas/RouterErrorType' RouterRateLimitRetryAfterHeader: description: >- Seconds to wait before sending another request after a 429 carrying error_type: rate_limited: the time until the caller's per-minute request allowance has refilled enough to admit one more request. It is sent on every rate_limited refusal and on no other answer, so it is absent on a 429 whose X-Comfy-Error-Type is concurrency_limit_exceeded or queue_backlog_full. Nothing the caller does drains it early; a request sent sooner is refused again and spends nothing, but gains nothing either. required: false schema: type: integer minimum: 1 example: 2 schemas: RouterModelOutput: type: object description: >- A partner model's native JSON output document, returned to the caller as-is. Its concrete shape is owned by the partner rather than by Comfy, so this is an open object: Router does not narrow, rename, or re-envelope the fields. It is a named component (never an inline anonymous object) because ComfyUI's spec-driven codegen needs a class to generate. For the concrete shape one model returns, read that model's own document at GET /v2/models/{provider}/{model}/openapi.json, whose 200 carries the per-model output schema when Comfy has described it. additionalProperties: true RouterQueueStatusResponse: type: object description: >- One queued request's current state, composed with the same three URLs the submission returned. allOf:
$ref: '#/components/schemas/RouterQueueUrls'
$ref: '#/components/schemas/RouterQueueStatusFields' RouterProviderSegment: type: string description: >- Lowercase provider segment of the canonical {provider}/{model} model ID - the partner whose model is being addressed. The invocation route's provider path parameter and a catalog entry's provider field both reference this one schema, which is what keeps the listed IDs and the accepted IDs from drifting apart. pattern: ^[a-z0-9]+([._-][a-z0-9]+)*$ maxLength: 64 example: bfl RouterModelSegment: type: string description: >- Lowercase model segment of the canonical {provider}/{model} model ID
the model to run within that provider. Shared by the invocation route's model path parameter and a catalog entry's model field, for the same no-drift reason as RouterProviderSegment. pattern: ^[a-z0-9]+([._-][a-z0-9]+)*$ maxLength: 128 example: flux-2-pro RouterQueueRequestId: type: string format: uuid x-go-type: string pattern: ^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$ maxLength: 36 description: >- Identifier of one queued Router request - the handle a caller polls, cancels and collects a result by. example: 6f1a1a6e-6a53-4a5f-9d3a-2b3b0a1f9c21 RouterQueueUrls: type: object description: >- The three URLs that address the rest of one queued request's lifetime, returned on every response that carries a live handle so a client never composes a queue URL itself. properties: status_url: type: string format: uri description: Absolute URL of this request's status read. example: >- https://api.comfy.org/v2/models/bfl/flux-pro-1.1/requests/6f1a1a6e-6a53-4a5f-9d3a-2b3b0a1f9c21/status response_url: type: string format: uri description: Absolute URL this request's result is collected from. example: >- https://api.comfy.org/v2/models/bfl/flux-pro-1.1/requests/6f1a1a6e-6a53-4a5f-9d3a-2b3b0a1f9c21 cancel_url: type: string format: uri description: Absolute URL a cancellation is asked for at. example: >- https://api.comfy.org/v2/models/bfl/flux-pro-1.1/requests/6f1a1a6e-6a53-4a5f-9d3a-2b3b0a1f9c21/cancel required:
status_url
response_url
cancel_url RouterQueueStatusFields: type: object description: >- The half of RouterQueueStatusResponse that is not the URL block: one queued request's identity, its current state, and - when that state is terminal and the run did not succeed - the coarse bucket saying why. properties: request_id: $ref: '#/components/schemas/RouterQueueRequestId' status: $ref: '#/components/schemas/RouterQueueStatus' queue_position: $ref: '#/components/schemas/RouterQueuePosition' error_type: allOf:
$ref: '#/components/schemas/RouterErrorType' description: >- Present only on a COMPLETED request that did not succeed, carrying the same coarse bucket the result read puts on X-Comfy-Error-Type when it returns that failure. It is what distinguishes a terminal request that succeeded from one that failed or was cancelled - there is no separate terminal status for either - and it is absent on success rather than null, so branch on its presence. required:
request_id
status RouterErrorResponse: type: object description: >- Router's request-level error body: what is returned when the request never reached the model, or failed for a reason the model itself did not report - auth, quota, an unknown model ID, or provider transport. A model-level validation failure has its own shape, RouterValidationErrorResponse, because flattening a FastAPI detail[] array into this detail string would destroy the per-field granularity an SDK branches on. properties: detail: type: string description: >- Human-readable description of the failure, safe to surface to an end user. Not machine-parsed - branch on error_type instead. For model_not_found on a retired model, detail reads `<id> was retired on <YYYY-MM-DD>; use <successor>` when a successor is recorded and visible to the caller, or just `<id> was retired on <YYYY-MM-DD>` when it is not, instead of the usual suggestion list. A successor named here is always a live catalog ID the call can be re-pointed at. A model whose sunset date is still in the future is not retired: it stays listed by GET /v2/models and stays runnable until that date. Like the rest of detail, this retirement wording is for display and carries no compatibility guarantee. error_type: $ref: '#/components/schemas/RouterErrorType' upstream_detail: type: string description: >- A bounded, sanitized reason for an invalid_input rejection. On the synchronous route it is the reason the model provider gave, present only when error_type is invalid_input and X-Comfy-Upstream-Status is a provider 4xx or 2xx - i.e. the provider refused the request as malformed and said why. Usually that status is a 4xx; it is a 2xx for a provider that reports a rejected generation inside a success envelope (a BytePlus failed-task poll is HTTP 200 with the reason in its body). There it is absent on every other failure, including provider 5xx, transport failures, content-policy refusals and any refusal Router raised about itself, and it mirrors the X-Comfy-Upstream-Detail header. The queued collect (`GET /v2/models/{provider}/{model}/requests/{request_id}`) of a run that ended invalid_input carries the same reason in this field on its first collect, which then deletes it from the request: a later collect normally answers the same error_type and detail without it, so read it from the first collect. That read sends neither header. The queued collect also uses this field for Router's own reason when Router refused the request before sending it to the provider and can state why in one sentence, which the synchronous route answers in detail; a refusal that names individual fields carries none. refusal_subject: type: string description: >- Which input or output a content-policy refusal was about, as a Router-level closed vocabulary: input, output, input_text, input_image, input_video, input_audio, output_text, output_image, output_video, output_audio. The bare input / output values name the side when the provider did not name a modality. Present only when error_type is content_policy_violation and the provider named the refused subject with a machine-readable code; absent otherwise. Never provider text. Named today for BytePlus, Runway, BFL, Gemini, Veo, Vertex, xAI and Wan refusals, and for the MiniMax Router's Nano Banana legs' Gemini refusals; a provider whose refusal does not say which side it was about leaves it absent. It mirrors the X-Comfy-Refusal-Subject header. denied_reason: type: string description: >- Billing's policy branch for a partner-node spend denial - no_funds when the billed wallet is empty, unspecified when the call was refused without a funds reading saying so. Present only when error_type is insufficient_credits and the deployment reports wallet facts; absent otherwise. A machine-readable code, not display text: show detail, branch on this. billed_workspace: $ref: '#/components/schemas/RouterBilledWorkspace' credential_kind: type: string description: >- How the refused request authenticated - personal_api_key, team_api_key, personal_session or team_session. Answers "which credential do I switch to bill the other wallet?". It is not a permission and grants nothing. Present only alongside denied_reason. required:
detail
error_type RouterQueueStatus: type: string description: >- The state of a queued Router request. It has exactly three values, and unlike RouterErrorType this one is a closed enum, because the two schemas are closed in opposite directions on purpose. RouterErrorType classifies failures and its set is expected to grow, so a generated client that hard-rejected an unrecognised bucket would fail hardest exactly when something had already gone wrong. This one is a lifecycle, and a lifecycle with a fourth state added later is a breaking change to every polling loop written against it whether it is declared as an enum or not - so it is declared as one, and the constraint is stated where a client can see it. enum:
IN_QUEUE
IN_PROGRESS
COMPLETED example: IN_QUEUE RouterQueuePosition: type: integer minimum: 0 description: >- How many requests are ahead of this one in the queue, at the instant the response was composed. Zero means this request is at the front. example: 3 RouterErrorType: type: string description: >- Coarse, machine-readable bucket for a Router failure, mirrored on the X-Comfy-Error-Type response header so a caller can branch without parsing the body. The set is closed at twenty values: the six request-level buckets invalid_input, content_policy_violation, provider_error, provider_timeout, insufficient_credits and model_not_found, plus the transport-level unauthorized, forbidden, concurrency_limit_exceeded, client_disconnected, internal_error, deadline_exceeded, not_enabled, service_unavailable, rate_limited, cancelled, queue_timeout, request_not_found, queue_backlog_full and result_expired. Closed describes the set as documented today, not a bound that holds forever: the set is expected to grow, which is why this is deliberately a plain string and not an enum, so a client must treat an unrecognised value as internal_error rather than switch exhaustively over the list above and break on the next addition. example: invalid_input x-comfy-error-types:
value: invalid_input tier: request meaning: >- The request was rejected before it reached the model - a malformed body, a malformed or expired pagination cursor, an input the model's own schema does not accept, or an Idempotency-Key that cannot serve this request (already used for a different request - the method, the path and query, or the body differ - or already consumed by a call whose response cannot be replayed). Sent with 409 in the key cases and with 400/422 in the others; the status says which, and the key cases are the ones answered by using a new key rather than by editing the request.
value: content_policy_violation tier: request meaning: >- The provider refused the request on content-policy grounds. The refusal is deterministic: re-sending the same input will be refused again.
value: provider_error tier: request meaning: >- The partner provider reported a failure of its own, or returned a response Router could not interpret as a result.
value: provider_timeout tier: request meaning: >- The partner provider did not answer within its deadline. This bucket is the provider timing out and never Router's own server deadline, which is reported as deadline_exceeded - the two share 504 and are separated because they name different causes: this one says the partner failed, that one says Comfy stopped holding the connection.
value: insufficient_credits tier: request meaning: The calling workspace does not have enough credits to run the model.
value: model_not_found tier: request meaning: >- The {provider}/{model} ID names no model Router can run: an unknown provider, an unenrolled id, one the catalog has retired past its sunset date, or a catalogued ID the provider does not currently serve for Comfy. A retired id's detail reads `<id> was retired on <YYYY-MM-DD>; use <successor>` when a successor is recorded and not withheld, or just <id> was retired on <YYYY-MM-DD> when it is not, instead of a suggestion list; the successor named for a retired id is always a live catalog ID you can re-point the call at, and a successor is dropped from detail either because the table records none, or because the recorded one is currently withheld behind an embargo the caller cannot see. A model whose sunset is still in the future is not withdrawn: it stays listed by GET /v2/models and stays runnable until the date, so a listing taken today remains the answer to what runs today. Otherwise detail carries up to three suggestions drawn from the models the caller is entitled to see, except for a catalogued ID the provider does not currently serve for Comfy, whose response carries no suggestions.
value: unauthorized tier: transport meaning: The request carried no usable credential.
value: forbidden tier: transport meaning: >- The credential is valid but is not entitled to this model or this operation.
value: concurrency_limit_exceeded tier: transport meaning: >- The workspace already has as many calls in flight as it is allowed; retry once one of them finishes. It carries one further condition on the run route, on a 409 rather than the 429 above: another call is already in flight for the Idempotency-Key this request presented. Re-send the same key after Retry-After seconds to collect that call's result.
value: client_disconnected tier: transport meaning: >- The caller closed the connection before Router could return a result. It is logged rather than delivered - there is no socket left to write it to - and it is an attribution, not a billing outcome: a provider generation that completed is billed regardless of whether the caller received the response.
value: internal_error tier: transport meaning: >- Router itself failed. It is also the value a client should treat any unrecognized bucket as, so a later addition to the set does not break a client generated before it.
value: deadline_exceeded tier: transport meaning: >- Comfy stopped holding the connection at its own configured bound before an answer arrived. It shares 504 with provider_timeout and the pair says which side ran out of time; this one is Comfy's own bound, so nothing about the request was rejected and the same request may be retried. It says nothing about the charge: a provider generation that completed is billed regardless of whether the caller received the response. Retry it with the same Idempotency-Key: when the provider had already accepted the generation, the retry collects that generation rather than dispatching another, and a Retry-After on the 504 says when to ask.
value: not_enabled tier: transport meaning: >- Comfy Router is not switched on for this caller yet. Nothing about the request is wrong and the model exists, which is why this is not model_not_found; it shares 403 with forbidden and is not the same thing, because forbidden is an entitlement decision about the caller while this is a state of the rollout. It is terminal: do not retry, and do not treat it as an outage. The one exception to "about the caller" is the queued submit, which also answers not_enabled for a model whose partner answers a generation directly as bytes: that model cannot yet be queued, so it is the model and not the caller that is refused, nothing is queued or charged, and the synchronous route POST /v2/models/{provider}/{model} runs it instead.
value: service_unavailable tier: transport meaning: >- A service Comfy Router depends on is temporarily unavailable and the caller did nothing wrong. Retry it with backoff: it is the one bucket here whose condition clears on its own, without the caller changing the request and without a concurrency slot freeing, which is what distinguishes it from the other retryable answers (concurrency_limit_exceeded, deadline_exceeded). It is separate from internal_error - which is a 500 and means Router itself failed - so a client can tell "come back shortly" from "this call is not going to work".
value: rate_limited tier: transport meaning: >- The caller has spent an allowance measured over a window and must wait for that window to roll. It shares 429 with concurrency_limit_exceeded and is not the same thing: that one clears the moment one of the caller's own in-flight calls finishes, so retrying in seconds is right, whereas nothing the caller does drains this one early. detail names the window, and Retry-After the seconds to wait.
value: cancelled tier: transport meaning: >- A queued request was withdrawn — through the cancel route, or by an operator — before it produced a result; it is terminal, and it is not by itself a statement about the charge. Cancelling stops Comfy waiting and it does not always stop the partner working, so a request cancelled while it was still IN_QUEUE was never dispatched and cannot be charged, whereas one cancelled after it was admitted may still be charged — a partner generation that completes is charged whether or not anyone collected it, which is why the cancel route calls the ask a request rather than a guarantee. It is not client_disconnected: that one says nobody is listening any more while a generation may still be running and billable, whereas this says the request itself was withdrawn. A caller polling the status read sees 200 with this in the body, because the request ended and so the read succeeded. Collecting the result of such a request answers 409 in Router's error envelope: that read also worked, and what it found is a request whose terminal state - the caller's own decision - leaves nothing to return. It is deliberately not 410, which on that route means the result aged out of its retention window, and not a 5xx, which would report the caller's own cancellation as a Router fault and read to a polling client as worth retrying.
value: queue_timeout tier: transport meaning: >- A queued request waited past its queue timeout without ever being admitted. Terminal, unbilled, and it never took a concurrency slot — the job never reached a provider. Deliberately not deadline_exceeded, which is the synchronous route's connection bound: a deadline_exceeded generation may be running and billable, whereas this one provably never started. It is returned under 504, which it shares with provider_timeout and deadline_exceeded because a status can only say that a clock ran out; which clock - the partner's, Comfy's connection bound, or the queue's admission bound - is what error_type carries. The request itself is terminal, so submit a new one rather than re-reading this one.
value: request_not_found tier: transport meaning: >- The request_id names no request of the caller's under this model. It is the second of the two conditions the queued reads' 404 covers; the first is the {provider}/{model} ID resolving to no partner model, which is model_not_found and carries fuzzy model suggestions. It also covers the right-id / wrong-model URL the path shape refuses, and it is deliberately indistinguishable from a request in another workspace, so a probe with a guessed id learns nothing. A request that has merely aged out of its retention window is 410, not this.
value: queue_backlog_full tier: transport meaning: >- The caller already has too many queued requests waiting to run, so this submit was refused. It shares 429 with concurrency_limit_exceeded and is not the same thing: that one is the synchronous route's answer for too many calls in flight at once, whereas the queue accepts a submit at that limit and parks it, and this bucket is the separate bound on how many a caller may leave waiting so that parking cannot mean enqueuing without end. It clears as the caller's own queued requests finish, so retry once some of them complete.
value: result_expired tier: transport meaning: >- The request existed and finished, but its result is no longer stored, so the collect has nothing to return. It is returned under 410 and is permanent for that id: re-reading will answer the same way, so do not retry it. It is deliberately not request_not_found, which would tell you the id was never valid and invite re-submitting a generation that has already run. Running the model again means submitting a new request. For a workspace under a zero-data-retention agreement, a queued request's result is not kept after it is delivered: it is removed shortly after the first collect, and an uncollected result is removed after a grace period once the request finishes, so store the result on your side when you first collect it. RouterBilledWorkspace: type: object description: >- The wallet a refused call would have charged, on RouterErrorResponse.billed_workspace. Answers "which wallet is empty?"
it is not necessarily the workspace the caller's UI currently has selected, and a team member's personal credential names their personal wallet here even while a funded team is open. Present only alongside denied_reason. properties: id: type: string description: The Cloud workspace id. Absent on the legacy rail. type: type: string description: >- personal or team. An open string: treat any other value as personal. rail: type: string description: >- legacy when the call bills the caller's pre-workspace Metronome customer rather than a Cloud workspace; that customer has no workspace id. Absent for a Cloud workspace. required:
type responses: RouterRequestError: description: >- A Router request-level failure - the request never reached the model, or failed for a reason the model itself did not report. The body is RouterErrorResponse and the bucket is repeated on X-Comfy-Error-Type. headers: X-Comfy-Error-Type: $ref: '#/components/headers/RouterErrorTypeHeader' X-Comfy-Request-Id: $ref: '#/components/headers/RouterRequestIdHeader' content: application/json: schema: $ref: '#/components/schemas/RouterErrorResponse' RouterRateLimited: description: >- The caller has spent their per-caller request allowance, which refills continuously over a one-minute window, and the request was refused before Router did anything with it. The bucket is always rate_limited: wait the number of seconds in Retry-After before sending the next request. Nothing was charged, and a request sent sooner is refused again. The body is RouterErrorResponse and the bucket is repeated on X-Comfy-Error-Type. headers: X-Comfy-Error-Type: $ref: '#/components/headers/RouterErrorTypeHeader' X-Comfy-Request-Id: $ref: '#/components/headers/RouterRequestIdHeader' Retry-After: $ref: '#/components/headers/RouterRateLimitRetryAfterHeader' content: application/json: schema: $ref: '#/components/schemas/RouterErrorResponse' securitySchemes: BearerAuth: type: http scheme: bearer bearerFormat: JWT description: >- Bearer token authentication. Normally a Firebase or Cloud JWT. A 'comfyui-' prefixed API key is also accepted in this header: the prefix classifies the value as an API key and it is validated exactly as if it had been sent in X-API-Key. ApiKeyAuth: type: apiKey in: header name: X-API-Key description: >- API key authentication. Send the key in the X-API-Key header; keys are prefixed with 'comfyui-' and are generated from user account settings. The same 'comfyui-' key is also accepted in Authorization: Bearer (see BearerAuth), and when both headers carry a key, X-API-Key wins.

````