The short answer

A pitch can usually be played on two to six strings, so TAB has to choose one. Most notation software, MuseScore included, takes the highest string that can play each note, which is its lowest fret, and moves a chord note whose string is taken to the next free string. That gives low, readable fingerings but can make a melody climb one string instead of staying in a hand position. When TAB from a file comes out an octave too high, the file wrote the guitar an octave above its sound and the app fretted the written pitch.

Why one note has several places on the neck

Because the strings overlap. In standard tuning the open strings are E2, A2, D3, G3, B3 and E4, five half steps apart except G to B, which is four, so the 5th fret of one string (the 4th on the G string) plays the next string’s open note. The E above middle C, E4, is the open top string, the 5th fret of the B string, the 9th of G, the 14th of D, the 19th of A and the 24th of the low E: six places on a 24-fret neck, five on a 22-fret electric or a 19-fret classical guitar.

A staff only gives the pitch. TAB gives the string and fret, so whoever writes it, a person or a program, picks one of those places for every note, and the choice decides where the hand goes.

What rule does notation software use?

MuseScore’s is in its source code, in StringData. A note goes to the highest string whose open pitch is at or below it (“using the highest possible string”, says the comment above convertPitch). For a chord, the notes are taken from the highest down; when a note’s string is already used, the app looks for “a suitable string, from topmost”: the first free string from the top that can play the note within the neck’s frets. If none can, both notes stay on one string and the TAB marks the clash.

We wrote the same rule for ScoreStarling and compared the two. A script wrote 120 random chords of one to four different notes between E2 and C6 on a standard-tuned TAB staff with no frets in it, let the MuseScore 4.7.5 command line fill them in, and compared every note. We ran it four times with different random chords.

The rule is predictable, which is why it’s a good default: anyone reading the TAB can work out where a note will be. A Guitar Pro or MuseScore user who opens the score sees the same frets.

When does the lowest-fret rule read badly?

When a line sits high on the neck. The rule never looks at the note before or after, so every note that the top string can play goes there, and a phrase a player would keep in one place runs up and down that one string. Here is a phrase coming down from the E at the 12th fret, as ScoreStarling writes it under each rule.

The first column covers frets 3 to 12 on one string, so the hand moves again and again on the way down. The second plays the last two notes on the B string at the 10th and 8th frets and stays between the 7th and the 12th. Neither is wrong, and the lowest-fret version is what most notation apps would show; the second is closer to what a teacher would write.

A program can find the second kind by planning the whole part. ScoreStarling’s “fewest hand shifts” option treats each note or chord as a step, lists the ways it can be fretted, and searches for the cheapest path through all of them: the hand covers four frets, a move costs more the farther it goes, a chord wider than four frets costs extra, higher positions and frets above the 12th cost a little, and open strings are free. It still doesn’t know your technique, so a planned fingering is a suggestion to check.

Why is my TAB an octave too high?

Because a guitar sounds an octave below its written notes, and a file can say that in two ways. MusicXML can write the part at the pitch it sounds, under a treble clef with a small 8 below it, or write it an octave up with a transpose element, which “represents what must be added to a written pitch to get a correct sounding pitch”. Both print the same staff. An app that fills in TAB from the written pitch of the second kind puts every note an octave too high.

We saw it in MuseScore 4.7.5. A file held an open-position C major scale, C3 to C4 as it sounds (from the A string’s 3rd fret to the B string’s 1st), written the second way with its strings and frets in it. MuseScore replaced every fret and wrote the scale from the B string’s 1st fret to the top string’s 8th, the same scale an octave up. Written at the pitch it sounds under the 8 clef, the same scale opened with every string and fret as written. ScoreStarling’s MusicXML downloads write TAB parts that way.

If a TAB you were given sits an octave high, check the clef and any transposition of the part in the source file before you change notes.

What does a capo change in a file?

The open notes. MusicXML’s capo element “changes the open tuning of the strings” by its number of half steps, and fret numbers start at 0 for an open string, so with a capo at the 2nd fret, fret 0 is the string played at the capo and fret 3 is the 5th fret from the nut. That matches what players read on a capo chart. MuseScore 4.7.5 ignored the capo when it opened our MusicXML and wrote frets from the nut, so print the capo position in the score’s text as well.

How ScoreStarling writes TAB

From October 8, 2026, ScoreStarling shows a guitar, bass or ukulele part with TAB under the staff or as TAB alone, from a recording or a video link, a PDF of sheet music or a MusicXML, MIDI or ABC file. The default strings follow the lowest-fret rule above; “fewest hand shifts” plans one hand position; you can move any note to another string at the same pitch or type a fret. Tunings include drop D, DADGAD and open G, with a capo up to the 12th fret. Notes no string can play as written are marked. It doesn’t write bends, slides, hammer-ons or strumming, and the tuning stays the same for the whole piece. Try it on audio to guitar tab, YouTube to guitar tab or sheet music to guitar tab.

Questions and answers

Why does my notation app put a note on a string I wouldn’t use?

Because a staff doesn’t say which string to use, so the app applies a rule. MuseScore takes the highest string that can play the note, which is its lowest fret, and gives a chord note whose string is taken to the next free one. Change the notes you play elsewhere; the pitch stays the same.

Why is my guitar TAB an octave too high?

The file probably writes the guitar an octave above its sound, with a transpose element, and the app fretted the written pitch. Writing the part at the pitch it sounds under a treble clef with an 8 below fixes it. In our test MuseScore 4.7.5 read an open-position C major scale written the first way as the same scale an octave up on the top two strings.

With a capo, does fret 0 mean the nut or the capo?

In MusicXML, the capo: the capo element raises the open tuning of the strings by its number of half steps, so fret 0 is the string played at the capo. MuseScore 4.7.5 ignored the capo when it opened our MusicXML and counted frets from the nut.

Can ScoreStarling make guitar TAB from a recording?

Yes, since October 8, 2026: it writes the recording on a staff with TAB under it, or TAB alone, for guitar, bass and ukulele, free for one instrument. It doesn’t write bends, slides or hammer-ons. See audio to guitar tab.

The short answer

Not at 320 kbit/s. On October 5, 2026 we transcribed the same recordings as lossless audio and after a round trip through MP3 and AAC, with three engines: Spotify’s Basic Pitch on 12 guitar recordings, a solo-piano model on 50 piano performances and Mirelo on a band song. MP3 at 320 kbit/s moved each engine’s onset F1 by at most 0.002 on a scale of 0 to 1, a handful of notes in a few thousand, and kept every file’s length to the sample. MP3 at 192 kbit/s and AAC at 256 kbit/s moved scores by up to 0.008, up as often as down, and the AAC files came back up to 733 samples longer.

Why would MP3 change the notes?

MP3 and AAC throw away detail the ear is unlikely to notice, mostly quiet sounds next to louder ones and high frequencies. Models such as Basic Pitch read a time-frequency picture of the audio, and nothing guarantees they ignore the same detail a listener does. A note near a model’s threshold can appear or vanish when the spectrum shifts a little.

Earlier work points to a small effect. Urbano and colleagues found MFCC features stable under lossy encoding from about 160 kbit/s, and chroma features, which follow pitch classes, hardly affected by codec or bitrate at all (ISMIR 2014). They measured features, not transcribed notes, so we measured the notes.

We had a practical reason too. Lossless copies of recordings and of their playback made up 77% of our score storage, and we wanted to keep smaller copies only if they cost nothing in accuracy.

How we tested

Every recording went through each codec with FFmpeg 8.1.1 (LAME at a constant 320 or 192 kbit/s, FFmpeg’s own AAC encoder at 256 kbit/s), then was decoded by the same code that reads an upload. A control changed the lossless audio by 0.01 dB, which nobody can hear, to show how much the measures move with no codec at all. All three engines are deterministic: the same input gives the same notes.

Onset F1 counts a transcribed note as right when its pitch is within 50 cents and its start within 50 ms of a reference note, and it punishes missed and extra notes alike; 1.0 is perfect. Our accuracy article explains the measure in full.

What changed for one instrument?

Almost nothing. Across the 12 guitar recordings Basic Pitch’s onset F1 stayed between 0.761 and 0.764 in every format, while the stereo file shrank to between 14% and 23% of the WAV.

The lossless score is 0.763, not the 0.744 in our October 3 article: since October 4, ScoreStarling writes one instrument as one line, which changed five of the solos. Both runs use Basic Pitch 0.4.0.

And for solo piano?

The piano model heard the same notes in every format. Its onset F1 against the notes played was 0.9427 lossless, 0.9426 for the control, 0.9428 for MP3 320 and 0.9433 for MP3 192, and it found about 92.2% of the written notes in every format.

The step that reads beats and bar lines from those notes was less steady, and not because of the codec. It placed the bar lines differently in 5 of the 50 performances after the inaudible control, and in 7 after MP3 320, four of them the same performances as the control. That step is sensitive to any change at all, so we treat it as noise in the measure rather than a cost of MP3. AAC was not run on piano.

And for a full band?

One paid comparison with Mirelo, on the 60-second band song: 842 notes and drum strokes came back for both the lossless file and the MP3, and 829 of them (98.5%) started within 50 ms of the lossless run’s.

Why did any notes change?

Because any change to the input moves a few notes that sit right at a model’s threshold. Of about 2,740 notes Basic Pitch found, the inaudible control moved one, MP3 320 moved 10, AAC 17 and MP3 192 14, never more than 7 in one recording. MP3 320 came out a hair lower in three of the five comparisons (by 0.0013 to 0.0020), level in one and a hair higher in one. AAC and MP3 192 went up on the guitar or the Slakh song and down on our synthesized band piece, by up to 0.008. A codec that cost real accuracy would show up as a clear drop everywhere, and none did.

What a codec can change for certain is timing at the edges. AAC encoders add silent priming samples at the start and pad the end to a whole frame; Apple documents a delay of 2112 samples. Our AAC files decoded 16 to 733 samples longer. FFmpeg writes MP3 with a Xing/LAME header that records the encoder delay, and our MP3 files decoded to the exact original length. That matters when a score is played in sync with its recording.

Which file should you upload?

• The file you already have. Converting a WAV to MP3 first gains nothing, and converting an MP3 back to WAV restores nothing.
• If you must compress, MP3 at 320 kbit/s matched the original most closely by signal-to-noise and kept the exact length.
• Low bitrates are unmeasured. We stopped at 192 kbit/s, so check what your recording app saves.
• Recording quality matters far more than the format: one clear part, little reverb, no background music. Our voice memo guide covers what to check.

ScoreStarling acts on this result: since October 5, 2026 a WAV, AIFF or FLAC upload is kept as a 320 kbit/s MP3 and transcribed from that copy, which stores a stereo recording at 23% of its WAV size. MP3, M4A, Ogg and video files are kept as they came.

What this test can’t tell you

• One band song for Mirelo, and synthesized piano rather than recorded pianos.
• No singing. Our real recorded takes are private and were already AAC files, so they could not serve as a lossless reference.
• One encoder per format and no bitrate below 192 kbit/s.
• Onset F1 says whether a note was heard, not whether the written score reads well.

Questions and answers

Should I upload WAV or MP3 for transcription?

Either. In our October 5, 2026 test an MP3 at 320 kbit/s scored within 0.002 onset F1 of the WAV it came from, with three different engines. Upload the file your recorder or editor gives you, and skip converting it. An MP3 at 192 kbit/s and an AAC file at 256 kbit/s stayed within 0.008; lower bitrates were not tested.

Does a lower MP3 bitrate change the notes?

A few, in both directions. At 192 kbit/s, 14 of about 2,740 matched notes changed across 14 recordings, against 10 at 320 kbit/s and 1 for an inaudible volume change. Onset F1 moved by up to 0.008 at 192 kbit/s and by at most 0.002 at 320 kbit/s. Bitrates below 192 kbit/s were not measured.

Why does an AAC file come out slightly longer than the WAV?

AAC encoders add silent priming samples at the start and pad the end to a whole frame; Apple documents a priming delay of 2112 samples. If the player or decoder does not trim them, the audio is a little longer. In our test AAC files decoded 16 to 733 samples longer. MP3 written by FFmpeg with its Xing/LAME header decoded to the exact length.

Does ScoreStarling convert my WAV to MP3?

Yes. Since October 5, 2026 a WAV, AIFF or FLAC upload is kept as a 320 kbit/s MP3, the setting measured here, and transcribed from that copy. MP3, M4A, Ogg and video uploads are kept as they came.

The short answer

On a phone, ChatGPT lays its title bar and message box over a fullscreen MCP App and reports them as safe-area insets, about 47 px and 127 px in our run, and moves the bottom one while the app is open. It also rebuilt our panel from the conversation’s original tool result whenever it entered or left fullscreen. Keep the inset clear without adding your own allowance, place script-positioned elements again on every context change, and check on load whether a result is out of date. We tested ChatGPT’s mobile website in an iPhone Simulator, not the native app.

What broke when we opened our MCP App in ChatGPT on a phone?

Four things, all involving fullscreen. ScoreStarling’s panel shows a score in the chat (how to connect it); in fullscreen you tap notes and ask the chat about them from a selection card that docks above the player on a phone. On October 7, 2026 we ran it in ChatGPT’s mobile website, in Safari on the iOS Simulator’s iPhone 17 (402 × 874 points). The panel’s frame is cross-origin, so we read it from screenshots.

Why does a fullscreen MCP App hide behind ChatGPT’s message box on a phone?

Because ChatGPT draws its message box over your frame and tells you how much it covers through the bottom safe-area inset. Ignore the inset and your controls sit under the box; add your own allowance on top, as we did, and they float. The MCP Apps specification describes safeAreaInsets only as “Safe area boundaries in pixels”, and OpenAI’s docs say the composer stays overlaid in fullscreen without giving its size (both checked October 7, 2026). Our 47 px and 127 px are estimates from screenshots.

On October 6 a conversation on a phone showed our player under ChatGPT’s title bar, so we moved the header below the top inset and the player to the bottom, where our CSS also kept 96 px for a message box on top of the bottom inset. A local test with a 34 px inset looked right; ChatGPT’s 127 + 96 did not. Now the panel keeps whichever is larger, and reads ChatGPT’s window.openai.safeArea too:

// panel.js, simplified: the host's inset or 96 px, never both
const bottom = Math.max(context.safeAreaInsets?.bottom || 0, window.openai?.safeArea?.insets?.bottom || 0);
root.style.setProperty('--safe-bottom', `${bottom}px`);
root.style.setProperty('--composer-space', fullscreen ? `${Math.max(0, 96 - bottom)}px` : '0px');
/* panel.css */
.stage > .player { bottom: calc(10px + var(--safe-bottom) + var(--composer-space)); }

What changes while a fullscreen MCP App is open on a phone?

The insets. In our run the bottom edge moved when a draft grew to two lines and when the Thinking bar replaced the message box. The specification lets a host send ui/notifications/host-context-changed whenever a context field changes, with only the changed fields, for the view to merge.

Our player sits on a CSS variable and followed. The selection card is placed by script and stayed behind, so now every context change places it again. Our own notice caused a second drift: “Updated from the chat” shows above the score for 20 seconds and pushes the score area down. The card, measured from that area’s top, slid over the player, and if anything placed it again meanwhile, it floated above the player once the notice went. A ResizeObserver on the area now places the card too, once per animation frame:

this.context = {...this.context, ...params};  // host.js, simplified: merge the partial update
function hostContext(next) { applyContext(next); editor.queuePlace(); }
new ResizeObserver(() => { updateClip(); editor.queuePlace(); }).observe($('stage'));

Why does an MCP App show an old version after leaving fullscreen?

Because ChatGPT on the phone built a new panel each time it entered or left fullscreen, and gave it the conversation’s original tool result, made before any edits. The specification lets a host tear a view down at any point; a tool result only records the moment its tool ran.

Ours was half snapshot, half live: page images and notes for its own revision, plus a current-revision field read when the panel fetches it. The rebuilt panel drew revision 0, saw that the score was at revision 3 and went read-only. Its check for chat edits compared the server’s revision with that already-current field, so it never caught up. Now a panel that the host hands a result the score has moved past reads the current revision once, unless the result holds a suggested change awaiting approval, which is meant to differ.

How do you test ChatGPT’s phone behavior without a phone?

Imitate the real host in a replica, and prove each test fails without its fix. We use sunpeak, which replicates ChatGPT and Claude for Playwright tests. Its mobile ChatGPT shell (version 0.20.91) draws a title bar and message box and reports the box as a 92 px inset. The three tests we wrote for these bugs, on a 402 × 874 touch screen, add the rest. Through the shell’s sandbox frame, which is the panel’s parent as ChatGPT’s frame is, they send new insets of 127, 160, 70 and 127 px, and after an edit they reload the panel and hand it the original tool result. Another test edits the score outside the panel, as the chat does. The player must end 0–24 px above the larger of the inset and 96 px, the card 0–16 px above the player.

A run of those three took 59.9 seconds. A fourth, added the same day, checks the phone editor’s one-row header and player, and our contributor rules now require the phone tests after any change to the fullscreen layout, insets, card or result handling. The phone run also caught ChatGPT turning a selected B4 into C4, a seventh down, for “Change this note to C”; a nearest-octave rule in the tool’s description took a local test with a real model from 2 of 3 passing runs to 6 of 6.

What we haven’t verified

Our phone checks ran in the iOS Simulator and ChatGPT’s mobile website: no physical phone, no native app. Still open:

• the exact insets ChatGPT sends, and when; ours are estimates the replicas reuse;
• Safari’s expanded toolbar, which half hides the message box and the player’s lower edge;
• a page scroll of about 156 points Safari left after the keyboard closed, which a cross-origin panel can’t undo;
• an opaque band up to about 777 points when fullscreen opened while ChatGPT was still answering;
• ChatGPT’s reply sheet and its own iframe teardown, which the replicas don’t imitate;
• ChatGPT on a computer, where fullscreen is a side panel with the message box outside it; we didn’t read its insets.

A checklist for MCP Apps on phones

• Keep both insets clear; if you also keep a fallback for a message box, use the larger, never the sum.
• Merge each host-context-changed notification, and place again anything positioned by script, once per frame.
• Observe your own containers for notices that move them.
• Expect a rebuild from an old tool result; compare its version with the server’s on load.
• Give your local test host the insets measured on the real one.
• Treat the UI resource URI as a cache key, as OpenAI’s docs advise, and after publishing a new one refresh the app’s tools in ChatGPT (plugin settings, Manage app, Refresh tools; checked October 7, 2026).
• Turn each real-host finding into a replica test that fails without its fix.

Questions and answers

Does ChatGPT count its message box in safeAreaInsets on a phone?

In our run, yes. On ChatGPT’s mobile website (iPhone 17 Simulator, October 7, 2026) the bottom inset was about 127 px and covered the message box, and the top inset, about 47 px, covered the title bar. The MCP Apps specification doesn’t say what an inset contains, so keep the reported space clear and don’t add an allowance of your own on top of it.

Does ChatGPT change the insets while a fullscreen app is open?

Yes, in our run: a two-line draft and ChatGPT’s Thinking bar both moved the bottom edge. Apply new insets whenever ui/notifications/host-context-changed arrives, merging the fields it carries into what you have, and place again anything you position with script.

Why does my MCP App show old data after switching to fullscreen on a phone?

ChatGPT on the phone built a new panel from the conversation’s original tool result each time it entered or left fullscreen, so ours showed the score as it was before later edits. When the view loads, compare the result’s version with the server’s and read the current state once if the result is behind.

Can I test ChatGPT’s phone layout without a phone?

Partly. We replay what the phone showed in sunpeak’s mobile ChatGPT shell with Playwright: moving insets, a rebuilt panel and an edit from the chat, and each test fails with its fix undone. The values ChatGPT really sends, Safari’s toolbar, the keyboard, ChatGPT’s reply sheet and the native app still need a real phone.

The short answer

On October 7, 2026 we split ScoreStarling’s one Railway service in two: the site only serves requests, and one to four worker replicas run the transcriptions. The queue stayed a table in our PostgreSQL database: a worker claims the oldest job under a transaction-level advisory lock and reports every 15 seconds, and another worker takes back any job that goes silent for two minutes. Railway doesn’t add replicas by itself, so the leading worker sets the count from the queue through Railway’s API, after a first version that asked for a field the API doesn’t have.

Why move transcription off the web server?

Because the web server was also the only transcription worker, and it could grow only by getting a bigger container. Until October 7, one Railway replica with 2 vCPUs and 8 GB served the site, the API and the MCP endpoint, and ran every transcription, one at a time. Only the holder of a session-level advisory lock worked the queue, so a second replica would have added no transcription capacity.

Now the same image runs as two Railway services with a role setting: web never takes a job, and worker has no public address. A job is one transcription (ScoreStarling turns recordings into sheet music): 17 to 266 seconds of a worker’s time in the production runs we sampled from October 2 to 7.

Why keep the queue in Postgres instead of a broker?

Because the job row already holds what a broker would only point to: owner, status, credit reservation, price and files. A broker would be a second store to keep in step, and most brokers deliver at least once, while a band transcription is a paid request to an outside service that must never be sent twice. We would need our own ownership rules anyway.

The load is small: a few dozen waiting jobs at most, each taking seconds to minutes. Railway’s queue guide says a Postgres queue has fewer moving parts when you already run Postgres, at lower throughput than Redis. Queue libraries such as pg-boss would add a second job table. We’ll reconsider at tens of jobs a second.

How do several workers share one Postgres queue without taking the same job?

Each claim is one short transaction under one lock for the whole queue. An idle worker checks without the lock whether anything is queued, and if not, looks again two seconds later:

-- One claim, slightly simplified
SELECT 1 FROM jobs WHERE status = 'queued' LIMIT 1;  -- nothing queued: stop here
SELECT pg_advisory_xact_lock(<queue key>);           -- held until COMMIT
SELECT * FROM jobs WHERE status = 'queued' ORDER BY created_at LIMIT 1;
UPDATE jobs SET status = 'running', worker_id = $1, heartbeat_at = $2
 WHERE id = $3;
COMMIT;

A second worker waits at the lock, and its next query starts after the first has committed. At Read Committed, PostgreSQL’s default, a query sees what was committed before it began, so the job already shows as running. In our checks, six workers on separate connections drained 40 queued jobs, each taken exactly once.

With many workers, SELECT … FOR UPDATE SKIP LOCKED is the usual choice; PostgreSQL’s documentation suggests it for queue-like tables. We kept one lock because uploads, credit changes and recoveries already take it (in the local SQLite version it is BEGIN IMMEDIATE), so claims take turns with them. We haven’t measured that wait. The queue also needs no database session of its own: no LISTEN, which PgBouncer’s transaction pooling doesn’t support, and no session-level lock like the one our old single leader held.

What happens to a job when its worker stops?

It is recovered, and paid work is never sent twice. A worker stopped on purpose, by a deploy for example, puts its free job back in the queue itself. A worker that crashes just goes silent. Every 15 seconds a worker writes the time and its stage to its job’s row, and every 30 seconds each worker looks, under the same lock, for running jobs whose 120-second lease has run out without a report. A free transcription goes back to the queue once; a second interruption fails it. A band transcription resumes from its saved request, or waits for review without one. A worker that was only slow, and finds its job given away, kills its process and writes nothing.

Once-only work, such as the controller, runs on the leader: the lowest ID among workers that reported to a workers table in the last 45 seconds, which each does every 15. Nothing is held, so a dead leader is replaced within 45 seconds.

Why scale workers on queue depth instead of CPU?

Because a worker runs one job at a time, the workers needed equal the jobs queued or running. A busy worker’s CPU says it is busy, not whether one job or twenty are waiting, and Railway’s autoscaling guide names queue depth as the signal for workers too. Railway grows a container up to its CPU and memory limits by itself, but a replica count stays where you set it; the guide’s controller scales up at once and down a step at a time.

Ours cuts back differently. The API takes a count and Railway picks which replica to stop, so we cut back only when nothing is queued or running and no worker is busy, then straight to one.

When jobs wait, the controller asks for one worker per queued or running job, at least one more than it has and at most four.

What broke in production?

The controller’s first call to Railway’s real API; our tests had used a stand-in that answered any query. Five minutes after the change that switched the controller on was merged, every look at the queue failed. The workers kept taking jobs, but the log and Sentry said only RailwayError: our logs leave out exception messages.

The same query sent without a token reproduced it. Railway validated it against its schema first and answered HTTP 400, GRAPHQL_VALIDATION_FAILED. Our service is placed by region, so the write sets multiRegionConfig, which the update input accepts, but our read asked a service instance for that field, and it has none. The fix reads the count from the environment’s config, which our Railway config file and railway scale also change.

# Before: rejected with GRAPHQL_VALIDATION_FAILED
query ($service: String!, $environment: String!) {
  serviceInstance(serviceId: $service, environmentId: $environment) {
    numReplicas multiRegionConfig
  }
}

# After: the count is at services.<service id>.deploy.multiRegionConfig
query ($environment: String!) {
  environment(id: $environment) { config(decryptVariables: false) }
}

# The write, unchanged; input: {"multiRegionConfig": {"<region>": {"numReplicas": 2}}}
mutation ($service: String!, $environment: String!, $input: ServiceInstanceUpdateInput!) {
  serviceInstanceUpdate(serviceId: $service, environmentId: $environment, input: $input)
}

The log now carries Railway’s own message, which never contains the token, since a refused token and a refused query were both HTTP 400. The stand-in refuses the old query. And a new check sends both operations to the live schema with placeholder IDs and no token: GraphQL servers validate before executing, so a wrong field fails validation, while a valid query gets as far as Railway’s “Not Authorized”.

The same day, the leader began saving each look’s outcome for the site’s health page, which warns when Railway refuses the token or no look arrives for two minutes. The site’s own health check no longer covers the workers, so a worker outage now shows in its five-minute service check, and Sentry emails us when a service stays unwell twice in a row.

What we haven’t verified, and what it costs

• Only free transcriptions have run on the workers; a band transcription there, and its recovery after a lost worker, are untested.
• Our test account may have two scores in progress, and we skipped the planned days of dry-run logging, so the controller has met one small burst and an hour of quiet. Three or four workers, the 90-second step and stopping a busy replica haven’t happened in production.
• Production doesn’t record when a job is taken, so we can’t say yet how much shorter the wait in line is. In the scale-up test the new worker found nothing to do: the first had already taken the waiting job.
• After ten quiet minutes the pool is back to one, so a burst waits up to 30 seconds for the next look, then for a new worker to start: 17 seconds in our one test.
• At the maximum, four jobs run and the rest wait in line.
• A deploy restarts every worker, returning a running free transcription to the queue once, and each CI run that applies our Railway config resets the count to one until the next look.

Railway charges $20 per vCPU and $10 per GB of memory a month, by the minute (checked October 7, 2026). We estimate a worker at about $0.08 an hour while it transcribes at 2 vCPUs and 1.5 GB, and much less while it waits. A hard usage limit on Railway takes every workload offline when reached, so raise such a limit together with the maximum.

If you build this yourself

• Keep the queue with the job’s state unless you need a broker’s routing or throughput.
• Claim in one short transaction; with many workers, use SKIP LOCKED.
• Keep session state out of the queue: no LISTEN, no session-level locks.
• Give each running job an owner and a heartbeat, and make a worker that lost its job stop without writing. Never resend a paid outside request; resume it from its saved ID.
• Scale on queued plus running jobs, and cut back only when no worker is busy if the platform picks which replica stops.
• Test the platform’s API against its live schema, and log its error messages once you know they hold no secrets.
• Give the controller somewhere to report.

Questions and answers

Does Railway autoscale replicas horizontally?

Not as of October 7, 2026. Railway gives a container more CPU and memory up to its limits, but a service’s replica count stays where you set it. Its autoscaling guide has you run a controller that reads a load signal and calls the API’s serviceInstanceUpdate.

Should a Postgres job queue use SKIP LOCKED or an advisory lock?

FOR UPDATE SKIP LOCKED lets many workers claim different rows at once, and PostgreSQL’s documentation suggests it for queue-like tables. A single transaction-level advisory lock makes claims take turns, which is simpler for a few workers, especially when the same lock already guards your other writes.

Why does Railway’s API answer GRAPHQL_VALIDATION_FAILED for multiRegionConfig?

In our case, because we asked a service instance to return multiRegionConfig, which only the update input has. Read the count from environment(id) { config } at services.<service id>.deploy.multiRegionConfig, and write it with serviceInstanceUpdate.

What happens to a running job when a worker replica is removed?

Our controller removes replicas only while no worker is busy. A busy worker stopped anyway, by a deploy for example, returns a free transcription to the queue once; if it vanishes, another worker takes the job back after 120 seconds without a report. Paid requests are never sent again.

How much does an extra worker cost on Railway?

Railway bills $20 per vCPU and $10 per GB of memory a month, by the minute (checked October 7, 2026). We estimate about $0.08 an hour for a worker transcribing at 2 vCPUs and 1.5 GB, and much less while it waits. Our cap is four workers.

The short answer

Not on their own. A chat assistant can talk about music and write notes out as text, but it won’t give you a reliable, editable score of a recording you made, and neither company’s documentation that we checked on October 3, 2026 describes turning audio into notation. Connect a music transcription tool through MCP and both can do it: the tool detects the notes and engraves the score, and the assistant turns your requests into tool calls. That is how ScoreStarling works with Claude and ChatGPT; it is waiting for review in both apps’ directories, and you can add it by its address today.

What happens if you just ask ChatGPT or Claude?

You get words about the music, or notes the assistant writes itself, rather than a transcription of your file. Claude’s help center lists documents (PDF, DOCX, CSV, TXT and others) and images (JPEG, PNG, GIF, WebP) as the files you can upload, with no audio format among them. OpenAI’s file transcription guide is about turning recorded speech into a transcript and doesn’t mention music or notation. We checked both on October 3, 2026.

What assistants can do is write music as text. ABC notation, for example, is plain text that software can draw as a staff, and the official MCP Apps example, Sheet Music Server, takes the ABC an assistant writes and renders it as a playable score. That helps when you sketch an idea. It isn’t a transcription, because nothing measured the pitches and timing in your recording, so you would have to check every note by ear.

A usable transcription is a chain of jobs: find each note’s pitch, start and length in the audio; fit the notes to a beat and a meter; choose a key signature, spell the accidentals, place rests and split voices; then engrave the page and save it in a format notation software opens. Each step has specialized software. Spotify’s open-source Basic Pitch, which we run on our server for one instrument or voice, does the first one, and its authors say it works best on one instrument at a time. MuseScore Studio 4.7.5’s MIDI importer does the middle steps for us, and Verovio engraves the page with the Leipzig music font.

What does connecting a tool over MCP change?

It lets the assistant hand the music to software built for it while you keep asking in plain words. The Model Context Protocol is, in its documentation’s words, “an open-source standard for connecting AI applications to external systems.” A service runs an MCP server that offers tools, and an assistant that connects to it can call those tools in the middle of a conversation. In Claude, a server you add yourself is a custom connector; in ChatGPT, it becomes an app you create in developer mode.

Connecting ScoreStarling opens our sign-in page in your browser. You allow access, and the assistant can then work with your projects and nobody else’s. From then on the jobs split like this:

The tools and the web workspace work on the same saved score, so a change made from chat is there when you open the workspace.

What does a session look like, from recording to PDF?

A handful of plain requests take you from the recording to the files: transcribe, fix, preview and export, with listening in between. The steps below use the example prompts from our connection guide. In ChatGPT we have run most of these steps in real conversations, though not this exact one: an attached recording transcribed on October 5, 2026, and on October 6 a transcription from a link, the score panel, playback, a preview, apply, undo and downloads. In Claude, a score written from notes opened in its panel and played on October 6; uploading a recording from Claude is still being tested.

1. Attach the recording and ask: “Use ScoreStarling to turn this voice memo into sheet music. It’s about 84 BPM.” Include the tempo if you know it. Without one, ScoreStarling estimates it from the recording, which can land on a related tempo for swung or rubato playing.
2. The file travels differently in each app. ChatGPT hands the attachment to the transcription tool. Claude reads it in its code sandbox, asks ScoreStarling for a one-time upload link and sends the file there, which is why the sandbox needs network access. If the upload can’t happen in your app, the assistant can open ScoreStarling’s upload panel, or you can upload the take in the web workspace.
3. Our server transcribes the take at the tempo you gave or one it detects. A voice or one instrument starts in 4/4, which you can change; solo piano also works out the meter and bar lines. The assistant opens it in the in-chat panel where your app can show one. The same project is in the workspace, which plays the transcription and your recording in sync, with a crossfade and looping, so you can hear where they part.
4. Correct what you hear: “In my ScoreStarling score, the last note of bar 1 should be an octave higher.” The assistant reads the score to find that note and applies the exact edit. Edits you spell out apply at once and can be undone.
5. Try a bigger change before you commit: “Transpose my ScoreStarling score up a whole step, and let me hear a preview first.” The tool renders the transposed score and its audio as a preview. Nothing changes until you accept it, and you can discard it instead.
6. Export: “Export my ScoreStarling score as PDF and MusicXML.” You get the two files in the chat or from the panel’s Download menu; their links expire after an hour. The PDF is ready to print, with a small footer line until the score is unlocked, and MusicXML opens in MuseScore, Dorico, Sibelius or Finale for more editing. MusicXML needs the score unlocked, 15 credits once, and the assistant asks before it spends them.

Two more prompts from the guide are worth knowing. “Play my ScoreStarling melody back on a flute” changes the General MIDI sound used for playback and audio exports. “Is anything still running in my ScoreStarling account?” checks your jobs before you start another, since a free account runs one at a time.

How do I connect it in Claude?

Add ScoreStarling as a custom connector. Anthropic’s help center says custom connectors work on the Free, Pro, Max, Team and Enterprise plans, with Free accounts limited to one (checked October 3, 2026).

1. Open Customize → Connectors, select + Add, then Add custom connector. Name it ScoreStarling and enter https://mcp.scorestarling.com/mcp.
2. Under Authentication, choose Sign in now. Under OAuth client, choose Register automatically. Claude recommends its published identity instead, but that option relies on client ID metadata documents, which our sign-in server doesn’t support yet.
3. Sign in to ScoreStarling. In a chat, select + in the message box, open Connectors and switch ScoreStarling on.

On Team and Enterprise plans, an owner first adds the connector under Organization settings → Connectors, and members then select Connect. To transcribe a recording you attach, Claude’s code sandbox has to be allowed to reach ScoreStarling; the guide shows the setting. Uploading from Claude is still being tested, so the upload panel and the workspace remain the fallback. The Claude steps also offer a button that fills in the form for you; Anthropic doesn’t document that shortcut, so the manual path sits beside it.

In Claude Code it is one command, then /mcp in a session to sign in:

claude mcp add --transport http --scope user scorestarling https://mcp.scorestarling.com/mcp

How do I connect it in ChatGPT?

Use developer mode, which OpenAI offers to Plus, Pro, Business, Enterprise and Education accounts on the web (checked October 3, 2026).

1. Turn on Developer mode in Settings → Security and login. In Business, Enterprise and Edu workspaces, an admin may have to allow it first.
2. Open Plugins, select +, name the app ScoreStarling and paste https://mcp.scorestarling.com/mcp. Choose OAuth with dynamic client registration; there is no API key.
3. Sign in to ScoreStarling. The app appears under Drafts; pick it from the Developer mode tool in the message box.

OpenAI’s guide flags developer mode as elevated risk and says write actions ask for confirmation by default, so expect ChatGPT to check with you before a tool changes something. ScoreStarling is waiting for review in the ChatGPT app directory, so a search there finds nothing yet. The ChatGPT steps cover what to check when Developer mode or the + button is missing.

What doesn’t work yet?

Some of it is still being tested, and some is out of scope. Product limits checked October 7, 2026; client menus were checked October 3.

• ScoreStarling is free to start. One instrument or voice, solo piano, imports, editing and PDF, MP3 and WAV downloads are free, and every account gets 100 free credits a month in 2026, 50 from January 2027. A band uses credits, and unlocking a score’s MusicXML and MIDI costs 15 (see pricing). In a chat, ScoreStarling only uses the credits you already have and never sells anything. A free account can have one score in progress at a time, and Plus five.
• Neither ChatGPT nor Claude lists it in its directory yet: we submitted it to both on October 6, 2026, and it is waiting for review. Until it is listed, ChatGPT needs developer mode.
• The in-chat score panel has opened in ChatGPT and Claude in our tests, and ChatGPT has passed an attached recording to ScoreStarling; uploading from Claude and other clients is still being tested. The web workspace is the fallback for every step.
• Uploads are limited to 100 MiB, and every choice transcribes the first five minutes of a recording. Upload audio or video, paste a link, or record in the browser. Pick the choice that matches what’s playing; see the guide to the choices.
• The tempo is detected unless you give one. A voice or one instrument starts in 4/4, which you can change; solo piano works out 4/4, 3/4, 6/8 or 12/8, the bar lines and a pickup; a band score’s meter is found from the playing or chosen before it starts. Every estimate needs checking. TAB doesn’t write bends, slides or hammer-ons, and imported notation and numbered views have their own limits.
• Remote MCP now also reads sheet music and score files and creates scores from ABC or MusicXML text. An assistant can write that notation itself; composition comes from the assistant. ScoreStarling’s plugin, with its two skills, is waiting for directory review too. WebMCP Beta is a separate route for agents in an open browser workspace.
• It doesn’t generate new recordings. MP3 and WAV exports are General MIDI renderings of the score, not stems separated from your recording.
• Every transcription is a first draft. Our October 2 comparison measured guitar recordings and one band excerpt, not singing or solo piano, and the results are published. Listen and correct before you share a score.

What are the other ways to do it?

Other services connect music tools to assistants too. We read each one’s own pages on October 3, 2026.

• Mirelo runs a hosted MCP server at https://mcp.mirelo.ai/mcp. You sign in with a Mirelo account and need no API key, and its guide covers Claude, ChatGPT in developer mode, Cursor, Claude Code and Codex. Its July 30, 2026 launch post says Audio-to-MIDI is available for existing recordings, and the Audio-to-MIDI skill in its plugin repository returns MIDI and MusicXML downloads and detects the tempo unless you give one. Most of its other tools make and edit sound effects. Mirelo is also our band partner inside ScoreStarling, so we are not neutral about it.
• Melogen’s MCP server, for ChatGPT in developer mode with OAuth sign-in, reads printed sheet music from a PDF, PNG or JPG into MIDI and MusicXML, and analyzes a song’s tempo, key and structure. Its public plugin has no tool that turns a recording into a score.
• If you would rather run everything on your own computer, audio2score-mcp is an open-source local server that chains Basic Pitch and music21 into .mid and .musicxml files, with setup notes for Claude Code. It needs no account, and its last commit was on August 20, 2026.
• Without an assistant, upload the take in ScoreStarling’s web workspace, which makes the same score.

Our map of sheet music MCP servers compares 26 of them side by side, including servers that control MuseScore or analyze scores with music21.

Questions and answers

Do I need a paid plan to use a sheet music connector in ChatGPT or Claude?

In ChatGPT, yes: developer mode is offered on Plus, Pro, Business, Enterprise and Education accounts, on the web. Claude allows custom connectors on every plan, and the Free plan is limited to one. Both checked October 3, 2026. On ScoreStarling, one instrument or voice, solo piano and editing are free; a band uses credits, and so does unlocking a score’s MusicXML and MIDI. Every account gets 100 free credits a month in 2026 and 50 from January 2027 (checked October 7, 2026).

Is ScoreStarling in the ChatGPT or Claude app directory?

Not yet. We submitted it to both directories on October 6, 2026, and it is waiting for review. Until then, add ScoreStarling by its address, https://mcp.scorestarling.com/mcp, as the connection guide shows. Anyone can sign in with Google or email.

Can it transcribe a full band recording?

Yes: choose a band, which uses credits, 40 a minute, with the price shown before it starts. Our band partner Mirelo transcribes it, and like any transcription the result needs checking. One instrument or voice and solo piano are free. Every choice covers the first five minutes of a recording, with a 100 MiB upload limit.

Will the assistant change my score without asking?

Edits you spell out, such as “make the last note of bar 1 an octave higher”, apply at once and can be undone. Changes the assistant suggests, and any you ask to hear first, arrive as previews; nothing changes until you accept one.

Can an assistant write guitar tab from my recording?

Yes, since October 8, 2026. Ask for TAB and ScoreStarling shows a guitar, bass or ukulele part with TAB under the staff, or TAB alone, in the tuning and capo you name; the assistant can move a note to another string and paste the TAB as text into its answer. Bends, slides and hammer-ons aren’t written. A local open-source MCP server, fingerstyle-tab-mcp, also turns guitar recordings into text tablature; our map of sheet music MCP servers lists it with the others.

The short answer

Good enough for a first draft, not for a finished score. In our October 2, 2026 test on 12 public guitar recordings, Spotify’s open-source Basic Pitch reached an onset F1 of 0.744 and Mirelo’s Audio-to-MIDI 0.471, where 1.0 would mean every note found at the right pitch and time with nothing extra. Mirelo returned no notes for three of the six solo recordings, but it led on a 60-second band excerpt, 0.672 to 0.520. Note lengths were far less reliable than note starts, and none of these numbers says whether the written score is readable.

What does onset F1 measure?

Onset F1 scores a transcription note by note against a reference transcription, and it punishes missed notes and extra notes alike. A transcribed note counts as a match when its pitch is within 50 cents (a quarter tone) of a reference note and it starts within 50 milliseconds of it. Each reference note can be matched only once.

Two shares come out of the matching. Precision is the share of the model’s notes that match; recall is the share of reference notes the model found. F1 is their harmonic mean, so it stays low when either one is low. Say a passage has 100 notes. A model that writes 100 notes, 75 of them right, scores 0.75. A model that finds 90 of the 100 but writes 150 notes to do it has a recall of 0.9, a precision of 0.6 and an F1 of 0.72: the 60 extra notes cost it.

Onset+offset F1 adds a condition: each note must also end within 20% of the reference note’s length, or within 50 ms if that is longer. Spotify’s Basic Pitch paper uses onset F1 as its main measure because note ends are less objective; it names reverb, the sustain pedal and the way annotations are made. We report both. Neither one checks which instrument a note was given, the key signature or how the rhythm would be written.

How we tested

We used GuitarSet 1.1.0 (Xi et al., ISMIR 2018), a public dataset of 360 guitar excerpts of about 30 seconds: six guitarists play the same 30 lead sheets in five styles, first as an accompaniment (“comp”) and then as a solo over it. It was recorded with a hexaphonic pickup, which gives each string its own signal and let the authors largely automate the note annotations.

We took 12 full recordings, one solo and one comp per guitarist, using the mono microphone audio: 433 seconds in all. The choice was fixed before any model ran. For each guitarist and mode we took the file whose SHA-256 hash of “scorestarling-v1:” plus its name sorts first, after excluding three recordings with known annotation errors (GuitarSet issues #4 and #5: a duplicated note and wrong timings). The table of results by recording below names the 12 it picked.

Scoring used mir_eval 0.8.2 with its default tolerances, as described above, averaged per recording so that each one counts equally. Nothing was tuned: no timing offsets, no filtering, no alignment shift. Basic Pitch 0.4.0 ran on a Mac, and two full runs gave byte-identical output. Mirelo’s Audio-to-MIDI API, which reported its model as a2m-1.1, ran the same 12 recordings on October 2, 2026, without the optional instrument list its API has accepted since August 6, 2026, according to Mirelo’s changelog.

Four limits apply to everything below:

• Basic Pitch’s paper lists GuitarSet and Slakh among its training data, so both tests favor it. We can’t tell whether our 12 GuitarSet recordings were in its training split; the band excerpt comes from Slakh’s test split.
• Twelve guitar recordings and one 60-second band excerpt make a diagnostic sample, not a benchmark. Voice and recorded band performances are unmeasured, and piano is measured only on synthesized audio, with another model (see the questions at the end).
• Mirelo ran the guitar recordings once, on October 2. We haven’t retried the three where it returned nothing, for example by telling it to expect acoustic guitar. Sent again on October 5, the band excerpt came back with the same notes.
• None of these numbers rates the written score. A score-level measure such as MV2H, which also checks meter, voices and note values, is still to be done.

ScoreStarling uses Basic Pitch for one instrument or voice, and Mirelo, our band partner, for a band, so we are not neutral observers. That is why the method, the sample and its limits are spelled out here.

Basic Pitch vs Mirelo on guitar recordings

Basic Pitch came out ahead: far ahead on solo lines, narrowly on accompaniment.

Update, October 4, 2026: we ran the same 12 recordings again through ScoreStarling’s one-instrument option after two changes to it: a take steadily sharp or flat is retuned to A440 first, and a melody is written one note at a time. It scored 0.846 on the solos, 0.679 on the accompaniments and 0.763 overall, or 0.522 with note ends. The table keeps the October 2 results of Basic Pitch on its own.

Mirelo returned no notes at all for three of the six solo recordings. They count as zero in its solo average, because an empty result is what a user would have received, and we have not rerun them. Where it did return notes, the picture was mixed. On the first recording, 00_BN3-154-E_solo, the two engines were level on note starts (0.809 for Basic Pitch, 0.814 for Mirelo), but Mirelo’s note ends were further off (onset+offset F1 0.320 against 0.524), and it put the 154 BPM piece at about 76.9 BPM, half the tempo. On accompaniment, Mirelo was clearly better on two of the six recordings. Across all 12, its onset+offset F1 was 0.224.

Basic Pitch’s 0.744 sits close to what its authors report on their own 72-recording GuitarSet test split: 0.79 onset F1, and 0.56 with note ends. The engines also differed in speed. Basic Pitch got through the 433 seconds of audio in 54 seconds on a Mac, which is not a production timing; on the first recording it took 6.1 seconds and Mirelo 37.

What happens with a full band?

A mix is harder, and there Mirelo led. We took the first 60 seconds of Track01881 from the test split of Slakh2100, a dataset of 2,100 songs rendered from MIDI with sample-based virtual instruments, so the reference notes are exact. The excerpt has steel-string and jazz guitar, piano, bass, vibraphone and drums, all playing within that minute. Pooled over every pitched instrument, ignoring which instrument a note was assigned to, onset F1 was 0.520 for Basic Pitch and 0.672 for Mirelo, scored on the MIDI file each engine returns.

Basic Pitch writes one combined part and no drums. Mirelo writes a part per instrument, so only Mirelo can be scored by instrument, grouped here into General MIDI instrument classes:

Telling the two guitars apart was harder. Scored part by part from Mirelo’s note list on October 2, the steel-string guitar reached 0.364 and the jazz guitar 0.148; the MIDI file starts its notes about 20 ms earlier than that list, so its figures differ slightly. Mirelo also reported 92 notes for instruments that are not in the song: organ, synth pad, violin and cello. Drum strokes are scored on timing alone, whichever drum. This is one song, rendered rather than recorded, so read it as a direction rather than a ranking.

Which notes are most likely to be wrong?

With Basic Pitch, the ones it wrote with a low velocity. Basic Pitch sets each note’s MIDI velocity to 127 times the model’s mean activation over that note, so velocity doubles as a confidence score. Across the 2,715 notes it wrote for the 12 guitar recordings, matched with the same 50 ms window, low-velocity notes were mostly wrong:

Velocity separates right from wrong notes with an AUC of 0.77, where 0.5 is a coin toss and 1.0 is perfect; note length manages 0.53, so short notes are not a useful warning sign. Deleting every note below velocity 50 would raise the overall onset F1 from 0.744 to 0.765, but one of those notes in five is correct. ScoreStarling’s score review therefore lists them as doubtful rather than deleting them, and leaves the decision to your ears. If you run Basic Pitch yourself, coloring or sorting notes by velocity in a piano roll gives you the same shortlist.

Why don’t published accuracy figures agree?

They measure different things on different recordings, and some don’t say what they measured.

Figures can be compared only when the metric, the tolerance and the recordings match. Our Basic Pitch result can sit beside its paper’s, since both use onset F1 on GuitarSet, though on different subsets; it can’t sit beside MuScriptor’s. The ScoreCloud page doesn’t say how pitch accuracy was counted, on how many recordings, or whether timing mattered. MuScriptor is the open research model that Mirelo’s Audio-to-MIDI Pro grew out of, and Mirelo describes its production model as more accurate. Mirelo’s post of September 17, 2026 says an updated model improved note and instrument accuracy “in our evaluations”, without publishing figures.

Do accurate notes make a readable score?

No. Onset F1 compares notes in seconds; it says nothing about whether the written score reads well. A score also needs a key signature, sensible sharps and flats, written rests, voices and a meter, and plain MIDI from a model like Basic Pitch carries none of them. On the same Basic Pitch notes, our first notation writer produced scores with no key signature and no visible rests in all 12 cases, while MuseScore Studio’s MIDI importer wrote the annotated key in 10 of 12 and showed every rest. Mirelo’s own MusicXML had the annotated key in 5 of its 9 completed cases, always on a single treble staff.

A transcription can score well and still be hard to read, and a tidy page can still hold wrong notes. The full before-and-after is in Why MIDI imports look messy in MuseScore.

Which transcription engine should you use?

Choose by the recording. Our reading of these results:

• One instrument or one melody line: Basic Pitch. It was far ahead on solo guitar, it is free and open source, and its README says it works best on one instrument at a time.
• A band, or a mix where you need separate parts or drums: a multi-instrument model such as Mirelo’s, since Basic Pitch writes a single combined part.
• Guitar accompaniment: either. They were close on average and each did better on different recordings, so try both on a short excerpt if the choice matters.
• Voice: we haven’t measured it yet. Piano: we have measured only our own solo-piano option, on synthesized audio, so we can’t rank engines for it.

Whichever engine you use, check rhythm and note lengths by ear. The measurements above, from October 2 and the October 4 re-run, leave out our solo-piano option. ScoreStarling uses Basic Pitch for one instrument or voice and a piano model for solo piano, both free, and Mirelo for a band, which uses credits (checked October 7, 2026). Each covers the first five minutes of an upload of up to 100 MiB. A voice or one instrument starts in 4/4; solo piano works out its meter, and a band score’s meter is found from the playing or chosen before it starts. Guitar, bass and ukulele parts can also be read as TAB, without bends, slides or hammer-ons; see the specifications.

Questions and answers

Can AI transcribe music from an MP3?

Yes, into MIDI note by note, with errors to fix. Models such as Spotify’s Basic Pitch work best on one instrument; full mixes need a multi-instrument model and come out less accurate. In our October 2, 2026 test the best group result was an onset F1 of 0.818, Basic Pitch on solo guitar (0.846 in an October 4 re-run, after two changes to how ScoreStarling uses it), so plan to correct some notes by ear.

Is Basic Pitch accurate enough to make sheet music?

For a first draft from one instrument, yes. On 12 guitar recordings it scored 0.744 onset F1 for note starts but 0.508 once note ends counted, and its MIDI has no key signature, rests or voices, so a notation step has to add them. Why MIDI imports look messy in MuseScore shows what that step changes.

How can I measure transcription accuracy myself?

You need a reference transcription you trust, with note times in seconds. With one, the open-source mir_eval library scores note matches with the tolerances we used: 50 ms for the start, 50 cents for pitch and, for note ends, 20% of the note’s length or 50 ms. Without one, loop short passages and compare the score with the recording by ear.

Why did Mirelo return no notes for some guitar solos?

We don’t know. Three of the six solo recordings came back empty on October 2, 2026. We ran them without Mirelo’s optional instrument list and haven’t retried them. On accompaniment it came close to Basic Pitch, and it led on the multi-instrument excerpt.

How accurate is AI transcription for singing or piano?

For singing, we can’t give you our own numbers yet. For piano, only on synthesized audio: on the opening bars of 25 pieces, each played twice with rubato (50 performances, measured October 6, 2026), our solo-piano option, built on Kong and colleagues’ piano model, heard about 92% of the written notes but got the beat right in only 35 of the 50, and the beat, meter and pickup in 26. Basic Pitch’s authors built it to work across instruments, voice included. A clear, dry recording of one voice or instrument gives any model its best chance.

The short answer

A MIDI file records a performance: which key went down, when, how hard and for how long. Its notes have no sharps or flats, voices, written rests or beams, and the file often has no key signature, so MuseScore has to guess them, and it guesses worst when the notes sit off the beat grid. On 12 guitar transcriptions, our first converter wrote no key signature and hid every rest; MuseScore Studio 4.7.5’s importer, given the same notes on a 16th-note grid at a constant tempo with the key written into every track, got the key right in 10 of 12 and showed every rest. MuseScore Studio 4 has no MIDI import panel, so those fixes go into the MIDI file or into an options file on the command line.

What doesn’t a MIDI file store?

Most of what a reader needs. A MIDI note is a key number from 0 to 127 plus a velocity, sent once when the note starts and again when it stops (MIDI Association). Note 63 is D♯ and E♭ at once; which one to write depends on the key, and the note doesn’t say. A Standard MIDI File can add tempo, time signature and key signature as meta events, but it has no standard place for voices, rests, beams or tuplets. A rest is just a gap, and a length is a count of ticks, not a written value.

Audio-to-MIDI tools add a second problem: their timing comes from a recording, so notes rarely land exactly on a beat. Spotify’s Basic Pitch, which ScoreStarling uses, writes every note into one Electric Piano 1 part at the tempo you give it, with no key signature (note_creation.py). Turning that into notation means choosing, for every note, a spelling, a written length, a voice and a staff. Every converter makes those choices; they differ in how well.

What a simple converter did to 12 guitar transcriptions

Our first notation step was a converter we wrote on the music21 library. We fed it Basic Pitch MIDI from 12 recordings in the public GuitarSet dataset, with each recording’s tempo supplied, and Verovio engraved exactly what it wrote. An audit of those 12 scores found:

• No visible rests in any score: by default, music21’s MusicXML exporter fills gaps with hidden rests (m21ToXml.py).
• No key signature in any score. Pieces in E major showed no sharps, and one accompaniment in C major carried redundant naturals on 153 of its 431 written notes (421 MIDI notes, some split by ties).
• Spelling by note number alone. MIDI note 63 always came out as E♭, even where E major needs D♯; in a piece in G♭ major, 30 of the 49 notes that belong to the key were misspelled.
• Up to five voices on one staff. Note starts and ends were each snapped to the nearest 16th, so a string still ringing under the next note forced another voice, with dots and ties to match.
• Guitar written as piano: 10 of the 12 scores on a grand staff and the other 2 in bass clef, none in guitar clef, because Basic Pitch labels every note Electric Piano.

We re-ran that converter on the same saved MIDI files on October 7, 2026 and got the same counts.

The music font was not the problem. Verovio and its Leipzig font drew what the MusicXML said; the MusicXML was wrong.

Before and after: MuseScore Studio’s importer

We looked at open-source alternatives first: partitura handles key, spelling and voices but has no quantizer and writes no rests, and the other research tools we found were piano-only, unlicensed, non-commercial or unreleased. So we handed the job to MuseScore Studio 4.7.5’s MIDI importer, run as a separate program. Same 12 recordings, same Basic Pitch notes, same supplied tempo, prepared as described below, on a Mac on October 2, 2026:

The written note counts differ because MuseScore ties notes across beats and barlines differently. The two wrong keys were both a fifth from the annotation: D♭ major for a piece in G♭, B major for one in E. Without our estimate in the file, MuseScore’s own key guess matched only 5 of the 12 (re-run October 7, 2026); writing the estimate in is what raised it to 10. The importer took 1.2–4.3 seconds per recording, 2.3 seconds on average.

Why does MuseScore re-guess the tempo, meter and key?

Because unquantized MIDI looks like a live performance to it. The importer checks the notes that fall near a beat, and if fewer than 60% of them start right on it, it treats the file as a human performance (importmidi_quant.cpp). It then runs its own beat tracker, picks a meter and stretches note times to fit the beats it found. MuseScore’s older handbook describes that mode as trading accuracy for readability and says it is on by default for unaligned files.

The key has a rule of its own. If any non-drum track lacks a key signature, or the file counts as a performance, the importer estimates the key from the notes (importmidi_key.cpp). So a key signature in the tempo track alone is not enough: every track with notes needs one. With raw Basic Pitch MIDI we saw meter, tempo and key all re-guessed, even with the human-performance option set to false.

How should you prepare MIDI before importing it?

Make the notation decisions you can inside the MIDI file, before MuseScore sees it. This is what we do to every transcription:

1. Use one constant tempo. ScoreStarling uses the BPM you set, or one it detects from the recording; in a DAW, record to a click or match the project tempo to the take.
2. Move every note’s start and end onto a grid of the shortest value you want to read. The October 2 test here used 16th notes in 4/4. With every note on the grid, MuseScore reads the file as written music rather than as a performance.
3. Put the tempo and time signature in the first track, and a key signature in every track that has notes. We estimate the key from the notes with music21’s Krumhansl–Schmuckler key finder; if you know the real key, use it.
4. Give each track its real instrument. MuseScore picks staves and clefs from the General MIDI program: a guitar left as Electric Piano lands on a grand staff, while a nylon-string guitar program gets treble clef with an 8 below.
5. Watch repeated notes. If one pitch is struck twice within a single grid step, snapping merges the two attacks; we place the second one a 32nd later.

Which MuseScore import settings should you use?

MuseScore Studio 4 has no import panel to set them in. Its handbook calls the MIDI import panel “not currently implemented”, and the GitHub issue to restore it (#11918, opened in June 2022) was still open when we checked on October 3, 2026. Inside the app, the only quantization control is the shortest note value for imported MIDI files, under Preferences → Import.

The importer still reads its main options from a file passed on the command line with -M; the handbook’s command-line page links a sample. This is the file the October 2 test used; ScoreStarling now writes a melody line in one voice (VoiceCount 0) and turns RecognizePickupBar on when the first bar is a pickup:

<?xml version="1.0" encoding="UTF-8"?>
<MidiOptions>
  <QuantValue>2</QuantValue>
  <VoiceCount>1</VoiceCount>
  <Duplets>false</Duplets>
  <Triplets>false</Triplets>
  <Quadruplets>false</Quadruplets>
  <Quintuplets>false</Quintuplets>
  <Septuplets>false</Septuplets>
  <Nonuplets>false</Nonuplets>
  <HumanPerformance>false</HumanPerformance>
  <MeasureCount2xLess>false</MeasureCount2xLess>
  <SplitStaff>false</SplitStaff>
  <ClefChanges>false</ClefChanges>
  <SimplifyDurations>true</SimplifyDurations>
  <ShowStaccato>false</ShowStaccato>
  <DottedNotes>true</DottedNotes>
  <RecognizePickupBar>false</RecognizePickupBar>
  <Swing>0</Swing>
</MidiOptions>

Then convert, naming the output as MusicXML:

mscore -M midi-import.xml -o score.musicxml performance.mid

The program’s name and location depend on your system; on Windows the handbook uses MuseScore4.exe. What the main options do:

If your music has triplets, don’t snap it to a straight grid, and leave Triplets on; we haven’t measured how well MuseScore finds them. In MuseScore 3 the same choices sat in an import panel, with columns such as Max. voices, Search tuplets and Is human performance.

What does the tidier score cost?

Some accuracy, mostly in note lengths. These are the trade-offs we measured or know of:

• MuseScore wrote 26% of the notes longer than the quantized performance, by up to three 16ths and never shorter, and notes sounding together with different lengths can share one value. In ScoreStarling, playback and MIDI exports keep the performed timing, though a melody line is cleaned first: of notes struck together the strongest stays, faint echoes go, and a held note ends where the next begins.
• The key is estimated from the notes and was wrong in 2 of 12 cases, each time a fifth away. Keys with seven sharps or flats are written as their five-accidental equivalents.
• The straight 16th-note grid in this October 2 guitar test did not represent triplets or swing. That is still true when ScoreStarling transcribes one instrument or voice, which starts in 4/4; for solo piano it follows the playing’s bars and can choose 4/4, 3/4, 6/8 or 12/8. If you prepare a file yourself, write its real time signature in.
• MuseScore splits piano chords between the hands by its own rule, and even close two-note chords can land on different staves.

Some of this can be cleaned up after import. Tools → Regroup rhythms rewrites a selected passage so that notes group by beat, without changing the rhythm itself. Tools → Respell pitches with sharps or with flats changes spelling, though the handbook says it is meant for notes of a single pitch. A wrong key is quicker to fix in the MIDI file before import than note by note afterwards.

Can MuseScore turn an MP3 into sheet music?

MuseScore Studio can’t: it opens score formats such as MusicXML and MIDI, not audio. Muse Group announced an Audio-to-Score beta on MuseScore’s web platform on August 17, 2026: solo piano and acoustic guitar, MP3 files up to 30 MB (about three minutes), free, returned as an MSCZ file for MuseScore Studio. We haven’t tested it.

The other route is the one in this article: an audio-to-MIDI model, preparation of its timing, then MuseScore’s importer. ScoreStarling works this way for one instrument or voice, with Basic Pitch, and for solo piano, with a piano model whose notes also give the pulse and bar lines; Verovio draws the page. A single-note line is now written on one staff in one voice, a part playing chords keeps them on one staff, and Score settings → Layout can change how a single-part recording is written. The measurements above are from October 2. An October 4 re-run, after melodies began to be written one note at a time on one staff, again matched the key in 10 of 12, spelled 0 of 3,158 in-key notes against it and showed all 357 rests.

You can also choose or drop a MIDI file in ScoreStarling and get an editable score; it leaves out drum tracks and keeps one time signature for the whole score. A recording is transcribed for its first five minutes, from an upload of up to 100 MiB. PDFs are free and MusicXML needs the score unlocked (15 credits, once); the specifications have the rest (checked October 7, 2026). The workspace is free to start; the accuracy article keeps the dated guitar and band measurements.

Questions and answers

How do I convert MIDI to MusicXML?

Open the MIDI file in MuseScore Studio, choose File → Export and pick MusicXML; compressed .mxl is the default. From a terminal, mscore -o score.musicxml file.mid does the same, and -M adds an options file for quantization and voices. Prepare the MIDI first, or the MusicXML will carry the same mess.

Why are there so many ties and dotted notes after a MIDI import?

Because performed notes rarely end on a beat. Snapped to a fine grid, they cross beats and barlines and need ties, and notes that overlap spill into extra voices. Quantize to the shortest value you want to read, cap the importer at two voices and let it simplify durations; MuseScore will then write some notes slightly longer to tidy the page.

Why does MuseScore write D♯ where I expected E♭?

MIDI stores note 63 without a spelling, so MuseScore spells from the key signature, and if a track has none it estimates the key itself. Write the right key signature into every track before importing. After import, Tools → Respell pitches with sharps or with flats changes selected notes of the same pitch.

Can I get the MuseScore 3 MIDI import panel in MuseScore Studio 4?

Not as of October 3, 2026: the panel hasn’t been ported, and GitHub issue #11918 to restore it is still open. MuseScore Studio 4 keeps a shortest-note preference for imported MIDI, and its command line accepts an options file with -M that covers the panel’s main choices.

Can I open a ScoreStarling transcription in MuseScore?

Yes. Export MusicXML (.musicxml or .mxl), which keeps the key signature, spelling, rests and voices, or MIDI if you only need the notes. Both need the score unlocked, which costs 15 credits once. ScoreStarling is free to start, and every transcription is a first draft to check by ear.

The short answer

Record the melody on its own: one voice or instrument, phone close, quiet room, steady tempo, ideally with a click in headphones so you know the BPM. Export the memo (an iPhone exports .m4a by default), trim it so it starts on the first note, and give it to a transcription tool along with that tempo. Then treat the score as a first draft: loop two bars at a time against the recording, fix pitches and lengths, and only then transpose and export PDF, MusicXML or MIDI.

Can an app turn humming or singing into sheet music?

Yes, when the recording holds one clear melody. The software does two separate jobs. First it listens for notes: each pitch, when it starts and when it stops. Then it writes those notes down, which means choosing a key, a meter, note values and where the bar lines go. If the tune is still only in your head, sing it into your phone first; everything below applies to that recording.

In ScoreStarling, for one instrument or voice, the first job is done by Spotify’s open-source Basic Pitch model, which turns audio into MIDI on our server. Spotify says Basic Pitch works on “almost any instrument, including voice.” That is their claim. Our own measurements so far cover guitar recordings, one band excerpt and synthesized piano, not singing. The second job goes to MuseScore Studio 4.7.5’s MIDI importer, and Verovio engraves the page.

Timing is often the hardest part of a voice memo. ScoreStarling detects the tempo or uses the BPM you supply, but for one instrument or voice it still writes to a straight grid starting in 4/4, so drift, silence before the tune and a wrong tempo can produce misplaced ties and rests. Solo piano follows the playing’s own pulse and meter, but it is meant for piano, not sung memos. The advice here helps give a melody a steady pulse.

How to record a voice memo for transcription

Give the software one line of music at one steady tempo, close to the microphone, with nothing else playing.

• Record one voice or one instrument: no backing track, no second singer, no guitar under the vocal. Busy mixes, heavy reverb and several instruments at once make the first draft harder to read.
• Keep the phone close and the room quiet. Apple’s guide sets the recording level by distance: move the phone closer to or farther from the sound. Close, but not so close that your loudest notes distort. A room with soft furnishings echoes less than a bathroom or a stairwell.
• Use a click that you can hear and the phone can’t: a metronome in headphones, played from a second device. Apple’s guide says Voice Memos stops recording if another app on the iPhone starts playing audio, so the click shouldn’t come from the recording phone.
• Write down the BPM. If you recorded without a metronome, tap along afterward with a tap-tempo metronome, or count beats for 15 seconds and multiply by four.
• Count in silently. A spoken “one, two, three, four” is sound like any other and can end up written as notes, so count in your head or in the headphones, or trim the count-in off afterward.
• Sing on a syllable such as “da” or “doo” rather than a closed hum, so repeated notes don’t blur into one. That’s our suggestion, not a measured result.
• Keep each take under five minutes: only the first five minutes of a recording are transcribed, from a file of up to 100 MiB. Record long songs in sections beginning at a bar line.
• Leave the extras off. On Pixel 9 and later, Google’s Recorder can add AI background music to a recording, and added music is more sound to transcribe. If you sang over an instrumental with Voice Memos’ layered recording, separate the layers and upload only the vocal.

Then trim the start. Bar 1 begins at 0:00 of the file, so cut any silence or count-in until the file starts right on the first note. If the tune begins with a pickup, you can mark the first bar as a pickup later. In Voice Memos, the editor’s yellow trim handles do this, and you can pinch to zoom for precision. Google’s Recorder has Crop & Remove, which saves a trimmed copy.

What format do iPhone and Android voice memos use?

An iPhone exports a Voice Memos recording as an .m4a file by default; Android recorders differ by maker, so check the file extension after you share one.

Apple’s iPhone User Guide (iOS 27, checked October 3, 2026) says default exports are .m4a, which flattens layered recordings and turns Spatial Audio into stereo. To get the file off the phone, use Save to Files from the recording’s share options. Skip the Editable option: it exports QuickTime Audio, a format for adjusting effects and layers later. For a layered recording, use Separate Layers first; each layer then becomes its own .m4a.

On Pixel phones, Google’s Recorder shares a recording as an audio file: touch and hold it, then choose Share, File and Audio. Google’s help pages don’t name the format (checked October 3, 2026), and other Android brands ship their own recorder apps. Whatever arrives, ScoreStarling accepts WAV, MP3, FLAC, M4A, OGG and AIFF. You can also skip the file and record in the browser; that recorder stops at 4:59, just inside the five-minute limit.

Step by step: voice memo to sheet music in ScoreStarling

Upload the memo, give its tempo, transcribe, then correct the score by ear before you export it. Transcribing one instrument or voice, editing and PDF downloads are free on ScoreStarling; unlocking the score’s MusicXML and MIDI uses credits (checked October 7, 2026). Open the workspace to start.

1. Choose New score. Drop in the file, or choose Record to sing straight into the browser. Nothing is kept until you choose Create score.
2. Under What’s playing?, keep One instrument or voice, which runs Basic Pitch on our server for free. Solo piano is free too. Band or several instruments uses credits, 40 a minute with the price shown before it starts, and sends the audio to our band partner Mirelo; it runs only if you pick it.
3. Open More options and enter Beats per minute, in quarter notes from 30 to 240, or leave it on Auto to have the tempo detected. It sets how the score is written, not the recording. If you can’t decide between 70 and 140, either will do: 140 writes every note at twice the value.
4. Choose Create score. The score appears with playback in sync with your recording.
5. Check it by ear, two bars at a time, as the next section describes.
6. Fix what you hear. Select a note to raise or lower it a semitone (the up and down arrow keys work too), change its length, or delete it; deleting leaves a rest, so the beat stays put. Undo, redo and saved versions are there if a fix goes wrong.
7. Finish in Score settings: key and clef, time signature, a pickup bar if the tune starts before the downbeat, and transposition by interval. Transpose last. It moves every note and the key, but your recording keeps its original key, so comparing by ear gets harder afterward.
8. Download what you need: PDF to print, MusicXML for a notation app, MIDI for a DAW, page images, separate parts, or an MP3 or WAV preview. MusicXML and MIDI need the score unlocked (15 credits, once); until then the PDF, page images and parts carry a small footer line. The audio is a General MIDI rendering of the score, not your voice. Our guide to MusicXML, MIDI and PDF explains which file to pick.

How to check a transcription against the recording

Work two bars at a time: select them, turn on looping, and listen three ways before you change anything. The player switches between Score, Both and Recording while it plays. Start with the recording alone to fix the melody in your ear, then the score alone, then both together. A wrong pitch clashes with your voice; a note in the wrong place sounds doubled, like an echo.

Fix things in order. Check the bar lines first, because if the first beat is wrong, every bar is wrong: mark a pickup bar, or re-trim the file and transcribe again. Then fix pitches, then lengths, and leave expression and layout for last.

What to expect from the first draft

Expect a draft to correct, not a finished part. We haven’t measured singing yet, so this list comes from how the One instrument or voice choice works and from our measurements on 12 solo and accompaniment guitar recordings from the public GuitarSet dataset, run on October 2, 2026 and again on October 4.

• One instrument or voice starts in 4/4 on a straight grid at the detected or supplied tempo; triplets and swing are not inferred. Check the rhythm and change the time signature in Score settings where needed. Solo piano can follow 3/4, 4/4, 6/8 and 12/8, but it is for piano.
• Note ends are less reliable than note starts. On those guitar recordings on October 2, Basic Pitch scored a macro onset F1 of 0.744, but 0.508 when the end of each note had to match too. An October 4 re-run, after we began retuning off-pitch takes and writing a melody one note at a time, scored 0.763 and 0.522. Onset F1 counts a note as found when its pitch matches and its start lands within 50 milliseconds, then balances missed notes against invented ones; 1.0 is perfect. Our accuracy measurements explain the method.
• An out-of-tune take is corrected first. A recording that is steadily 10 cents or more sharp or flat of A440 is retuned before transcription, so its notes are written at concert pitch; a voice whose pitch drifts is left as it is.
• Written lengths are simplified for reading. MuseScore Studio wrote 26% of the guitar notes longer than they were played (after snapping to the grid), by up to three sixteenths, and never shorter. Playback and the MIDI export keep your timing; change a note’s length if the page should show what you sang.
• Repeated notes need a look. Two notes on one pitch with no gap between them give the model little to separate, so check for one long note where you sang two. To fix it, shorten the note, then fill the rest that appears with the same pitch.
• The key is a guess. It’s estimated from the notes; on the guitar set it was wrong for 2 of the 12 recordings, both times a fifth away. Set the right one under Key & clef.
• Check the melody line. A detected single-note line is written as Melody on one staff, keeping the strongest of notes struck together and dropping faint echoes, while a part playing chords keeps them on one staff. For a single-part recording, Score settings → Layout can apply One melody line to an older score too, using the existing notes. It removes extra notes from playback; Undo restores them. Check that it kept the notes you sang.
• You get notes only. ScoreStarling doesn’t write lyrics or chord symbols from a recording.

How to write a melody down by ear instead

If no tool suits the job, you can write the melody down yourself with a keyboard (a phone app will do) and a player that loops a passage. It’s slower, and it trains your ear.

1. Find home. Hum the note the tune wants to end on and find it on the keyboard. That is usually the key’s home note, which suggests a key signature to try.
2. Find the beat. Tap your foot to the recording and count. A strong beat every three taps suggests 3/4, every four taps 4/4; if each beat splits into three, think 6/8.
3. Write the rhythm first, one bar at a time, as marks under the counts.
4. Add the pitches. Start from a note you know, judge each next note as a step, a skip or a leap, and check it on the keyboard.
5. Play your version back against the recording and sing along. Anything that rubs is a note to fix.

Other apps take singing too. ScoreCloud’s Express app for iPhone and iPad notates singing, whistling or humming, and Klangio’s Sing2Notes runs in a browser and on iOS and Android, with PDF, MIDI and MusicXML downloads (both as described on their own sites, checked October 3, 2026). We haven’t tested either.

Questions and answers

Can I hum, or do I need to sing the words?

Both give the software a pitched melody to follow, and we haven’t measured either yet. We suggest singing on a syllable that starts with a consonant, such as “da”, so every note has a clear beginning. That matters most when the same pitch repeats.

Will it work out the tempo for me?

Yes, it detects the tempo when you leave Beats per minute on Auto. Supplying the BPM you recorded with is more reliable: in our October 3, 2026 check on 14 test recordings, the detected tempo was within 4% on 6, and most misses were off by 3:2 or 4:3, typical of swing or a triplet feel. One instrument or voice starts in 4/4 on a straight grid; if the tune uses another meter, change it in Score settings after transcription.

Can it add lyrics or chord symbols to my melody?

Not from the recording. The transcription contains notes, not words or chord names. Unlock the score (15 credits, once), export MusicXML and add lyrics or chord symbols in a notation app such as MuseScore Studio.

How long can a voice memo be?

Up to five minutes. A longer file, up to 100 MiB, is accepted and its first five minutes are transcribed; the browser recorder stops at 4:59. Split longer music at a bar line and transcribe each section.

Where does my recording go when I upload it?

With One instrument or voice, the default, the audio is transcribed on ScoreStarling’s own servers and the project stays private to your account. Only if you choose Band or several instruments is the audio sent to our band partner Mirelo. The privacy policy covers storage and deletion.

The short answer

We opened 26 MCP servers for sheet music on October 3, 2026, and they do five different jobs. Two hosted servers turn a recording into notation, Mirelo and our own ScoreStarling, and audio2score-mcp does it on your computer with open-source parts. MuseScore, Dorico and Finale each have servers that drive the app on your machine; mcp-musescore and mcp-score are the active MuseScore ones. The rest render notation an assistant writes, analyze music with music21 and similar engines, or read and find printed music.

How did we find and check these servers?

We searched the official MCP Registry, GitHub, PulseMCP, Glama and mcp.so for sheet music, notation, MuseScore, music21, MusicXML, ABC, LilyPond, Dorico and audio-to-MIDI servers, then opened the README or product page of every server listed here. The directories turned up little on their own: PulseMCP returned one server for “sheet music” and none for “music21”, so most of the list came from GitHub.

In the tables, last activity is the latest release, shown with its version, or else the latest commit on the main branch. “Local” means the server runs on your computer, usually over stdio, and “ChatGPT” means its developer mode. We sent each hosted server an MCP initialize request, the first message any client sends, to see whether it asks for sign-in. We didn’t install or run the local servers, so their features are as their authors describe them. We left out servers that only generate MIDI or audio, DAW controllers, streaming and metadata servers, practice apps, copies of other projects, and repositories whose README doesn’t describe a working server. ScoreStarling is ours, so it appears with the same columns and its limits.

Which MCP servers turn a recording into sheet music?

Three of the servers we opened take a recording and return notation: Mirelo and ScoreStarling are hosted, and audio2score-mcp runs locally. Three more stop short of a score: audiolla and a MuScriptor server return MIDI, and fingerstyle-tab-mcp writes text tablature.

The two hosted servers are built for different jobs. Mirelo’s is mostly sound-effect tools; its Audio-to-MIDI tool returns files and detects the tempo unless you give one, and its plugin README lists no tools for editing a score. ScoreStarling detects the tempo unless you give one and keeps the score in your account, where you can correct notes, hear a change before applying it, transpose and export; it is waiting for review in the ChatGPT and Claude directories. Mirelo is also our band partner inside ScoreStarling. audio2score-mcp stops at files on purpose and leaves editing to your notation app. The MuScriptor server needs a Hugging Face sign-in to download its model, whose weights are for non-commercial use.

Which MCP servers render or write notation?

Five servers turn notation that the assistant writes, as ABC, LilyPond, JSON or MusicXML, into something you can see, hear or print. None of them transcribes a recording.

The official example is the smallest: its one tool, play-sheet-music, takes ABC and draws it in hosts that support MCP Apps, and a copy at example-server.modelcontextprotocol.io answered our handshake without sign-in. Music Studio’s hosted address did too. Gradus is a local package that sends scores to its maker’s hosted API without a key and asks agents to credit Gradus when they show its output; it also analyzes harmony and checks engraving against a cited rulebook. lilypond-mcp runs a WebAssembly build of LilyPond, and raulkivi’s rendering server uses Verovio, the engraver we use too.

Is there an MCP server for MuseScore, Dorico or Finale?

Yes: we found five for MuseScore, two for Dorico and one for Finale, all independent projects on GitHub that run on your computer next to the app.

They work through each app’s own interfaces: MuseScore’s plugins, extension host or command line; Dorico’s Remote Control API, which you allow in Dorico, through a preference or a prompt on first connection; or an RGP Lua script in Finale. FinaleMCP’s README notes that Finale was discontinued in August 2024 but still runs. None of them imports audio. JordanSucher’s server still appears in directories but hasn’t changed since April 2025, so we would try mcp-musescore and mcp-score first; mcp-score calls itself alpha. The only official MCP Registry entry with “musescore” in its name, @chrischall/musescore-mcp, is a local package for Claude that searches the musescore.com site through your signed-in browser instead of editing scores; it was last published on September 28, 2026, and its GitHub repository returned 404 when we checked.

Is there a music21 MCP server for music analysis?

Several. music21 is, in its own documentation’s words, “a Python-based toolkit for computer-aided musicology,” and these servers use it or similar engines to answer questions about keys, chords, cadences and voice leading in MIDI, MusicXML or MEI files.

The most-starred, music21-mcp-server, needs a source install: the pip package its README names wasn’t on PyPI when we checked, and its main branch last changed on March 19, 2026. It also offers a local HTTP API beside the MCP server. encoding-music-mcp comes from the University of Melbourne’s data analytics platform and suits scholarly MEI editions. THIRI answers chord questions rather than reading whole scores.

Which other sheet music MCP servers are worth knowing?

Two jobs sit next to transcription: reading printed music into a digital score, and finding public-domain scores.

To read printed music on your own computer instead, the omr-mcp server in raulkivi’s set above turns a photo or scan into MusicXML, and ScoreBridge, in the MuseScore table, has the assistant read the page and write it out through MuseScore. All of them work from images of a page, not from audio.

How do you choose a sheet music MCP server?

Start from the job, then check where the server runs.

• For an editable score from a recording inside a chat app, use a hosted recording-to-notation server: ScoreStarling with a free account, or Mirelo with a Mirelo account. Compare how each sets the tempo, how long a take can be and which files come back.
• To keep working in MuseScore, Dorico or Finale, use one of the app servers. They need the app installed on the same computer, usually open, and a client that runs local servers.
• For analysis or teaching, try a music21 server or Gradus; for MEI editions, encoding-music-mcp.
• For the assistant to write and show music, use Music Studio or the Sheet Music Server example for ABC, or lilypond-mcp for LilyPond.

Hosted servers are the kind you can add to ChatGPT, or to Claude on the web and on a phone, but your files go to the provider, and most need an account with it. ChatGPT’s developer mode connects with OAuth or no authentication, while Claude’s custom connector form also takes fixed request headers such as an API key (both checked October 3, 2026). Local servers keep files on your machine and need Python or Node and a desktop client such as Claude Desktop, Claude Code, Cursor or VS Code. Either way, read the last-activity column: four of the GitHub projects here had no commit on their main branch in the six months before we checked.

Questions and answers

Which MuseScore MCP server is the most popular?

By GitHub stars on October 3, 2026, ghchen99’s mcp-musescore leads with 105, then JordanSucher’s musescore-mcp with 29, which hasn’t changed since April 2025, and tskovlund’s mcp-score with 26. Stars measure attention, not quality, so also check the last commit and which MuseScore versions each one supports.

Can I use these MCP servers in ChatGPT?

On the web, only the hosted ones. ChatGPT’s developer mode, offered on Plus, Pro, Business, Enterprise and Education accounts, connects to remote servers over SSE or streaming HTTP with OAuth or no authentication (checked October 3, 2026). Local stdio servers need a client that starts them on your computer, such as Claude Desktop, Claude Code, Cursor or VS Code.

Is there an MCP server that turns audio into guitar tab?

fingerstyle-tab-mcp writes text tablature from a guitar recording, using Demucs and Basic Pitch on your own computer, with setup steps for Claude Desktop. Its last commit was on January 15, 2026. Since October 8, 2026, ScoreStarling also shows a guitar, bass or ukulele part as TAB under the staff or alone and returns the TAB as text.

Do MuseScore, Steinberg or MakeMusic publish an official MCP server?

Not among the servers we found on October 3, 2026. Every MuseScore, Dorico and Finale server here is an independent project on GitHub, and Dorico Maestro’s README says it isn’t affiliated with Steinberg.

Do I need MuseScore installed to use a MuseScore MCP server?

Yes. mcp-musescore needs MuseScore 3 or 4 running with its plugin and a score open. mcp-score needs MuseScore Studio 4.4.2 or later running for live editing, and MuseScore installed, though not running, to render files.

The short answer

Export MusicXML when someone will keep editing the notation, MIDI when the music goes into a DAW or a synthesizer, and PDF when someone will read or print it. MusicXML stores the written score: spelled notes, key and time signatures, rests, voices and lyrics. MIDI stores a performance (which key, when, how hard), so turning it back into notation means guessing. A PDF stores the finished page and nothing a music program can edit.

What is MusicXML?

MusicXML is an open, XML-based file format for sheet music, made so that notation programs can exchange scores and archive them. The latest finished version, MusicXML 4.0, was published on June 1, 2021 by the W3C Music Notation Community Group as a final community group report, which is not the same thing as a formal W3C standard. The group reported work toward a 4.1 release in August 2026.

It describes music the way it is written. A pitch is a letter name, an alteration and an octave, so D♯ and E♭ stay different notes. A note has a duration, counted in divisions of a quarter note, and a written type such as a dotted eighth. Rests, voice numbers, beams, stem directions, key signatures (counted in fifths: positive numbers for sharps, negative for flats), time signatures, lyrics with verse numbers, and optional page and system layout each have their own elements. The format also keeps sound apart from appearance. A tempo can be stored in quarter notes per minute, and a note can carry small attack and release offsets that belong to a performance rather than to the page.

Notation programs use it to trade scores. MuseScore Studio, Dorico and Sibelius all document MusicXML import, and MakeMusic’s MusicXML site counts more than 260 applications that support the format (checked October 3, 2026).

What is a MIDI file, and what does it leave out?

A MIDI file is a timed list of performance events: this key went down at this moment with this velocity, came up at that moment, and should sound with this instrument program. MIDI 1.0 dates from 1983. Its file format, Standard MIDI Files 1.0 (RP-001, last revised in February 1996), exists so that programs can exchange time-stamped MIDI data.

A MIDI file can also carry a few musical facts as meta-events: the tempo (in microseconds per quarter note), a time signature, a key signature given as a number of sharps or flats plus major or minor, and lyrics, usually one event per syllable. The specification asks every file to state its tempo and time signature, and when one doesn’t, programs assume 4/4 at 120 beats per minute. Key signatures and lyrics are optional.

What MIDI can’t say is how to write the notes. A note is a key number from 0 to 127, so number 63 is D♯ and E♭ at once; when the first converter we built turned MIDI into notation, it wrote 63 as E♭ every time, even in E major, where it should be D♯. Durations are only start and stop times, so note values have to be inferred. There are no rests (silence is just a gap), no voices, beams or stems, and no page layout. MuseScore Studio’s handbook says MIDI encodes the notes and instruments “but none of the visual formatting.” There is no audio either: the sound comes from whatever synthesizer plays the file.

MusicXML vs MIDI vs PDF: what each file keeps

MusicXML keeps what is written, MIDI keeps what is played, and a PDF keeps how the page looks. PDF is the general-purpose page format, standardized as ISO 32000; PDF 2.0 (ISO 32000-2) was first published in 2017 and revised in 2020, and the Library of Congress’s format register describes it as page-oriented. A score in PDF looks the same on any screen or printer, but to a music program it is a picture of notes.

“Printed only” means a person can read it on the page but software can’t use it as music. Getting notation back out of a PDF takes optical music recognition (OMR), which reads the image and infers the notes, so the result needs proofreading.

Which format should you export?

Choose by what happens to the file next.

• If someone will edit the notation, send MusicXML. MuseScore Studio (free and open source), Dorico and Sibelius all import it. Send .mxl unless a tool asks for plain .musicxml.
• If the music goes into a DAW or drives a synthesizer, send MIDI. It keeps the timing and velocity of every note, which is what production work needs.
• If someone will play from it, send a PDF, printed or on a tablet, with separate parts for an ensemble.
• If someone only needs to hear it, send an MP3 or WAV rendering; a MIDI file makes no sound of its own.
• If you’re archiving, keep the MusicXML for the music and the PDF for the look. That’s our habit, not a rule.

Finale users have one more thing to weigh. MakeMusic stopped developing and selling Finale on August 26, 2024. It keeps working where it is installed, barring operating-system changes, and MakeMusic’s technical support for it ended in August 2025. MakeMusic’s own migration advice is to export MusicXML, which Finale v27 writes as MusicXML 4.0, because Dorico can’t open Finale’s .mus or .musx files directly (checked October 3, 2026).

To turn a MIDI file into PDF sheet music, import it into a notation program, clean it up there, and export the PDF. MuseScore Studio opens MIDI files and has an import preference for the shortest note value to use; Dorico Pro’s manual describes its own MIDI import and quantization options. Expect cleanup either way, for the reasons in the section on guesswork below. ScoreStarling now accepts MIDI with Choose a file or a file drop, engraves it into an editable score and exports PDF. It omits drum tracks, uses the first meter, and still needs a visual check. You can also import MusicXML/MXL, ABC or printed sheet music; see current input limits.

MXL vs MusicXML: what is the difference?

Both hold the same MusicXML: .mxl is the compressed package, and .musicxml is the plain text file. The W3C’s MusicXML 4.0 tutorial recommends exactly those two suffixes and points out that a plain .xml suffix doesn’t let programs tell MusicXML apart from any other XML file.

An .mxl file is a zip archive compressed with the DEFLATE algorithm. Its first entry is an uncompressed file named mimetype, and a file at META-INF/container.xml points to the score inside. According to the tutorial, compression shrinks MusicXML to about the size of the equivalent MIDI file, so we’d send .mxl. MuseScore Studio exports compressed MusicXML by default. Choose .musicxml when you want to read, compare or process the XML yourself. The two also have separate media types: application/vnd.recordare.musicxml for .mxl and application/vnd.recordare.musicxml+xml for .musicxml.

Why MIDI to sheet music takes guesswork

A MIDI file never says how its notes should be written, so any program that turns MIDI into notation has to decide the key, the spelling, the note values, the voices and where the rests go.

We measured how that goes wrong. On October 2, 2026, we gave Basic Pitch MIDI from 12 guitar recordings in the public GuitarSet dataset to the first converter we had built, on the music21 library. None of the 12 scores had a key signature, every rest was hidden (0 of 1,626 visible), up to five voices were stacked on one staff, and 322 of 2,703 notes that belong to the key were spelled against it.

Switching to MuseScore Studio 4.7.5’s MIDI importer fixed most of that, once we prepared the MIDI: notes snapped to a sixteenth-note grid, and a key estimated from the notes written into every note track. Without that step, MuseScore treats off-grid MIDI as a live performance and guesses the meter, tempo and key again. We also capped its import at two voices per staff and turned tuplets off. With those settings, 10 of 12 key signatures matched the dataset’s annotations (the other two were each a fifth away), 0 of 3,213 notes were spelled against the key, all 988 rests were visible, and no staff held more than two voices. The full before-and-after is in why MIDI imports look messy in MuseScore.

Why a MusicXML file can look different in another app

MusicXML carries the music well, but each program applies its own fonts, spacing and defaults, so layout and small details often shift on import. MuseScore Studio’s handbook says notes and instrumentation come across faithfully, yet some cleanup is usually needed to make an imported score look like the original. Its import options can keep the file’s page size, margins, staff size and breaks, though spacing and font differences mean the breaks may not fall in the same places. MakeMusic’s guide to moving from Finale to Dorico says much the same: musical content and basic layout such as page and staff size transfer well, while graphical adjustments to individual items usually don’t.

Our own round-trip check, on October 2, 2026, was small. MuseScore Studio 4.7.5’s command-line converter re-imported a three-note MusicXML sample of ours with identical pitches, positions and lengths, but it moved our transcriber credit into the composer position and dropped its role. We haven’t tested Sibelius or Dorico. Before you send a score on, open it in the app it’s going to and check the credits, the layout and anything you adjusted by hand.

What ScoreStarling exports, and why its MIDI and MusicXML differ

ScoreStarling exports both, and they disagree about timing on purpose: the MIDI keeps the performance, and the MusicXML keeps a version written to be read.

In our October 2 test of the one-instrument option, transcription started as MIDI from Basic Pitch at the supplied tempo. MuseScore Studio wrote the notation from a copy snapped to a sixteenth-note grid, in 4/4, with a key estimated from the notes, visible rests and at most two voices per staff. It also simplifies durations: on the 12 guitar recordings above, it wrote 26% of notes longer than the snapped performance, by up to three sixteenths, and never shorter. A player wants a clean dotted quarter; a producer wants the feel. So playback and the MIDI export keep your timing, while the MusicXML, the PDF and the page images show the written version. A pitch edit changes both files, and when you set a note’s written length, its MIDI note is resized from where it was played. Other tools draw the same line: Klangio offers both quantized and unquantized MIDI downloads for its Sing2Notes app (checked October 3, 2026).

What ScoreStarling lets you download, free or after unlocking:

The workspace’s Download menu gives MusicXML as .musicxml; .mxl and MEI come through an AI assistant. Transcribing one instrument or voice or solo piano (up to three a day together), importing and editing are free; a band uses credits. Numbered notation is also a read-only view in the workspace and the chat panel; edit in staff notation. Jianpu has notation-preservation limits. The MP3 and WAV are General MIDI renderings of the score, not stems separated from your recording. The specifications list the details.

Questions and answers

Does a MIDI file contain any sound?

No. It holds instructions: which key to play, when, how hard, and a program number for the instrument. The sound comes from whatever synthesizer or sample library plays the file, which is why the same MIDI file sounds different in different apps.

Why does my MIDI file open in 4/4 at 120 BPM?

The Standard MIDI Files specification asks every file to state its tempo and time signature, and tells programs to assume 4/4 at 120 beats per minute when a file doesn’t. Set the real tempo and meter before you judge the notation.

Can I convert a PDF back into MusicXML?

Only with optical music recognition (OMR), which reads the image of the page and infers the notation, so the result needs proofreading. If the original notation file or its MusicXML still exists, start from that instead.

Is MusicXML the same as a MuseScore or Sibelius file?

No. MuseScore Studio’s .mscz and Sibelius’s .sib are each program’s own format. MusicXML is the exchange format between programs; MuseScore Studio, for example, opens MusicXML, compressed MusicXML and MIDI files alongside its own.

Which file should I send to a choir or band?

A PDF for reading, with separate parts if each player only needs their own line. Add the MusicXML if someone will transpose, rearrange or edit the parts.

The short answer

A remote MCP server is an OAuth protected resource. Without a token, it answers 401 and points to its RFC 9728 metadata; the client follows that to the authorization server, registers, signs the person in with PKCE and the resource parameter, and returns with a bearer token issued for the server’s URL. We run this in production with Supabase Auth. Three details took the work: a 401 with a scope hint and no error code, a token hook that adds our audience and scope to Supabase’s tokens, and dynamic client registration, since our authorization server doesn’t offer client ID metadata documents.

Who does what when an MCP server uses OAuth?

The MCP server has the smallest job: it accepts or rejects bearer tokens. The MCP authorization specification (version 2025-11-25) makes it an OAuth 2.1 resource server and the assistant an OAuth client, and lets the authorization server, which signs the person in and issues tokens, be a separate service.

Ours is separate. Supabase Auth’s OAuth 2.1 server issues every token, our website supplies the sign-in and consent page, and the endpoint at https://mcp.scorestarling.com/mcp only verifies tokens. It runs Streamable HTTP without MCP sessions and checks the token on every request. ScoreStarling turns recordings into editable sheet music, and this endpoint is how assistants reach it; the setup guide shows the steps people follow.

What happens when an MCP client connects?

The client starts with only the URL. Two answers from our server, shown as of October 3, 2026, tell it where to sign in; six more steps get it a token. First, a request without a token gets a 401 whose WWW-Authenticate header names the metadata and the scopes to request:

$ curl -si -X POST https://mcp.scorestarling.com/mcp \
    -H 'content-type: application/json' \
    -H 'accept: application/json, text/event-stream' -d '{}'
HTTP/2 401
content-type: application/json
www-authenticate: Bearer resource_metadata="https://mcp.scorestarling.com/.well-known/oauth-protected-resource/mcp", scope="openid email profile"

{"error_description": "Authentication required"}

Second, the client fetches that metadata. RFC 9728 forms its address by inserting /.well-known/oauth-protected-resource between host and path, and requires resource to be identical to the URL the client is using, or the client must stop. Our Supabase project reference is replaced here:

{
  "resource": "https://mcp.scorestarling.com/mcp",
  "authorization_servers": ["https://<project-ref>.supabase.co/auth/v1"],
  "scopes_supported": ["openid", "email", "profile"],
  "bearer_methods_supported": ["header"]
}

The other six steps:

1. The client reads the authorization server’s metadata. Supabase’s issuer has a path, so RFC 8414 puts the well-known segment before it: https://<project-ref>.supabase.co/.well-known/oauth-authorization-server/auth/v1. The client checks that issuer matches exactly and that code_challenge_methods_supported lists S256; the MCP spec says to stop if that field is missing.

2. It posts its own metadata to the advertised registration_endpoint (dynamic client registration, RFC 7591) and gets a client_id. Our test client registers as a public client with no secret; Anthropic’s documentation says Claude does too.

3. It opens the browser at the authorization endpoint with a PKCE S256 challenge, the scope from the 401 and resource=https://mcp.scorestarling.com/mcp (RFC 8707). Supabase hands the browser to our consent page, which signs the person in if needed and asks them to approve or deny the client.

4. It exchanges the code with its PKCE verifier and the same resource, and gets an access token that lasts an hour plus a refresh token.

5. It sends Authorization: Bearer … on every MCP request. We check the signature against the issuer’s published keys, the issuer, audience, expiry and write scope, then that the account has not been turned off.

6. When the token expires, or we answer 401 with invalid_token, it refreshes, again with resource, and gets a new access token and refresh token.

Clients must send resource on the authorization and token requests even if the authorization server ignores it. Supabase’s OAuth flow documentation doesn’t mention the parameter (checked October 3, 2026). Supabase accepted it in all our live runs, and the audience in our tokens comes from a hook.

What should the 401 WWW-Authenticate header contain?

When no token was sent: where the metadata is, which scopes to ask for, and no error code. RFC 6750 §3.1 says a request without any authentication information should not get an error code. invalid_token is for a token that was sent and failed, and tells the client it may get a new one and retry. The MCP spec adds that the 401 should carry a scope hint, which clients must treat as the scopes to request.

We found our own server getting this wrong while writing our setup guide. In MCP Python SDK 1.30.0, RequireAuthMiddleware answers every unauthenticated request with error="invalid_token" and no scope, so a client that had never sent a token was told its token was invalid. A small ASGI middleware around the MCP route now rewrites only the SDK’s 401s; the SDK still decides who gets in, and its 403 insufficient_scope answer is untouched:

# No token, before the fix (the SDK's default; wrapped for reading)
WWW-Authenticate: Bearer error="invalid_token",
    error_description="Authentication required",
    resource_metadata="…/.well-known/oauth-protected-resource/mcp"

# No token, now
WWW-Authenticate: Bearer
    resource_metadata="…/.well-known/oauth-protected-resource/mcp",
    scope="openid email profile"

# Rejected token: expired, wrong audience, malformed or account turned off
WWW-Authenticate: Bearer error="invalid_token",
    error_description="Invalid or expired access token",
    resource_metadata="…/.well-known/oauth-protected-resource/mcp",
    scope="openid email profile"

The hint names openid email profile, the scopes Supabase can grant, matching scopes_supported. Our deployment check now fails if a no-token challenge carries an error code. The fix reached production on October 2, 2026, within four minutes of merging. Anthropic’s connector docs add two rules for Claude: sign-in starts only from a 401 (it ignores WWW-Authenticate on a 200), and it uses only the first entry in authorization_servers.

How do you get an MCP audience and scope into Supabase tokens?

With a custom access token hook. The MCP spec says a server must accept only tokens issued for it, which in practice means checking aud, and we wanted a write scope of our own; Supabase’s documentation says its OAuth server doesn’t support custom scopes (checked October 3, 2026). The hook is a Postgres function that Supabase Auth runs before issuing a token, and it can rewrite claims. Ours, slightly simplified from our migration:

create or replace function scorestarling.access_token_hook(event jsonb)
returns jsonb language plpgsql stable security invoker set search_path = '' as $$
declare claims jsonb := event->'claims';
begin
  -- Tokens issued to an OAuth client carry its client_id; website sessions don't.
  if coalesce(claims->>'client_id', '') <> '' then
    claims := jsonb_set(claims, '{aud}', '"https://mcp.scorestarling.com/mcp"');
    claims := jsonb_set(claims, '{scope}', '"openid email profile scorestarling:write"');
  end if;
  return jsonb_build_object('claims', claims);
end;
$$;
grant usage on schema scorestarling to supabase_auth_admin;
grant execute on function scorestarling.access_token_hook(jsonb) to supabase_auth_admin;
revoke all on function scorestarling.access_token_hook(jsonb) from public, anon, authenticated;

The MCP side checks those claims with PyJWT, then applies two rules of its own:

claims = jwt.decode(token, key, algorithms=["RS256", "ES256"],
                    issuer=ISSUER, audience=ACCEPTED_AUDIENCES,
                    options={"require": ["exp", "iat", "iss", "aud", "sub"]})
if "scorestarling:write" not in claims.get("scope", "").split():
    return None  # the client gets 401 invalid_token
# then: has this account been turned off?

ACCEPTED_AUDIENCES is the MCP URL, plus the old one during a move. The client-ID test keeps the website’s own sign-in out: a browser session token from the same Supabase project has the same issuer and keys but no client_id, so it never gets the MCP audience.

The hook has two costs. It stamps one fixed audience rather than following the client’s resource, which works while one authorization server serves one MCP server. And our consent page can only show the scopes the client asked for, so approving the client is what grants the write scope.

An open report, supabase/auth#2820 (opened September 20, 2026; no replies by October 3), says Supabase’s authorization-details request returns 400 for public clients, offline_access or resource. None of these reproduced for us; in the Supabase Auth source we reviewed, that 400 appears only for an authorization that is no longer pending, such as one fetched twice.

Dynamic client registration or client ID metadata documents?

Use what your authorization server advertises; with Supabase today, that is dynamic client registration (DCR). The 2025-11-25 MCP spec recommends client ID metadata documents (CIMD) when client and server have never met, and keeps DCR for backwards compatibility. Clients should try a client ID given in advance first, then CIMD, then DCR, and only then ask the person.

Supabase’s metadata, read again on October 3, 2026, lists a registration endpoint, S256 and the none token-endpoint method, and no CIMD flag; its MCP guide has you switch dynamic registration on in the dashboard.

That decides what people pick in Claude’s custom-connector form. Anthropic’s documentation describes the recommended option, Claude’s published identity, as a CIMD that Anthropic hosts and the server must support. So our guide asks for Sign in now, since none of our tools works without an account, and Register automatically. Anthropic’s developer docs say Claude falls back to DCR when CIMD isn’t advertised (CIMD also needs none in token_endpoint_auth_methods_supported); we haven’t tested the form with its default left in place, so we ask for the explicit choice. The client docs we read on October 2, 2026 describe DCR for ChatGPT developer mode, Cursor, VS Code and Gemini CLI.

DCR has a cost: Anthropic notes that Claude registers a new client on every fresh connection, and Supabase warns that dynamic registration lets any MCP client register with your project. Registering grants nothing on its own, though. A person still has to sign in and approve the client, and the verifier checks the account on every request. Because any client can register under any name, our consent page has shown since October 6, 2026 where approving sends the person, and it warns when an app calls itself ChatGPT or Claude but doesn’t return to that assistant’s address.

Do MCP clients stay signed in after the access token expires?

Yes. Access tokens last an hour, and clients renew them with refresh tokens. Before relying on that, we read Supabase Auth’s source (master as of September 22, 2026):

• every code exchange returns a refresh token, with or without offline_access;
• a refresh must come from the session’s own client, rotates the refresh token and keeps the client_id claim;
• the hook runs on refreshes too (authentication_method is token_refresh), so our audience and scope come back each time.

A live run on October 2, 2026 matched: the refresh token rotated, and the renewed access token worked. Anthropic’s docs say Claude refreshes after a 401 and up to five minutes before expiry, and adds offline_access when the authorization server lists it in scopes_supported. Supabase’s metadata lists it, and our check that also requested offline_access passed.

Sessions still end when:

• the account is turned off, or the user is deleted or banned (in our live run, turning the account off rejected the browser session and both MCP tokens);
• an old refresh token is reused after Supabase’s reuse interval, 10 seconds by default, which revokes the whole session;
• a time-box, an inactivity timeout or “single session per user” is turned on. Keep the last one off, or a website sign-in ends the assistant’s session;
• the person signs out of the website with Supabase’s default logout, which ends every session of the account, the assistant’s included. Ours did until October 6, 2026, the likely reason one ChatGPT connection could no longer renew its token; Sign out now sends scope=local and ends only that browser’s session.

Supabase advertises no revocation endpoint (checked October 3, 2026), so turning the account off is how we cut off access.

Why does a trailing slash in the issuer matter?

Because issuers are compared character for character. RFC 8414 requires the issuer in the metadata to be identical to the one the client used to find it, and RFC 9728 asks the same of resource. To a strict client, https://auth.example.com and https://auth.example.com/ are different issuers.

The MCP Python SDK stores the issuer as a pydantic AnyHttpUrl, and pydantic 2.13.5, the version in our lockfile, turns https://auth.example.com into https://auth.example.com/. Metadata built from that names an issuer the authorization server never published, so our server writes its own protected resource metadata with the issuer exactly as configured. Supabase’s issuer ends in a path, which pydantic leaves alone, so this never hit us in production; it would with a bare-origin issuer. Our deployment check fails unless the authorization server’s issuer matches ours exactly.

What we’ve verified, and what we haven’t

Our first evidence came from a scripted client that follows the MCP spec. On October 2, 2026, one run against production covered the no-token 401, dynamic registration of a public client, consent and code exchange with resource, a refresh with rotation, tools/list with both tokens, and turning the account off, which rejected both tokens and the browser session. A second run also requested offline_access, and both passed. That run used our earlier address; the move to mcp.scorestarling.com has its own article.

Real clients have connected since. ChatGPT’s developer-mode app signed in through mcp.scorestarling.com and called a tool on October 3, 2026, and Claude connected and ran tools on October 6. Not verified yet:

• a refresh after a token has really expired: the scripted refresh ran right after sign-in, and we haven’t traced one from a real client;
• Supabase’s hosted session settings, which we haven’t read back.

Questions and answers

Does a remote MCP server need its own authorization server?

No. The MCP authorization spec lets the authorization server be a separate service. The MCP server publishes RFC 9728 metadata that names it, then validates the tokens it issues, including their audience. Ours points to Supabase Auth and only verifies tokens.

Should an MCP server’s 401 include the invalid_token error when no token was sent?

No. RFC 6750 §3.1 says a request without credentials should get no error code. Send resource_metadata and a scope hint instead, and keep invalid_token for a token that was sent and rejected, where it tells the client to refresh.

Can Supabase Auth issue custom scopes for an MCP server?

Not as of October 3, 2026: Supabase’s OAuth 2.1 documentation says custom scopes aren’t supported. We request openid email profile and add our own scope and the MCP audience in a custom access token hook, which also runs on every refresh.

What should people choose in Claude’s custom connector form if the server doesn’t support CIMD?

Register automatically under OAuth client, which uses dynamic client registration, and Sign in now under Authentication if every tool needs an account. Claude’s recommended published identity is a client ID metadata document, and the server must support it. Our Claude steps show both choices.

Do I need the offline_access scope to get refresh tokens from Supabase?

Not in our tests. Supabase returned a refresh token on every code exchange without it, in its source and in live runs on October 2, 2026. Some clients ask for it anyway; Anthropic’s docs say Claude does when the authorization server lists it, and our check with it passed too.

The short answer

Most remote MCP servers we checked have a host of their own. On October 2, 2026, 14 of the 22 services whose endpoint asked for sign-in used mcp.<domain>/mcp, six more used an mcp. host with no path or a versioned one, and two used an api. host. No address is standard and paths can’t be guessed, so publish the exact URL. We moved ours from scorestarling.com/mcp to https://mcp.scorestarling.com/mcp so that the website’s /mcp could become the setup guide for people.

What URLs do public MCP servers use?

Mostly a dedicated mcp. subdomain, usually with /mcp as the path. We went looking while choosing between mcp.scorestarling.com/mcp and api.scorestarling.com/v1/mcp, the form ElevenLabs uses, because we wanted to know what other services actually do.

On October 2, 2026, between 17:40 and 17:42 UTC, we sent one unauthenticated POST to each of 33 addresses from 27 services, with {} as the body, an Accept: application/json, text/event-stream header and an 8-second timeout, and recorded only the status code. A 401 means something at that address answered and wants a token, which is how a protected MCP server starts sign-in. A 404 means nothing is served at that path. Some addresses were published by the services; others were variants and guesses we tried to see which paths answer. It’s a snapshot of well-known services, not a census, and any of these may have changed since.

The 404s carry the practical lesson: an MCP URL can’t be derived from a domain. Stripe and Vercel answer at the bare host and return 404 at /mcp; Higgsfield is the other way round; ElevenLabs needs its /v1. A client uses exactly the URL it is given, and RFC 9728 makes that URL the identity the server’s metadata must match, so the same string has to appear in your docs, install links and plugin manifests. Manifests show still more variety: among the plugins we had installed were gitlab.com/api/v4/mcp, a path on gitlab.com itself, and mcp.hubspot.com/anthropic. We didn’t probe those two.

Should the MCP endpoint share a host with your website?

We don’t think so. The endpoint is for software and the setup page is for people, and both want the obvious address. Until October 2, 2026, scorestarling.com/mcp was our MCP server, so the guide had to live somewhere else; and since that URL’s 401 is how every client discovers sign-in, it couldn’t also be a web page.

We considered serving both at one URL, a page to browsers and MCP to clients, and rejected it as a permanent setup: one wrong guess about a request breaks sign-in discovery for every client. The transport spec also lets clients send GET to the endpoint to open an event stream, and expects either that stream or a 405 in reply, not an HTML page.

A separate host also keeps website changes away from the endpoint: a redesign can’t move it, and a CDN cache or browser challenge that suits a marketing site never sits in front of it. Assistants call the server from their own infrastructure, not from a browser: Anthropic’s connector docs say Claude connects from Anthropic’s cloud, and that a firewall in front of the identity provider can break sign-in. Two peers we looked at split the same way (checked October 2 and again October 3, 2026): Higgsfield’s guide is at higgsfield.ai/mcp and its server at mcp.higgsfield.ai/mcp; ElevenLabs’ guide is at elevenlabs.io/mcp and its server at api.elevenlabs.io/v1/mcp.

Our MCP host serves only /mcp and /.well-known/*. Every other path gets a 308 to the same path and query on the website, so sign-in, consent, pages, download links and cookies stay on one host. The website’s /mcp is now the setup guide for Claude, ChatGPT and other clients.

$ curl -si "https://mcp.scorestarling.com/login?x=1"
HTTP/2 308
location: https://scorestarling.com/login?x=1

mcp.example.com/mcp, a bare host, or api.example.com/v1/mcp?

Any of them works; choose by what else lives on the host. The MCP authorization spec lists https://mcp.example.com/mcp and https://mcp.example.com among valid canonical server URIs and asks for the form without a trailing slash unless the slash matters. The transport spec only requires one endpoint path that accepts POST and GET, with https://example.com/mcp as its example, and Anthropic’s connector docs use https://mcp.example.com/mcp.

Two smaller rules. Don’t end a Streamable HTTP endpoint in /sse: Anthropic’s docs say a URL ending that way selects the older SSE transport in Claude’s connector form. And leave off the trailing slash unless you mean it; of the 23 addresses that answered 401, only GitHub’s was written with one.

How do you move an MCP server to a new URL?

Serve both addresses for a while, and make each one complete on its own: its own 401, its own metadata, and tokens for either audience. We moved in four steps, all live within an hour on the evening of October 2, 2026 (UTC):

1. Ship alias support while nothing uses it. One setting lists earlier addresses, each HTTPS and ending in /mcp. A token verifies if its audience is the current address or an alias; any other audience is refused. The host allow-lists (Starlette’s trusted hosts and the MCP SDK’s DNS-rebinding protection) hold every address plus the website. With no alias set, production behaved as before.

2. Add the host, then switch the address and set the alias in one change. The new subdomain got its DNS records, the certificate followed about six minutes later, and the host answered 400 until our server was told to trust it. One configuration change set the new resource URL and listed the old one as an alias, so a single redeploy picked up both. Doing this before step 1 was live would have made the running code refuse the website’s own host.

3. Repoint everything people copy: the setup guide, including the encoded one-click install links for Claude, Cursor and VS Code, the plugin manifests and the docs.

4. Switch the token audience, then retire the old address. A migration made our access-token hook issue the new audience, and CI applied it before the code shipped; while the alias stood, tokens with either audience still worked. Then we removed the alias and redeployed. For the few minutes between that release and the redeploy, the website’s /mcp sent browsers the guide and MCP clients the server. It now serves only the guide, and the guide’s old address, /connect, answers with a 308 to it.

The metadata is the easy part to miss. RFC 9728 requires its resource to be identical to the URL the client connected to, and Anthropic’s docs require it to equal the URL as typed into Claude. So during the overlap each host described itself, and each 401 pointed to its own host’s document:

GET https://scorestarling.com/.well-known/oauth-protected-resource/mcp
→ "resource": "https://scorestarling.com/mcp"

GET https://mcp.scorestarling.com/.well-known/oauth-protected-resource/mcp
→ "resource": "https://mcp.scorestarling.com/mcp"

We didn’t redirect /mcp itself. The transport spec doesn’t describe redirects for the endpoint, and its URL is part of the OAuth handshake as the resource and the token audience, so we served MCP at both addresses instead. For every other path, a 308 rather than a 301 keeps the method, since RFC 9110 doesn’t let a client turn a POST into a GET after a 308. How the audience gets into our tokens is in our notes on MCP OAuth.

We could move that fast because ScoreStarling was still a small invite-only pilot, and nobody relied on the old address yet. Once the alias is gone, a client still configured with scorestarling.com/mcp has to reconnect. Our runbook expects a client already on the new address but holding an old-audience token to get one 401 invalid_token, refresh, and receive the new audience; we haven’t watched a real Claude or ChatGPT client do that. With real users, keep the alias until traffic to the old address stops.

What broke during the move?

Three small things went wrong along the way:

• A check script built the metadata URL with resource.replace('/mcp', '/.well-known/oauth-protected-resource/mcp'). On the old address that worked. On https://mcp.scorestarling.com/mcp, /mcp also matches inside //mcp., and the result was https://.well-known/oauth-protected-resource/mcp.scorestarling.com/.well-known/oauth-protected-resource/mcp. Build the URL from its parsed parts instead: scheme and host, then the well-known segment, then the path.
• The longer address overflowed our guide on a 320-pixel-wide screen until inline code was allowed to wrap.
• Deleting the alias variable with Railway’s command-line tool only staged the change; the old address stayed accepted until we redeployed by hand.

A checklist for choosing an MCP server address

• Give the endpoint a host that serves nothing for people; mcp. plus your domain is the common choice in our sample.
• Pick a path once. /mcp is the most common and a bare host is also valid; avoid a trailing slash and a path ending in /sse.
• Keep the setup page for people on your main site, at an address they can guess, and link it from your navigation.
• Serve RFC 9728 metadata for the exact URL, at /.well-known/oauth-protected-resource plus your path and at the root, with resource equal to the address the client used.
• Make that URL the token audience, and build alias support before you need to move.
• Redirect every other path on the MCP host to your website with a 308, keeping the query string.
• Keep browser challenges and HTML caching away from the MCP host.
• Publish one string everywhere (guide, install links, plugin manifests, docs) and test that every copy matches.
• To move: aliases first, then the new address and the alias in one change, every copy repointed, the audience switched, and the old address retired after its traffic stops.

Questions and answers

Does an MCP server URL have to end in /mcp?

No. The MCP spec requires a single endpoint path and lists both https://mcp.example.com and https://mcp.example.com/mcp as valid server URIs. In our October 2, 2026 sample, 18 of the 22 services that asked for sign-in used a path such as /mcp or /v1/mcp, and 4 answered at the bare host. Pick one and publish it exactly.

Can the setup page and the MCP endpoint share one URL?

You can send browsers a page and MCP clients the server at one URL, but we decided against it apart from a few minutes during our move. One misjudged request breaks sign-in discovery, and Streamable HTTP clients may send GET to the endpoint expecting an event stream or a 405. Our guide is at scorestarling.com/mcp and the server has its own host.

Will changing an MCP server URL disconnect users?

Only when you retire the old address. The URL is the OAuth resource and the token audience, so a client configured with the old one has to reconnect once it stops answering. Serve both for a while: accept both audiences, give each address its own metadata, and retire the old one after its traffic stops.

What does a 401, 404 or 400 mean when I POST to an MCP URL?

In our survey, a 401 meant a protected endpoint answered and asked for a token, and a 404 meant nothing was served at that path. A 400 only says something rejected our empty test body; we didn’t interpret those further. To test a server properly, connect with a real MCP client.

Should an MCP server URL end with a slash?

Preferably not. The MCP authorization spec asks implementations to use the form without a trailing slash unless the slash is significant. Of the 23 addresses that answered 401 in our survey, only GitHub’s, api.githubcopilot.com/mcp/, was written with one.

The short answer

On May 27, 1784, Mozart paid 34 kreuzer for a starling that could sing the opening of the finale of his Piano Concerto No. 17 in G major, K. 453, which he had entered in his catalogue of works about six weeks earlier. In his account book he wrote out the bird’s version, which pauses on one note and sings G sharp where the concerto has G, and added “Das war schön!” (“That was beautiful!”). The bird lived with him for three years; when it died on June 4, 1787, he buried it in the garden and wrote it a comic poem.

The 1784 purchase and the account-book entry

Mozart bought the starling in Vienna on May 27, 1784, and the first record of the bird is the entry he made that day in his account book, also called his expense book. He had started it that year, at the same time as the catalogue of his works. According to Wikipedia, which cites Hermann Abert’s biography, he kept the expense book for only about a year, while the catalogue ran until his death in 1791.

The Neue Mozart-Ausgabe (NMA), the scholarly edition of Mozart’s complete works that the Mozarteum Foundation publishes online, reproduces the entry in the preface to the volume that contains K. 453. It is short. Across the top run the date, “Vogel Stahrl” (starling bird) and “34 Kr.” Below is a single staff of music in G major and cut time. Under the staff Mozart wrote “Das war schön!”

“Kr.” stands for kreuzer, a coin of the day; sixty made a gulden. The NMA’s English translation prints “34 Crowns” and “That was nice!”, while Wikipedia, which cites Otto Erich Deutsch’s documentary biography for the German text, reads kreuzer and gives “That was beautiful!”, as our homepage does. The editors of that NMA volume, Eva and Paul Badura-Skoda, say Mozart had apparently enjoyed hearing the bird whistle the theme of the concerto’s last movement and bought it for that reason, “even if the intonation may not have been quite clean.”

The tune: the finale theme of K. 453, bar by bar

The bird sang the first phrase of the theme that opens the concerto’s finale, an upbeat and four bars, with two changes: it paused on the G at the end of the first full bar, and it sang G sharp instead of G in the next bar. Mozart’s entry keeps both.

Mozart wrote the concerto for his pupil Barbara (Babette) Ployer and entered it in his catalogue on April 12, 1784. Its finale, an Allegretto in cut time, is a set of variations on a plain, singable theme and ends with a Presto. The table sets the start of that theme beside the line in the account book.

Pitches follow Wikipedia’s transcription of the entry, which cites Deutsch, and its corrected version of the tune, which follows the musicologist Daniel Heartz. We checked both against the NMA: its reproduction of the entry shows the fermata and the sharp, and its score of the finale (page 46 of the volume) has neither. The concerto also has grace notes, staccato dots and a slur that the account-book line leaves out.

Read as a transcription, the entry is careful work. Mozart knew exactly how his tune went, and he still wrote the pause and the sharp where he heard them instead of tidying them away. The line records the performance, not the composition.

How did the bird know a six-week-old tune?

Nobody knows. The documents record the purchase, not how the bird learned the tune, and the main accounts tell the story in different orders:

• The NMA preface says Mozart heard the bird whistle the theme and bought it because of that.
• Wikipedia’s article on the common starling, citing the book Birds Britannica (2005), says he bought it from a shop after hearing it sing a phrase from a work he had written six weeks earlier and that had not yet been performed in public.
• Wikipedia’s article on Mozart’s starling suggests the reverse order: presumably Mozart taught the bird the tune in the shop, or wherever he bought it.

“Not yet performed in public” is uncertain too. In a letter of June 12, 1784, quoted in the NMA preface, Mozart tells his father that Babette Ployer will play her new concerto in G the next day at a musical evening at the Ployers’ house in Döbling. The musicologist Michael Lorenz has argued that Mozart may have played it earlier, at his concert with the violinist Regina Strinasacchi at the Kärntnertortheater on April 29, 1784, as Wikipedia’s article on the concerto summarizes him. If so, the tune had been heard in public four weeks before Mozart bought the bird.

Starlings can learn quickly: Wikipedia’s starling article notes that a wild starling has been seen to copy a sound it heard only once. To us, the simplest explanation is a composer whistling his newest tune in a bird shop. Nothing in the documents shows that it happened.

Why starlings are such good mimics

Common starlings (Sturnus vulgaris) are vocal learners that build borrowed sounds into their own song, so a pet starling picking up a whistled melody is ordinary behavior for the species. A male’s song bout can run a minute or more: pure whistles, then variable sequences that take in snatches of other birds’ songs and other noises, then clicks and a final burst of high song. Practiced birds have up to 35 variable song types, according to Chris Feare’s 1996 account of the species in British Birds, which Wikipedia cites.

In their essay on vocal copying, Paul Ehrlich, David Dobkin and Darryl Wheye name the European starling as a species whose vocal mimicry is well known. Their explanation is repertoire size: a large, varied song can help a male attract a mate and intimidate rivals, and borrowing from the surroundings, even dog barks, machinery or human whistling, is one way to grow it. They add that mimics usually give themselves away through their own tone, timing or context, so listeners are rarely fooled.

Pet starlings pick up human phrases readily. Konrad Lorenz, as cited on Wikipedia, noted that since the words mean nothing to the bird, it mixes them up and uses them at odd moments. Meredith West and Andrew King, two researchers with long experience of pet starlings, linked the birds’ mimicry to their lively social interactions.

Their anatomy helps. A 2025 study in Scientific Reports analyzed 115 videos, posted online, of birds imitating the robot R2-D2 from Star Wars; eight were of starlings. The starlings copied the robot’s complex, multi-tone sounds more accurately than the parrots did, and the two groups did equally well on simple beeps. The authors put the difference down to the syrinx, the bird’s voice organ: a starling controls its two sides independently, so it can make two sounds at once, and a parrot can’t.

Starlings also seem to hear tunes differently from us. In a 2016 study in PNAS, five starlings learned to tell apart four-tone sequences that rose or fell in pitch. When the sequences were shifted slightly up or down, or played with a different timbre, the birds did no better than chance. They recognized versions that kept each tone’s spectral shape, meaning how its energy is spread across frequencies, far more readily, even with the pitch removed. A musician hears a melody as intervals that survive transposition; a starling seems to hear something closer to a string of sound shapes. That may be part of why a starling’s copy of a tune comes out close but not exact. This is our reading, not something anyone measured on Mozart’s bird.

June 1787: the starling’s funeral and Mozart’s poem

The starling died on June 4, 1787, about three years after Mozart bought it, and he buried it in the garden with some ceremony and a poem he wrote for it. It was a hard season. His father, Leopold Mozart, had died in Salzburg on May 28, a week earlier.

The funeral reaches us secondhand, mostly through Mozart’s early biographers, and the accounts differ:

• Franz Xaver Niemetschek, who interviewed Mozart’s widow, Constanze, mentions a much-loved starling that Mozart gave a proper gravestone, with an inscription, in the garden he rented.
• Georg Nikolaus Nissen, Constanze’s second husband, tells it the same way in his 1828 biography: on the death of a beloved starling Mozart wrote verses and put up a proper grave with an epitaph in his rented garden (page 668), and he loved animals, especially birds (page 670). The procession comes from elsewhere: Nissen’s collected notes, which Rudolf von Lewicki printed in the Mozarteums-Mitteilungen in November 1919. There Nissen writes that Mozart loved dogs and birds and always kept some, that his dog was called Puzzipaukel, and that when a bird died he arranged a funeral procession in which everyone who could sing had to follow in great veils, with a sort of requiem and an epitaph in verse (page 29). The note says “a bird” without naming the starling; Otto Erich Deutsch quotes it in English on page 225 of his documentary biography.
• West and King’s 1990 article in American Scientist, as summarized on RILM’s blog, has veiled mourners marching in procession, singing hymns and hearing the poem recited at the graveside.

The poem is dated June 4, 1787. It opens “Hier ruht ein lieber Narr, / Ein Vogel Staar” (“Here rests a dear fool, a starling”; our translation). It mourns a bird taken in his best years, insists he was not bad, only rather lively and at times a lovable rascal, and ends with a joke about its own author: dying, the bird spared no thought for the man “der so schön reimen kann,” who rhymes so beautifully. It is the same word, schön, that Mozart had written under the bird’s tune three years before.

Robert Spaethling, who translated the poem into English, reads it as funny and bittersweet, written while Mozart was grieving and deep in work on Don Giovanni. The folklorist Wolfgang Mieder has suggested that Mozart was partly writing about himself. West and King point out how closely pet starlings bond with their keepers, which makes the grief behind the comedy easy to believe.

Did the starling influence Mozart’s music?

It did not shape the concerto, which Mozart had finished six weeks before he bought the bird, and the idea that it shaped a later piece, A Musical Joke (Ein musikalischer Spaß, K. 522), is a hypothesis with no document behind it. Lyanda Lynn Haupt, a naturalist and the author of the 2017 book Mozart’s Starling, told NPR that the dates rule out the theory that the bird inspired the concerto.

The case for the later piece was made by West and King. In their 1990 article they wrote that many elements of A Musical Joke “bear the vocal autograph of a starling.” The timing is suggestive: Mozart entered the piece in his catalogue on June 14, 1787, ten days after the bird died. Haupt made a similar case to NPR; laid over starling song, the piece’s oddest passages show, in her words, the same “fractured phrases” and playfulness.

Treat it as a hypothesis. Wikipedia notes that West and King based the idea on the description of the piece in a record sleeve note. Many commentators hear A Musical Joke as a parody of clumsy composers, and Mozart is not known to have said what he meant by it. None of the sources we read cites a letter or note of his that connects the piece to the bird. The only documented musical link between Mozart and his starling that we know of is the account-book entry of May 27, 1784.

Why we named ScoreStarling after it

We named the product after the bird because its story is the job we do. In one line: a bird sang, and a composer wrote down what he heard. The name is Score plus Starling, and our logo is a starling whose raised wing forms the flag of a note. The less famous detail matters to us as much. Mozart’s line is a faithful record of what he heard, and what he heard was not quite what he had written. A transcription is a first draft, and you finish it by ear.

ScoreStarling listens to a recording and writes it out as MIDI and an editable score. Play it beside the recording, loop a passage, correct the notes and export. It also reads printed sheet music, score files and ABC or MusicXML text, and shows the score on a staff, as guitar TAB or as jianpu. Transcribing one instrument, a voice or solo piano and editing are free; a band and unlocking a score’s MusicXML and MIDI use credits. Every account gets 100 free credits a month, and the specifications have the rest. Our accuracy article says what we measured and on which recordings.

Questions and answers

What piece did Mozart’s starling sing?

The opening phrase of the theme of the finale (Allegretto) of Mozart’s Piano Concerto No. 17 in G major, K. 453. Mozart had entered the concerto in his catalogue on April 12, 1784. When he bought the bird on May 27, he wrote its version in his account book: the same upbeat and four bars, with a pause on the G at the end of bar 1 and G sharp in place of G in bar 2.

What does “Das war schön” mean in Mozart’s notebook?

It means “That was beautiful,” or “That was lovely”; the English translation of the Neue Mozart-Ausgabe preface has “That was nice!” Mozart wrote it under the starling’s version of his tune, in the account book where he recorded the bird (“Vogel Stahrl”) and its price, 34 kreuzer, on May 27, 1784.

What happened to Mozart’s starling?

It lived in Mozart’s household for about three years and died on June 4, 1787, a week after his father, Leopold. Mozart buried it in his garden and wrote a comic poem for it, dated that day, that begins “Hier ruht ein lieber Narr, / Ein Vogel Staar” (“Here rests a dear fool, a starling”). His early biographer Georg Nikolaus Nissen wrote that Mozart built the beloved starling a proper grave with an epitaph in his rented garden and loved animals, especially birds; the veiled mourners come from his private notes, first printed in 1919, not from that book.

Can starlings really copy music?

Yes. Common starlings are vocal mimics that work other birds’ songs and other sounds into their own song, and pet starlings pick up words and tunes from the people around them. They copy closely, not perfectly: Mozart’s bird added a pause and sang G sharp for G, and a 2016 lab study found that starlings recognize tone sequences by their spectral shape rather than by pitch.