Why an interrupted Cursor call does not need a fixed session fee
Advanced Cursor users often plan around a specific worry: a long-running request stops halfway, the answer never appears, and the balance still moves. With SwiftRelay, the billing model follows a simpler rule: each call deducts only what it used. There is no fixed session charge and no recurring fee to maintain, so the number that matters after an interruption is the token usage recorded for that call.
SwiftRelay is a pay-per-token API relay, and Cursor connects to it through the OpenAI-compatible endpoint. You point your Cursor setup at the SwiftRelay API host, https://api.fastapirelay.com, and use a swft_ key as the API key. From there, the connection is designed to be quick: copy three lines and run.
That setup changes how you can think about an interrupted request. Instead of asking whether a whole session should be treated as one package, you can inspect the call itself. The usage area lists tokens and cost per call, which gives you a concrete record to review when Cursor stops early, a connection drops or you close a task before the response is finished.
This is not about paying for tokens you never generated. It is about knowing where the accounting comes from. SwiftRelay charges according to the usage attached to the call, and the ledger shows that usage. That makes a mid-call interruption a case for checking the numbers, not a case for guessing.
Reading an interrupted Cursor call in the usage ledger
The advanced move is to treat the usage list as your first diagnostic after any interrupted Cursor request. Each entry gives you tokens and cost per call, so you can compare the recorded call against what you remember sending and what you saw Cursor display before the interruption.
Start with three questions. First, did the request fail before the model produced output, or did it stop after some output had already been generated? Second, how many input tokens and output tokens does the usage entry show? Third, what cost does SwiftRelay attach to that entry? Those answers replace vague assumptions with a measurable position.
For an OpenAI-compatible workflow in Cursor, the relevant models include GPT-6 Astra, GPT-6.1 Sol, DeepSeek V4 Flash and DeepSeek V4 Pro. Their input, output and cache read rates are shown on the SwiftRelay pricing page, so you can follow the same model from the price list to the per-call figure in the usage area.
Cache read entries deserve particular attention because they are billed separately from ordinary input and output. If your Cursor project reuses a large, stable context, the cache read rate can be a meaningful part of the cost picture. When a call is interrupted, check the full token record rather than only the visible response length.
If the numbers do not line up with your expectations, SwiftRelay support is available through Messages in the dashboard, where login is required. There is no support email to hunt for. Keeping the model name, the call entry and your Cursor configuration in view will make that message much more useful.
A worked example of four interrupted Cursor calls
The following is an example only. It uses the current SwiftRelay prices per 1M tokens and assumes each call recorded 1,000,000 input tokens and 100,000 output tokens before the request was interrupted.
- GPT-6.1 Sol: input of $0.1736 plus output of $0.08542 gives a total of $0.25902 for that example call.
- DeepSeek V4 Flash: input of $0.2639 plus output of $0.106 gives a total of $0.3699 for that example call.
- GPT-6 Astra: input of $0.6597 plus output of $0.328 gives a total of $0.9877 for that example call.
- DeepSeek V4 Pro: input of $1.17 plus output of $0.351 gives a total of $1.521 for that example call.
Now imagine that all four example calls were interrupted in the same afternoon. The combined example spend is $0.25902 + $0.3699 + $0.9877 + $1.521 = $3.13762. Every part of that sum comes from the listed SwiftRelay rates, and every one of those calls should appear separately in the usage list with its own tokens and cost.
This example shows why a per-token relay is useful for irregular Cursor work. If one model handles quick edits and another handles a heavier reasoning pass, you can see the cost of each interrupted attempt without trying to divide a flat fee into imaginary parts. You can also decide whether a retry should use the same model or a different one based on the recorded cost, not on a guess.
One more example detail is worth noting. If a call also included cache reads, add those at their own rates. DeepSeek V4 Flash lists cache read at $0.006944 per 1M tokens, DeepSeek V4 Pro at $0.0389, GPT-6 Astra at $0.0653 and GPT-6.1 Sol at $0.0347. Keeping the three components separate in your notes makes an interrupted call much easier to audit later.
Top-ups, refunds and balance moves for unpredictable Cursor workloads
Per-token billing only works smoothly if the balance is ready before the next Cursor request. SwiftRelay sells no subscriptions and has no recurring charge, so you top up a balance and each call deducts only what it used. The available top-up amounts are $1.39, $6.94, $13.89, $27.78, $69.44 and $138.89.
For an advanced workflow, choose the top-up that matches how often you expect to run interrupted or retried requests, rather than treating the balance like a fixed monthly commitment. A smaller top-up keeps the experiment tight; a larger one removes repeated top-up interruptions from the middle of a work session. Either way, the deduction remains tied to actual token usage.
There is also a clear refund route for credit you have not used. SwiftRelay refunds unused credit within 11 days of a top-up, minus what was used and the payment fee. That rule is particularly relevant when you are testing a heavier Cursor model for a short period and want to know what happens to the remainder of the top-up.
The referral programme adds another balance lever. You receive 14% of each top-up by someone you invited, plus 3% from the people they invite. Rewards can be withdrawn once the minimum is $4.86, or they can be moved into the balance for use on later Cursor calls. New accounts also receive $0.22 in sign-up gift credit, which is enough to put a first request through and see the usage record for yourself.
A practical Cursor runbook for the next interruption
Here is a repeatable routine for Cursor users who want fewer surprises. Before running a task, note the model you selected and confirm that your Cursor session is pointed at the SwiftRelay API host with a valid swft_ key. Up to 20 live API keys can be active per account, so you can keep separate keys for separate projects or machines instead of editing one key constantly.
When a request stops halfway, do not immediately retry in a loop. Open the SwiftRelay dashboard and locate that call in the usage area. Record the input tokens, output tokens, cache reads and the cost shown for the call. If the model choice feels too expensive for the task, compare it with another listed model using the same method you used in the worked example.
Next, decide whether the interruption came from the request itself, the connection or the size of the task. If the request was simply too broad, split it into smaller Cursor steps, because smaller steps make the token record easier to read and the cost of a failed attempt easier to judge. If you need help, send the details through Messages in the dashboard.
Finally, keep the balance funded and the ledger familiar. Top up at one of the available amounts, watch how the balance moves after each call, and use the refund window when appropriate. This is the practical value of a pay-per-token API proxy for Cursor: you stay in control of the balance, you can see the cost of every call, and an interrupted run becomes a reviewable entry rather than an unexplained deduction.
Start your first SwiftRelay run now: connect in minutes, watch the per-call cost, and keep every Cursor interruption on the record.