MIDI ticks per note value calculator
At 480 PPQ a quarter note spans exactly 480 MIDI ticks: pick the resolution and a note value, straight, dotted or triplet, and get its tick length plus a table of every common duration. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Ppq
- 480
- Note value
- Quarter
- Note beats
- 1 ticks
- Ticks
- 480
- Ticks integer
- 480
MIDI sequencers store time as integer ticks at a fixed pulses-per-quarter-note (PPQ or PPQN) resolution, not as wall-clock milliseconds. When you place a quarter note, an eighth, a dotted quarter, or a triplet on a piano roll, the editor multiplies that note’s beat length by the sequence PPQ so every event lands on a grid the player and the file format agree on. This MIDI ticks per note value calculator accepts a positive PPQ and a named note value, returns the exact tick span for that value, a nearest-integer tick count for sequencers that store whole ticks only, and a full reference table of common durations at the same resolution. Use it when building MIDI files by hand, writing quantization tools, checking DAW export settings, or teaching how musical note values map onto the MIDI time base.
How PPQ and note values become MIDI ticks
Classic General MIDI files often use 96 or 192; many modern DAWs default to 480 or 960 so triplets and thirty-seconds land on clean integers. Once PPQ is fixed, every note value is just a multiple of that quarter-note unit. A whole note is four quarter beats, so its tick length is four times PPQ.
A half note is two times PPQ, a quarter equals PPQ, an eighth is half of PPQ, a sixteenth is one quarter of PPQ, and a thirty-second is one eighth of PPQ. Dotted values add half of the undotted length: a dotted quarter is one and a half quarter beats, or one and a half times PPQ.
Triplet groups split two beats of the parent into three equal parts; a quarter-note triplet is two-thirds of a quarter (two-thirds of PPQ), an eighth triplet is one-third of PPQ, and a sixteenth triplet is one-sixth of PPQ.
What you can do with it
MIDI file and piano-roll tooling
Convert notation note values into tick spans at the project PPQ before writing SMF delta-times or placing events on a custom piano roll.
Quantization and resolution changes
Rebuild grid tables when switching from 480 to 960 PPQ so eighths, dotted quarters, and triplets stay musically correct.
Teaching MIDI time bases
Show students that ticks = PPQ × note beats, independent of BPM, with live tables for straight, dotted, and triplet values.
FAQ
What is PPQ or PPQN?
A quarter note always lasts exactly that many ticks; other values scale from it. Common settings are 96, 480, and 960.
Do dotted and triplet notes work?
Yes. Dotted values use 1.5× the undotted length. Triplet quarter, eighth, and sixteenth use 2/3, 1/3, and 1/6 of a quarter note in beats.
How many ticks is a quarter note at 480 PPQ?
Exactly 480 ticks, because PPQ counts the pulses inside one quarter note. Every other value is a multiple of it: a whole note is four times PPQ and an eighth is half of it.
Does the tempo change the number of MIDI ticks?
No. The tick count depends only on the resolution and the note value, not on BPM. Tempo decides how long each tick lasts in time, while an eighth or a triplet keeps the same number of ticks.
Which PPQ resolution works best for triplets?
A high resolution such as 480 or 960 lets triplets and thirty-second notes land on whole ticks. Older General MIDI files often use 96 or 192, and the result tells you whether a value needs rounding.
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/hobby/music-ticks-per-note \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"ppq":480,"note_value":"quarter"}'const res = await fetch("https://api.kit.forhosting.com/hobby/music-ticks-per-note", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"ppq": 480,
"note_value": "quarter"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/hobby/music-ticks-per-note",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"ppq": 480,
"note_value": "quarter"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/hobby/music-ticks-per-note", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"ppq":480,"note_value":"quarter"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"ppq":480,"note_value":"quarter"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/hobby/music-ticks-per-note", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"ppq": 480,
"note_value": "quarter"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "hobby.music_ticks_per_note",
"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. |
Technical notes
How PPQ and note values become MIDI ticks
A MIDI sequence declares a time division in pulses per quarter note: how many ticks fit inside one quarter-note beat.
Input contract, response fields, and validation
Common legal values include 96, 192, 240, 480, and 960; any positive finite number within absolute limits is accepted so experimental resolutions work too. Formula and message strings summarize the rule for display; steps list the arithmetic in order for debugging UIs. POST a JSON body with two required fields. The field ppq is the sequence resolution: a finite positive number of pulses per quarter note. Aliases such as ppqn, ticks_per_quarter, resolution, pulses_per_quarter, and tpqn are accepted and map to the same value. The field note_value is a closed enum of musical names: whole, half, quarter, eighth, sixteenth, thirty_second, dotted_half, dotted_quarter, dotted_eighth, dotted_sixteenth, triplet_quarter, triplet_eighth, and triplet_sixteenth. Aliases such as 1/4, quaver, and 1/8_triplet normalize to the same keys. Missing, non-positive, or non-finite ppq fails with invalid_input and is not billed. An unknown note_value fails the same way. On success the body echoes ppq and the canonical note_value, reports note_beats relative to a quarter, ticks as the precise product, ticks_integer as Math.round of that product, is_exact_integer when the product is within a tiny epsilon of a whole number, and note_ticks as a full dictionary of every supported value at that PPQ. Example: ppq 480 and note_value quarter yields 480 ticks; the same PPQ with eighth yields 240; dotted_quarter yields 720; triplet_eighth yields 160 exactly.
Where a ticks-per-note calculator earns its keep
MIDI tool authors need a single source of truth when converting score notation into delta-times before writing track chunks. DAW power users who change project resolution must re-quantize existing regions; knowing that an eighth at 480 PPQ is 240 ticks and at 960 PPQ is 480 ticks prevents off-by-factor edits that slide every note. Failed validation does not consume balance. Educators teaching digital audio explain that tempo changes wall-clock duration while PPQ only changes the tick grid, and this endpoint makes that distinction concrete without opening a full sequencer. Game and interactive-music engines that schedule MIDI-like events on a fixed pulse clock can call the API once per note value and cache the table.
Technical questions
How do I convert a note value to MIDI ticks?
Send positive ppq (pulses per quarter note) and a note_value such as quarter, eighth, or triplet_eighth. The API returns ticks = ppq × note_beats, where one beat is one quarter note.
Why is there both ticks and ticks_integer?
ticks is the precise product (stable to twelve decimals). ticks_integer is the nearest whole tick for sequencers and SMF delta-times that store integers only. is_exact_integer is true when no rounding was needed.
What does the MIDI ticks calculator cost?
The browser tool is free. API requests use prepaid KIT balance at $0.002 per successful call; invalid input is not billed.