API cost per request estimator
On a plan that includes 100,000 calls, using 125,000 means 25,000 extra calls billed at the overage rate. Enter the monthly price, the allowance, your usage and that rate to see the overage charge, the monthly total and the real cost of one call. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Monthly plan cost
- 100
- Included requests
- 100,000
- Actual requests
- 125,000
- Overage price per request
- 0.0015
- Included cost per request
- 0.001
- Overage requests
- 25,000
- Overage cost
- 37.5
- Total monthly cost
- 137.5
Use it to compare tiers, review a production bill, or model expected traffic before committing to a plan. Values are currency-neutral, so enter every monetary amount in the same currency.
From a monthly plan to a real unit cost
Monthly prices are easy to budget but difficult to compare when plans include different request allowances. This calculator creates two related unit figures. The response also echoes the inputs, reports whether usage exceeded the allowance, and provides the formula for auditability.
All money fields are currency-neutral. If the monthly plan cost is in dollars, every reported cost is in dollars; if it is in euros, all results are in euros. Do not mix currencies or billing periods.
Convert annual commitments, credits, or quarterly invoices to one representative monthly amount before submitting them. The calculation measures direct request charges only. Add those items to the monthly plan cost when they truly belong in the fixed monthly total.
Calculate included usage, overages, and the effective rate
Overage requests equal actual requests minus included requests, with a floor of zero. Overage cost is that excess count multiplied by the overage price, and total monthly cost is the plan price plus the overage cost. When actual usage is zero, the calculator returns zero for the effective per-request value instead of dividing by zero; the total monthly cost still shows the plan expense.
When the included allowance is zero, the included cost benchmark is likewise reported as zero because no included unit exists, while any actual calls are correctly counted as overage. A negative included volume is explicitly rejected, as are negative prices, negative actual usage, non-finite values, unsafe request counts, and unsupported precision settings.
Use the estimate for plan selection and monthly cost control
A larger plan may have a better nominal included rate yet cost more per actual request when demand remains below its allowance. Conversely, a smaller tier can appear economical until overage charges push its total above the next tier. The estimator makes that crossover visible without pretending to forecast traffic.
During operations, feed it the provider's current-month request count to monitor how the effective rate evolves and to estimate the direct bill if the month ended at that volume. Interpret the result in the context of the provider's billing rules. In those cases, normalize the usage count and overage rate before calculation or run separate estimates for each charge category.
This tool estimates a transparent request-based plan; it does not reproduce an undisclosed or multi-dimensional invoice engine.
What you can do with it
Build usage budget alerts
Turn current request volume into consistent overage, total-cost, and effective-unit-cost fields for reporting workflows.
FAQ
What does this calculator cost?
It is free to run in the browser.
What is the difference between included cost and effective cost?
Included cost divides the plan price by the allowance, the unit price if you used it all. Effective cost divides the whole monthly bill by all calls you actually made, so it rises when a plan is underused.
How are overage calls counted?
Usage above the allowance is overage, and it never drops below zero. With 125,000 calls on a plan that includes 100,000, the extra 25,000 are multiplied by the overage rate and added to the plan price.
Can I enter amounts in different currencies or an annual price?
No. All amounts must use one currency and one billing month. Convert an annual commitment, credits or a quarterly invoice into a single monthly figure before entering it, and every result comes out in that currency.
Are taxes or data transfer fees included?
No. Only direct usage charges are counted. Taxes, data transfer, support fees or minimum commitments are not guessed; if one is truly a fixed monthly cost, add it to the plan price yourself.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/dev/api-cost-per-request-estimate \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"monthly_plan_cost":100,"included_requests":100000,"actual_requests":125000}'const res = await fetch("https://api.kit.forhosting.com/dev/api-cost-per-request-estimate", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"monthly_plan_cost": 100,
"included_requests": 100000,
"actual_requests": 125000
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/api-cost-per-request-estimate",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"monthly_plan_cost": 100,
"included_requests": 100000,
"actual_requests": 125000
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/api-cost-per-request-estimate", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"monthly_plan_cost":100,"included_requests":100000,"actual_requests":125000}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"monthly_plan_cost":100,"included_requests":100000,"actual_requests":125000}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/api-cost-per-request-estimate", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"monthly_plan_cost": 100,
"included_requests": 100000,
"actual_requests": 125000
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.api_cost_per_request_estimate",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_value | 1000000000000000 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
An API subscription can look inexpensive until usage is expressed as a cost for every request that actually ran. This estimator combines the recurring monthly plan price, included request allowance, actual monthly volume, and provider overage rate. It reports the plan's included-unit benchmark, excess request count, overage charge, total monthly cost, and effective cost per actual request. The calculation runs free in the browser, while an automated call costs $0.002 per successful request.
Turn a monthly API subscription into a usable unit cost
The included cost per request divides the recurring plan cost by the included request volume, showing the nominal price of fully consuming the allowance. The effective cost per request divides the complete calculated monthly bill by the number of requests actually made. That second number changes with utilization: an underused fixed plan has a higher effective unit cost because the same subscription price is spread across fewer calls. It does not infer taxes, data transfer fees, compute surcharges, premium endpoints, token charges, support fees, or minimum commitments that are absent from the inputs.
Calculate included usage, overages, and the effective rate
Enter monthly_plan_cost as a finite non-negative amount and included_requests as the non-negative integer allowance printed by the provider. Enter actual_requests as the non-negative number observed for the same billing month. If the provider charges for calls beyond the allowance, set overage_price_per_request to that published rate; it defaults to zero for plans with no request overage charge or when you only want to study fixed-plan utilization. Finally, effective cost per request is total monthly cost divided by actual requests.
Use the estimate for plan selection and monthly cost control
Before buying an API plan, run realistic low, expected, and high traffic scenarios. Finance and engineering teams can use the same response fields in a budget worksheet, vendor review, internal chargeback model, or alert explanation. Automated workflows can call the deterministic API for $0.002 per successful request, receiving the same calculation for identical inputs without network lookups, randomness, or time-dependent behavior. Some vendors round usage blocks, price different endpoints separately, exclude failed calls, reset allowances by account, or bill tokens rather than requests.
Integration use cases
Choose an API subscription tier
Compare expected utilization and overage exposure before committing to a monthly request allowance.
Review a monthly vendor bill
Reconstruct the request-based portion of a bill from the plan fee, measured calls, and published overage rate.
Technical questions
How is effective API cost per request calculated?
The calculator adds monthly plan cost and overage cost, then divides that total by actual requests. When actual usage is zero, it returns zero rather than dividing by zero.
How is API overage cost calculated?
Requests above the included allowance are multiplied by overage_price_per_request. Usage at or below the allowance produces zero overage requests and zero overage cost.
What happens if included request volume is negative?
The request fails with invalid_input because an included request allowance cannot be negative.
Can I use any currency?
Yes. The calculator is currency-neutral, but monthly_plan_cost and overage_price_per_request must use the same currency and billing context.