MIDI to audio API
Published November 2026
Send notes or a MIDI file over HTTP and get them played on 100+ AI instruments, each part its own WAV.
A free account has 120 credits a month. The catalog, a quote and the OpenAPI document need no key.
One part
Make a key at Settings → API keys and send it as X-API-Key (or Authorization: Bearer):
export DOO_API_KEY=dsk_live_...
render_midi plays one part. The notes are beats from bar 1 (beat 0 is the first beat), at concert pitch:
curl -s -X POST https://api.doseedo.com/api/jobs \
-H "X-API-Key: $DOO_API_KEY" \
-H 'Content-Type: application/json' \
-H 'Idempotency-Key: cello-phrase-v1' \
-d '{
"kind": "render_midi",
"input": {
"instrument": "cello",
"bpm": 72,
"notes": [
{ "pitch": 48, "start_beats": 0, "duration_beats": 2 },
{ "pitch": 55, "start_beats": 2, "duration_beats": 2 },
{ "pitch": 52, "start_beats": 4, "duration_beats": 4 }
]
}
}'
curl -s "https://api.doseedo.com/api/jobs/$JOB_ID?wait=50" -H "X-API-Key: $DOO_API_KEY"
Run on November 16, 2026: three takes of the phrase came back 15 seconds after the submit, ranked best first in output.takes, for 10 credits. Result links are pre-signed: download them with a plain GET and no header. They last 24 hours, and a result link is accepted as the audio_url of a later job.
The complete loop, submit to file on disk, in Python and JavaScript, is on the API's front page.
A whole score
render_score plays every part of a piece in one call. Each part is rendered on its own and comes back as its own file, with a mix of them all:
curl -s -X POST https://api.doseedo.com/api/jobs \
-H "X-API-Key: $DOO_API_KEY" \
-H 'Content-Type: application/json' \
-H 'Idempotency-Key: duo-v1' \
-d '{
"kind": "render_score",
"input": {
"bpm": 90,
"parts": [
{
"name": "Cello",
"instrument": "cello",
"notes": [
{ "pitch": 48, "start_beats": 0, "duration_beats": 4 },
{ "pitch": 43, "start_beats": 4, "duration_beats": 4 }
]
},
{
"name": "Violin",
"instrument": "violin",
"notes": [
{ "pitch": 67, "start_beats": 0, "duration_beats": 2 },
{ "pitch": 69, "start_beats": 2, "duration_beats": 2 },
{ "pitch": 71, "start_beats": 4, "duration_beats": 4 }
]
}
]
}
}'
Run on November 16, 2026: both parts passed the check against their notes, and the two stems and a mix came back 47 seconds after the submit, for 10 credits. Each entry of output.parts carries its url and a fit: how many of its written notes were heard, and how close to their beats.
Mix them properly with one more job, by the render's id: {"kind": "mix", "input": {"from_job": "job_…"}} returns a mastered mix_url and what was done to each part. It costs no credits.
What goes in
- Notes as JSON:
pitch(MIDI 0 to 127),start_beats,duration_beats,velocity(1 to 127, default 96), and alyricon a sung note. Up to 4,096 notes a part. - A file: a Standard MIDI File (
midi_url, up to 2 MiB) or a MusicXML score (musicxml_url, up to 8 MiB) from Dorico, Sibelius, Finale or MuseScore. A file on your machine goes up first: see the upload on the stem separation page; a score file's key is passed asscore_key. - The instrument, by id, for each part: strings, winds, brass, guitars, keys, drums, voices and a choir. A sung part takes its words.
- The tempo:
bpm, or atempo_mapwhen it changes, and atime_signature. - Up to 600 seconds a render, and for a score up to 32 written lines.
What your code controls
- Takes.
takes: one to four performances of a part in one call, at no extra credits, ranked best first. - The sound.
timbre_presetpicks a preset of the instrument;timbre_audio_urlcopies the tone of a recording you supply. - Your own instrument. The
train_instrumentjob trains one from a recording, and its id plays any notes afterwards. - One region.
revise_take_urlwithrevise_start_beatsandrevise_end_beatsre-renders that span of a take you already have and splices it back. - Sections.
playerson a part of a score makes it a section of two to eight players, each its own render.
What it costs
10 credits for each 30 seconds of one part; in a score, 10 credits for each 30 seconds of each group of up to six parts. POST /api/jobs/quote prices the exact call first.
One credit pool pays for every job. A free account has 120 credits a month; Pro is $12 a month with 2,000, plus one-time extra usage (500 credits for $5). The quote endpoint prices a call before you make it, a refused call spends nothing, and a failed job is refunded.
On a free account a render of several parts comes back as its mix: each part as its own stem comes with Pro. A one-part render, a separation and every analysis job are the same on every plan.
Limits
- A performance, not a playback. The models are trained on real recordings and a take can miss or change a note. Takes come back ranked, a score's parts come back checked against their notes, and the
check_takejob measures any take against any notes. - Asynchronous. Usually 45 s to 3 min for a part, by the catalog; a short phrase is faster.
- Sung words are clearest in English.
A MIDI to audio API
MIDI to audio API, MIDI rendering API, MIDI to WAV API and an API that plays MIDI on realistic instruments name the same job: notes go in, and a performance of exactly those notes comes out.
Send your first notes
Make a key, post three notes, and download the take. A free account has 120 credits a month.
Get an API key →FAQ
Is there an API that turns MIDI into realistic audio?
Yes. Doseedo's render_midi job takes notes or a MIDI file and an instrument, and returns that part played by an AI instrument model as a WAV, with several takes ranked best first. There are 100+ instruments.
Does it play exactly the notes I send?
The notes are sent to the model as given: nothing is corrected or re-voiced on the way. The performance is generated, so a take can miss or change a note; that is why takes are ranked and a score's parts come back with a check against their notes.
Can it render a full MIDI file with many tracks?
Yes. render_score takes a multi-track Standard MIDI File or a MusicXML score, renders every part on its own, and returns each as its own stem with a mix.
How is this different from a SoundFont or a sample library?
A sample library plays back recordings of single notes. Here a model trained on real recordings performs the phrase, so the notes connect the way a player connects them. It also means the result is a performance to check, not a deterministic playback.
What audio format comes back?
WAV, 48 kHz stereo. Add ?format=opus to a result link for a compressed copy.
The music API · music your code controls
- MIDI to audio APIyour notes, played
- Video soundtrack APIspot, render, lay on the picture
- Stem separation APIa mix in, stems and MIDI out
- Game music generatorseamless loops, in layers
- The MCP serverthe same jobs for an AI agent
- Every toolthe reference
- Planscredits a month