UART frame time calculator
The UART frame time calculator converts a serial port configuration into an exact transmission duration.
Run — free
Enter the baud rate, number of data bits, parity mode, and stop bits to see the bit period, total bits per frame, frame time in several units, and theoretical frames per second. It models the complete asynchronous frame, including the mandatory start bit and every configured overhead bit, so it is more accurate than dividing payload bytes by baud rate alone. The calculation is deterministic, runs without network access, and is suitable for design checks, firmware timing budgets, test fixtures, and serial protocol documentation.
Count every part of the UART frame
A UART transmission does not put only payload bits on the wire. An idle line first changes state for one start bit, then carries the configured data bits, may carry one parity bit, and finishes with one or more stop-bit periods. This calculator adds those components before dividing by the baud rate. For the familiar 8N1 format, the count is one start bit, eight data bits, no parity bit, and one stop bit, for ten bit periods per frame. At 115200 baud, a frame therefore takes ten divided by 115200 seconds, not eight divided by 115200 seconds. Select even, odd, mark, or space parity and one additional bit period is included. Select 1.5 or 2 stop bits and that duration is included as well. The result reports each component separately, making the overhead visible and easy to review. It also reports the total frame duration in seconds, milliseconds, and microseconds, avoiding manual unit conversions when preparing a timeout, oscilloscope measurement, logic-analyzer annotation, or technical note.
Interpret baud rate and timing results correctly
In conventional binary UART, each symbol represents one bit, so a baud rate of 9600 means 9600 bit periods per second. The bit time is consequently one divided by the baud rate, while the frame time is the total number of configured bit periods divided by that same rate. The returned frames_per_second value is the ideal continuous-wire rate: it assumes frames are sent back to back with no software delay, flow-control pause, packet gap, interrupt latency, USB scheduling interval, or application think time. It is useful as a ceiling, not a promise of end-to-end throughput. Likewise, the calculator describes framing time rather than encoding uncertainty. A real transmitter and receiver have oscillator tolerances, sampling rules, and hardware-specific limits that determine whether communication remains reliable. Use the frame duration for scheduling and capacity estimates, then consult the microcontroller, UART bridge, or transceiver data sheet for permissible baud error. The accepted stop-bit values are one, one and a half, and two; parity may be none, even, odd, mark, or space. Inputs outside these explicit domains fail instead of being silently rounded into a different serial format.
Apply frame time to buffers, timeouts, and protocol plans
Frame timing becomes especially useful when a serial protocol sends fixed-length messages. Multiply frame_time_seconds by the number of transmitted characters to obtain the wire time for a message, then add any protocol-mandated silent interval and a realistic allowance for scheduling or processing. That estimate helps firmware authors choose receive timeouts that are long enough for the configured link but short enough to detect a missing response. It also helps size buffers: frames_per_second gives the maximum arrival rate when the sender never pauses, which can be compared with a consumer task's service rate. Engineers validating hardware can compare the reported bit and frame times with logic-analyzer cursors to catch a wrong baud divisor or an unexpected parity setting. Test developers can store the deterministic response as a fixture for user-interface or configuration validation. The calculation intentionally stops at one frame and does not assume a message length, inter-frame gap, electrical standard, or flow-control scheme. RS-232, RS-485, and TTL UART may use different voltages and network arrangements, but their configured asynchronous frame duration follows the same bit-count equation when the signaling rate is the stated baud rate.
What you can do with it
Set a serial receive timeout
Estimate the minimum wire time for each character before adding message length, processing delay, and a safety margin.
Check logic-analyzer captures
Compare measured bit and frame widths with the expected values for a selected UART configuration.
Estimate maximum serial throughput
Use ideal frames per second to assess buffer pressure and quantify framing overhead.
FAQ
What does the UART frame time calculator cost?
It runs free in the browser. A successful API calculation costs $0.002.
Does a UART frame always have a start bit?
Yes. This model includes one start bit in every asynchronous UART frame.
How does parity affect frame time?
Even, odd, mark, and space parity each add one bit period. None adds zero parity bits.
Why is 8N1 ten bits rather than eight?
Its eight data bits are accompanied by one start bit and one stop bit, producing ten bit periods in total.
Is frames per second the same as application throughput?
No. It is the ideal back-to-back frame rate and excludes gaps, flow control, processing, transport bridges, and protocol overhead.
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/elec/uart-frame-time \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"baud_rate":115200}'const res = await fetch("https://api.kit.forhosting.com/elec/uart-frame-time", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"baud_rate": 115200
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/elec/uart-frame-time",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"baud_rate": 115200
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/elec/uart-frame-time", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"baud_rate":115200}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"baud_rate":115200}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/elec/uart-frame-time", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"baud_rate": 115200
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "elec.uart_frame_time",
"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.
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. |