· reAPI Team
Suno MIDI Import and Export: Requirements and API Guide
Suno MIDI import and export guide: V6_WILD file requirements, 6-second minimum duration, stem-to-MIDI JSON API workflow, and current per-request rates.

Suno MIDI now works in both directions, and the technical rules differ on each side. On November 4, 2026, Suno added MIDI file upload directly to its Create page, letting Pro and Premier subscribers start a V6 song from a .mid or .midi file instead of relying on text prompts alone[1]. Going the other way, turning an AI-generated track back into editable notes still requires stem separation first, whether you click Get MIDI inside Suno Studio[2] or chain two endpoints through the Suno MIDI API[4].
Most articles treat Suno MIDI as a single export button or stop at general DAW mixing advice. If you build audio tools or bounce sketches between a DAW and Suno, the actual friction sits in the constraints: which model version runs Suno MIDI import, why a syntactically valid .mid file gets rejected before rendering, how API extraction returns note JSON instead of a binary .mid download, and what each step costs. Everything below pairs Suno's current documentation with our own live API test runs on November 19, 2026.
Two Suno MIDI workflows and when each fits
Before writing integration code or paying for a monthly Studio plan, separate the two directions. Suno MIDI import turns a silent note sequence into a full arrangement, acting as a fast alternative to loading gigabytes of sample libraries for an early demo. Suno MIDI export goes the opposite direction, recovering pitch, timing, and velocity data from separated stems so you can swap synths, check chord voicings, or rebuild parts in Logic, Ableton, FL Studio, or MuseScore.
| Workflow detail | Suno web app / Studio (UI) | reAPI HTTP API (/api/v1/audio/generations) |
|---|---|---|
| Start a song from MIDI | Drag .mid / .midi onto Create (Simple mode, v6-wild, Pro/Premier plans)[1] | model: "suno-music", custom_mode: false, version: "V6_WILD", midi_urls (1 public URL)[4] |
| Live piano roll & USB controllers | Native MIDI tracks in Studio with Web MIDI API (Chrome; no Safari Web MIDI)[3] | Not applicable (stateless REST task pipeline) |
| Extract MIDI from a song | Extract stems in Studio, then right-click a stem and click Get MIDI (10 Suno credits)[2] | Step 1: suno-vocal-separation (generated track or external audio_url). Step 2: suno-midi on the separation task_id[4] |
| Exported MIDI format | Standard .mid file download[2] | Structured JSON (instruments[].notes[] with pitch, start, end, velocity)[4] |
| Pricing model (checked Nov 19, 2026) | Subscription tiers (Pro / Premier) + Suno credit balance[1][2] | Flat pay-per-request on reAPI Suno: $0.06 music gen, $0.05 to $0.25 stem split, $0.001 MIDI extract[5] |
If you want to jam live with a USB keyboard, quantize notes in a browser piano roll, or comp takes against an audio timeline, Suno Studio is the right environment. Safari does not currently support Web MIDI, so Suno recommends Google Chrome for hardware controllers in Studio[3]. If you need batch processing, app integration, or pay-per-request billing without a recurring seat, the Suno MIDI API is much simpler to automate.
Suno MIDI requirements and importing .mid files via API
A Standard MIDI File carries no sound. As Suno notes in its November 4, 2026 announcement, a .mid or .midi file holds up to 16 channels of pitch and timing events, each with up to 120 controller lanes for parameters such as sustain, volume, and modulation[1]. Feeding that file into Suno gives the model exact note timing and harmonic motion, and your prompt controls how tightly the output follows your score: you can ask it to play your chords verbatim on a string quartet, or borrow a short motif and develop it into a new genre[1].
At launch, Suno MIDI import runs in Simple (inspiration) mode on V6_WILD[1]. On reAPI, that maps to model: "suno-music" with custom_mode: false, version: "V6_WILD", and midi_urls containing one public HTTP(S) URL[4]. Sending a different version alongside midi_urls switches execution to V6_WILD upstream[4]. Base64 and data: URIs are rejected platform-wide, so host the .mid file on public object storage (or upload through the playground's suno-midi uploader) before calling the generation endpoint[4].
Exact file and payload limits
Every Suno MIDI import request has to clear five Suno MIDI requirements before the model renders audio:
- Format: Standard
.midor.midibinary starting with theMThdheader[4]. - File size: 256 KB maximum[4].
- File count: 1 MIDI URL per request (
midi_urlsaccepts at most one entry), and total reference attachments (style,lyrics,image_urls,audio_urls,video_urls, andmidi_urls) cannot exceed 10[4]. - Mode: Inspiration mode (
custom_mode: false) only. You can combinemidi_urlswith a descriptiveprompt(up to 3,000 characters), or omitpromptwhen another non-custom input is present[4]. - Duration: At least 6 seconds of musical timeline, verified in our November 19, 2026 live runs[4].
Working Suno MIDI API request for song generation
curl -X POST https://reapi.ai/api/v1/audio/generations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "suno-music",
"custom_mode": false,
"instrumental": true,
"version": "V6_WILD",
"prompt": "Warm ambient electric piano and soft synth pad following the MIDI progression",
"midi_urls": ["https://your-storage.example.com/original-progression-12s.mid"]
}'The endpoint returns a task ID immediately. Poll GET /api/v1/tasks/{id} until status becomes "completed" or "failed"[4]. A completed Suno MIDI generation returns two audio variations in output.audio_urls[] and two index-aligned metadata entries in output.tracks[], each carrying a reusable id, url, title, and duration[4].
What actually failed during our live MIDI upload tests
Documentation alone rarely tells you why a valid .mid file gets bounced. When we tested Suno MIDI import end-to-end on November 19, 2026 against live paid generation tasks, two realistic failure cases showed up immediately:
- Short sketches under 6 seconds are rejected. Our first test uploaded a valid 58-byte Format 0 MIDI file holding four quarter notes at 120 BPM (2 seconds total). The task failed with
"Your MIDI file is too short for us to check. Minimum duration is 6 seconds", and the reserved credits were refunded (usage.credits: 0). Pad short riffs to at least 6 seconds before submitting. - Textbook scales can trip known-recording matching. Our second test extended the file to 10 seconds with a plain ascending and descending C-major scale. Even though the file was freshly synthesized MIDI bytes, the task failed with
"Our system matched this upload to a known recording"(again refunded at 0 credits). Producers on r/SunoAI have reported similar false positives on bare melodies and standard exercises. - Original polyphonic progressions pass cleanly. Swapping the scale for a 12-second, 461-byte original D-Lydian chord and melody progression at 100 BPM completed in 54.2 seconds and returned two playable MP3 variations (
HTTP 200on the reAPI CDN).
If you build an automated pipeline around Suno MIDI uploads, catch both failure modes early: inspect MIDI duration locally in your client before calling the API (block anything under 6 seconds), and warn users that bare scales or recognizable cover melodies may trigger fingerprint rejection.
Exporting Suno MIDI from songs and stems
Going from audio back to notes is always a two-stage job. Neither Suno Studio nor the Suno MIDI API transcribes a dense stereo master straight into MIDI in a single step.
Inside Suno Studio, you first split your clip through the Stems panel to isolate vocals, drums, bass, or other layers. Once individual Suno MIDI stems exist, click the target stem and choose Get MIDI from the context menu. Studio charges 10 Suno credits and outputs a Standard MIDI file ready to drag into a DAW[2].
Through the reAPI HTTP surface, the sequence mirrors Studio's design, with one useful advantage: you do not need to have generated the source track on Suno first.
Step 1: Separate stems with suno-vocal-separation
suno-vocal-separation supports two mutually exclusive source shapes[4]:
- Existing track generated on reAPI: pass
task_id(the completed reAPItask_...ID) andaudio_id(one entry'sidfromoutput.tracks[]). - Your own uploaded audio: pass
audio_urlalone (public HTTP(S) URL, up to 20 MB; noaudio_idrequired). Legacy callers that still passaudio_idalongsideaudio_urlremain accepted for backward compatibility[4].
Pick the separation type deliberately because it changes both cost and downstream Suno MIDI export accuracy:
separate_vocal(default,$0.05/ 50 credits): splits into 2 stems (VocalsandInstrumental)[4][5].split_stem_advanced($0.10/ 100 credits): isolates one specific instrument viastem_name(98 supported instruments such asPiano,Bass,Electric Guitar,Drum Kit, orLead Vocal)[4][5].split_stem($0.25/ 250 credits): splits into up to 12 stems at once[4][5].
curl -X POST https://reapi.ai/api/v1/audio/generations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "suno-vocal-separation",
"audio_url": "https://your-storage.example.com/mix.mp3",
"type": "separate_vocal"
}'When GET /api/v1/tasks/{sep_task_id} completes, output.tracks[] returns each separated stem with its label (such as Vocals or Instrumental) and its own track id[4].
Step 2: Transcribe separated stems with suno-midi
Next, submit model: "suno-midi" with task_id set to the vocal-separation task ID rather than the original suno-music task ID[4]. Passing a plain music-generation task ID is rejected. Include audio_id from the separation task's output.tracks[].id to transcribe one stem, or omit audio_id to transcribe all separated stems[4].
curl -X POST https://reapi.ai/api/v1/audio/generations \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "suno-midi",
"task_id": "task_YOUR_SEPARATION_TASK_ID",
"audio_id": "STEM_TRACK_ID_FROM_SEPARATION"
}'Unlike Studio's .mid download, the Suno MIDI API returns structured note data inside output.result.midi[4]:
{
"output": {
"result": {
"midi": {
"state": "completed",
"instruments": [
{
"name": "Electric Bass (finger)",
"notes": [
{ "pitch": 45, "start": 1.24, "end": 1.72, "velocity": 0.78 }
]
}
]
}
}
}
}Each note entry carries standard MIDI pitch (0–127), start and end times in seconds, and normalized velocity (0–1)[4]. If your downstream tool expects a binary .mid file rather than JSON, converting output.result.midi in Node.js with @tonejs/midi takes a few lines:
import { writeFileSync } from 'node:fs';
import { Midi } from '@tonejs/midi';
function saveSunoMidiJson(midiResult, outPath) {
const midi = new Midi();
for (const inst of midiResult.instruments ?? []) {
const track = midi.addTrack();
track.name = inst.name;
for (const n of inst.notes ?? []) {
track.addNote({
midi: n.pitch,
time: n.start,
duration: Math.max(0.02, n.end - n.start),
velocity: n.velocity,
});
}
}
writeFileSync(outPath, Buffer.from(midi.toArray()));
}Realistic expectations for Suno MIDI export quality
Producers on r/SunoAI who tried importing Suno MIDI export straight into notation tools like MuseScore often report stray ghost notes, jittery rhythms, or polyphonic bleed. That criticism is grounded in two technical realities:
- Audio-to-MIDI transcription inherits stem bleed. Any reverb tail or overlapping chord layer left inside a stem turns into extra short notes during pitch detection. Running
split_stem_advancedon one clear instrument (likePianoorBass) or usingseparate_vocalbefore callingsuno-midiusually yields cleaner note arrays than transcribing a dense full mix. - 12-stem
split_stemcan return empty note data. As documented in the reAPI Suno reference, separations created withtype: "split_stem"can yield no detected notes at all on sparse or noisy stems[4]. If no note data survives transcription, reAPI reports thesuno-miditask as failed and refunds the credit instead of returning an empty result[4].
Treat extracted Suno MIDI as an editable harmonic and rhythmic sketch in your DAW, not print-ready sheet music. Quantize (Shift+Q in Studio or your DAW grid), strip sub-50 ms low-velocity artifacts, and assign your own virtual instruments.
Pricing and character limits across the pipeline
reAPI bills Suno requests at flat per-operation rates that do not scale with audio duration or model version (V6, V6_MINI, and V6_WILD cost the same). Failed and rejected tasks are refunded automatically. Rates below were verified on /models/suno on November 19, 2026; check the live Suno model page or Suno V6 page for current pricing[5].
| Step in Suno MIDI pipeline | reAPI model + option | Rate (USD, checked Nov 19, 2026)[5] | Credits (1 credit = $0.001)[5] |
|---|---|---|---|
| Generate song from MIDI (2 tracks) | suno-music (V6_WILD + midi_urls) | $0.06[5] | 60 |
| Split vocals + instrumental | suno-vocal-separation (separate_vocal) | $0.05[5] | 50 |
| Isolate 1 of 98 instruments | suno-vocal-separation (split_stem_advanced) | $0.10[5] | 100 |
| Split up to 12 stems | suno-vocal-separation (split_stem) | $0.25[5] | 250 |
| Extract MIDI note JSON from stems | suno-midi | $0.001[5] | 1 |
Using the November 19, 2026 rates above, a complete Suno MIDI round-trip (generate a track from MIDI at $0.06, split vocals and instrumental at $0.05, and transcribe MIDI JSON at $0.001) totals $0.111 (111 credits)[5]. If you bring your own audio file and only extract isolated piano notes via split_stem_advanced ($0.10) plus suno-midi ($0.001), the two-call workflow totals $0.101 (101 credits)[5].
Because developers also run into text validation errors when combining prompts with Suno MIDI requests, here are the exact V6 character limits on suno-music[4]:
prompt: up to 3,000 characters in inspiration mode (custom_mode: false, whichmidi_urlsrequires), or up to 5,000 characters in custom mode (custom_mode: true) on V6 models.lyrics: up to 5,000 characters (takes priority overpromptas sung words).style: up to 1,000 characters on V6 models (200 on legacy V4).title: up to 80 characters onsuno-music(100 on V6 extend and mashup operations).
Frequently asked questions
How do you export MIDI from Suno?
In Suno Studio, split your clip into stems from the Stems panel first, then select a stem and choose Get MIDI (10 Suno credits) to download a Standard MIDI file[2]. Through the Suno MIDI API on reAPI, run suno-vocal-separation first and pass that completed separation task's task_id into suno-midi to get structured instrument and note JSON[4].
Can I upload multiple MIDI files in the same prompt?
No. Under current Suno MIDI requirements on suno-music, midi_urls accepts a maximum of one .mid or .midi URL per request[4]. If your arrangement splits piano, bass, and drums across separate DAW tracks, export them into a single multi-channel Standard MIDI File (up to 16 channels, under 256 KB) before uploading[1][4].
Why did Suno reject my valid .mid file?
Two common reasons appeared in our November 19, 2026 live tests: the MIDI timeline was shorter than 6 seconds ("Minimum duration is 6 seconds"), or a bare scale triggered known-recording matching ("Our system matched this upload to a known recording"). Also verify the file starts with the standard MThd binary header, stays at or below 256 KB, and is served from a public HTTP(S) URL rather than a data: URI[4].
Does Suno offer official API access for MIDI?
Suno does not publish a general public REST API for developers. Its native Suno MIDI features live inside the Suno web app and Studio for Pro and Premier subscribers[1][3]. Developers building automated pipelines use unified API gateways such as reAPI's Suno API, which exposes midi_urls, suno-vocal-separation, and suno-midi behind one Bearer token and async polling contract[4].
How many characters does Suno allow in prompts when using MIDI?
When passing midi_urls on suno-music, the request runs in inspiration mode (custom_mode: false), where prompt allows up to 3,000 characters[4]. In custom mode without MIDI attachments, prompt and lyrics allow up to 5,000 characters on V6 models, style up to 1,000, and title up to 80[4].
Can I use Suno MIDI in a real DAW music production workflow?
Yes, as long as you treat each direction according to its strengths. Starting a song from your own DAW MIDI file gives tighter harmonic and structural control than text prompting alone[1]. Extracting MIDI out of Suno audio works well for capturing chord voicings, basslines, or melodies to re-trigger with DAW plugins, provided you separate stems cleanly first and budget a few minutes for quantization and ghost-note cleanup.
Deciding between Studio and the API for Suno MIDI work
Pick Suno Studio if you are a solo producer jamming with a USB keyboard in Chrome, editing notes on a browser timeline, and exporting occasional WAV stems or .mid files by hand[2][3]. Pick the reAPI HTTP workflow when you want to run midi_urls on V6_WILD without a monthly subscription, process uploaded audio through suno-vocal-separation and suno-midi programmatically, or consume note arrays directly in JSON. Either way, reliable Suno MIDI results come down to two habits: export original multi-channel .mid files at least 6 seconds long on the way in, and isolate stems carefully before transcribing on the way out.
Read the complete parameter schema in the reAPI Suno API documentation or test calls directly in the browser on the Suno model page.
References
- Suno. Start Songs with MIDI. Published November 4, 2026. Retrieved November 2026 from suno.com/blog/MIDI-in-create
- Suno Help Center. Exporting from Studio. Retrieved November 2026 from help.suno.com/en/articles/8128193
- Suno Help Center. MIDI in Studio. Retrieved November 2026 from help.suno.com/en/articles/13670593
- reAPI. Suno API Documentation. Retrieved November 2026 from reapi.ai/docs/suno
- reAPI. Suno Model Page & Live Pricing. Retrieved November 2026 from reapi.ai/models/suno