Claude + Suno + Spotify：构建年入 10 万美元自动化音乐业务的详细分步指南

AI tools like Suno let you put out release-ready tracks without a studio or a music background, and on a paid plan all the rights to that music are yours -> you can monetize it through streaming.

The income isn't instant and depends on real listeners, but as a repeatable process, make a release → put it out → promote it, the workflow works and scales. Below is a detailed setup for each tool.

What you'll need

• Suno, a paid plan (Pro or Premier, from $10/mo) -> to generate music with commercial rights.
• A distributor (DistroKid, Amuse, Soundrop, etc.) -> to deliver your tracks to Spotify and other platforms.
• Spotify for Artists -> FREE, for stats and promotion.
• Claude / Claude Code -> to automate the busywork, write copy, and analyze stats. Claude Code requires a paid Claude plan (Pro or higher) or API billing.

Step 1. Set up Suno

1.1. Subscription. Get Pro or Premier -> both plans grant a commercial license for songs created while subscribed: you can distribute them to streaming services and earn money, and Suno takes no cut. Premier gives you more generations per month -> pick based on how many tracks you plan to release.

1.2. Custom Mode. Turn on Custom Mode -> it gives you control over three fields: Style (a description of the sound), Lyrics (the words or structure tags), and Title. Simple mode is handy for experiments, but releases need Custom.

1.3. Style prompt. Describe the sound concretely: genre and subgenre, mood, instruments, tempo (BPM), vocal type or an "instrumental" note, and production character. Don't name real artists -> Suno filters that out, and it's risky for a commercial release.

Example:

lo-fi hip-hop, mellow and nostalgic, warm vinyl crackle, soft Rhodes piano, lazy boom-bap drums, 75 BPM, instrumental, late-night study vibe

1.4. Structure with tags. In the Lyrics field, control the shape of the track with bracketed tags:

1[Intro]
2[Verse]
3...verse lyrics...
4[Pre-Chorus]
5[Chorus]
6...chorus lyrics...
7[Bridge]
8[Instrumental]
9[Outro]

For an instrumental, leave just the section tags with no words.

1.5. Lyrics. Write your own lyrics or ask Claude for a draft, then revise them yourself -> original lyrics and live vocals lift a track above the "generic AI sound" and help it pass moderation.

1.6. Generating and refining. Each request returns several variations -> pick the best. From there: Extend to lengthen the track, Replace Section to regenerate a specific part, and re-roll if you don't like the result. Assemble a final version of the length you want (2.5–3.5 minutes is a comfortable streaming format).

1.7. Export. Download as WAV (or a high-bitrate MP3). If your plan supports stem export, pull the stems -> that way you can balance the vocals and instrumental separately when mixing.

1.8. Final processing. Run the track through mastering (an online service or a DAW) and bring the loudness to roughly −14 LUFS -> that's the reference Spotify normalizes to, so your track sits at the same level as the rest in a playlist.

1.9. Cover art. Square, at least 3000×3000 px, JPEG or PNG, with no third-party logos or protected images. You can generate the cover in any AI image generator.

Step 2. Set up Claude

Claude handles everything around the music except the music itself: metadata, copy, file organization, and stats analysis.

2.1. Which one to use. If you're not a programmer, use the Claude app (just a chat). If you're comfortable in a terminal, use Claude Code: an agentic tool that reads your files, writes scripts, and runs them on your computer.

2.2. Installing Claude Code. You'll need a paid Claude plan (Pro or higher) or API billing. Two methods (per the official docs):

1# Method 1 — native installer (recommended, no dependencies), macOS/Linux:
2curl -fsSL https://claude.ai/install.sh | bash
3
4# Method 2 — via npm (requires Node.js 18+), without sudo:
5npm install -g @anthropic-ai/claude-code

For Windows there's the same native installer plus a desktop app (macOS/Windows) -> if you'd rather skip the terminal entirely. After installing, verify it and sign in via the browser on first launch:

1claude --version   # should print a version
2claude doctor      # diagnoses your environment if something's off

2.3. Launching. Go to your release folder and start Claude Code — then give it tasks in plain language:

1cd "releases/My Artist - Midnight Lofi"
2claude

2.4. Bulk metadata generation. Give Claude a list of tracks and ask it to format everything in a consistent style.

Example prompt:

Here's a list of 12 instrumental lo-fi tracks. For each one, come up with: a title, a short description (up to 150 characters), 5 genre tags, and 5 mood tags. Return it as a CSV table with columns filename, title, description, genres, moods.

2.5. Organizing release files. Ask Claude Code to run this script -> it gathers the tracks into one structure with consistent naming:

1# organize_release.py — arranges release tracks into a consistent template
2from pathlib import Path
3import shutil
4
5ARTIST  = "My Artist"
6RELEASE = "Midnight Lofi"        # release/album name
7SRC = Path("downloads")          # folder with tracks downloaded from Suno
8DST = Path("releases") / f"{ARTIST} - {RELEASE}"
9DST.mkdir(parents=True, exist_ok=True)
10
11audio = sorted(SRC.glob("*.wav")) + sorted(SRC.glob("*.mp3"))
12for i, f in enumerate(audio, start=1):
13    new_name = f"{i:02d} - {ARTIST} - {RELEASE}{f.suffix.lower()}"
14    shutil.copy2(f, DST / new_name)
15    print("OK:", new_name)
16
17print(f"\nDone: {len(audio)} tracks in {DST}")

2.6. Metadata sheet for the distributor. This script builds a CSV table from the release files; you can then ask Claude to fill in the blank fields:

1# make_metadata_sheet.py — creates a release metadata template
2import csv
3from pathlib import Path
4
5ARTIST = "My Artist"
6DST    = Path("releases/My Artist - Midnight Lofi")
7
8rows = []
9for f in sorted(DST.glob("*.wav")) + sorted(DST.glob("*.mp3")):
10    rows.append({
11        "file": f.name,
12        "title": "",            # fill in, or ask Claude
13        "artist": ARTIST,
14        "genre": "",
15        "language": "Instrumental",
16        "explicit": "no",
17        "isrc": "",             # the distributor assigns this automatically
18    })
19
20with open("metadata.csv", "w", newline="", encoding="utf-8") as out:
21    w = csv.DictWriter(out, fieldnames=rows[0].keys())
22    w.writeheader()
23    w.writerows(rows)
24
25print(f"Created metadata.csv for {len(rows)} tracks")

2.7. Stats and revenue analysis. Export a CSV from Spotify for Artists or your distributor's dashboard and run it through this script -> it shows what's growing and how much it earns:

1# stream_report.py — a summary of plays from a CSV
2import pandas as pd
3
4RATE = 0.004                     # approximate Spotify per-stream rate, $
5df = pd.read_csv("streams.csv")
6
7track_col  = "Track"             # adjust to match the column names in your export
8stream_col = "Streams"
9
10df[stream_col] = pd.to_numeric(df[stream_col], errors="coerce").fillna(0)
11df["est_$"] = (df[stream_col] * RATE).round(2)
12
13total = int(df[stream_col].sum())
14print(f"Total streams: {total:,}")
15print(f"Estimated revenue: ${total * RATE:,.2f}\n")
16
17print("Top 10 tracks:")
18top = df.sort_values(stream_col, ascending=False).head(10)
19print(top[[track_col, stream_col, "est_$"]].to_string(index=False))
20
21# a track only starts earning royalties after 1,000 streams in 12 months
22above = int((df[stream_col] >= 1000).sum())
23print(f"\nAbove the monetization threshold (1,000): {above} of {len(df)} tracks")

2.8. Promo copy. Ask Claude to write your profile bio, a release description, a pitch email to a playlist editor, and social posts for the announcement -> all in a consistent voice and tailored to your niche.

Step 3. Set up Spotify

3.1. Choosing a distributor. Compare on three points: the payment model (a flat annual fee vs. a percentage of royalties), whether the service accepts AI music (many have tightened their rules), and whether it collects songwriting/publishing royalties on your behalf. Sign up and verify your account.

3.2. Uploading a release. Create a release and upload the audio + cover art. Fill in the metadata: track title, primary and featured artists, genre, language, the explicit flag, and writers/composers. Set the release date 3–4 weeks out -> you'll need this for the next step. The distributor generates the ISRC and UPC automatically.

3.3. Spotify for Artists. After submitting the release (or as soon as the profile appears), claim your artist profile and confirm access -> either through your distributor or by requesting it on the S4A site. This gives you stats and promotion tools.

3.4. Pitching playlist editors. The main free tool. In Spotify for Artists, pitch an unreleased track at least 7 days before release (3–4 weeks is better). In the pitch, give detailed info on genre, mood, instruments, the track's story, and context -> this reaches editors and influences algorithmic playlists. You can pitch one track at a time per account.

3.5. Automatic traffic sources. If the release is set up correctly and in advance, it'll land in your followers' Release Radar, and from there potentially into Discover Weekly and algorithmic radio. These mechanisms feed on real signals: saves, completion rate, and playlist adds.

3.6. Spotify's official paid tools. Once you have a base, you can use Marquee (a paid full-screen recommendation of new releases to listeners) or Discovery Mode (algorithmic promotion in exchange for a reduced royalty rate on those plays). These are legitimate tools from Spotify itself.

3.7. Organic promotion. Today the main driver of music discovery is short-form video (TikTok, Reels, Shorts): post snippets of your tracks. Run pre-save campaigns before release, release consistently, and work in a narrow functional niche (lo-fi, background, music for sleep/work/study) -> these tracks land more easily in themed playlists because people search for them by mood, not by artist name.

3.8. What to avoid. Don't buy "guaranteed streams" or playlist placements from third-party services -> it's almost always bot activity: Spotify strips those streams, doesn't pay royalties on them, and may remove your tracks or restrict your profile. People lose money on this, they don't make it.

Result:

Here's how the setup fits together: Suno provides music with commercial rights, Claude removes all the busywork -> metadata, copy, file organization, and stats analysis -> the distributor delivers your tracks to Spotify, and Spotify for Artists helps you promote them through playlists. Spotify pays roughly $0.003–0.005 per stream, and a track only starts earning royalties after 1,000 streams in a year -> so the first months are usually token amounts, and meaningful income shows up once your catalog builds a real audience. But as a repeatable, scalable process, it works: the more quality releases and real listeners you have, the higher the income.

Believe in yourself and you will succeed 🩷