### Install and Run Suno MCP Server (Bash)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/CONTRIBUTING.md

This snippet demonstrates the basic commands to clone the Suno MCP Server repository, install its dependencies using npm, run tests, and start the development server. It requires Git, Node.js, and npm/yarn to be installed.

```bash
git clone https://github.com/sandraschi/suno-mcp.git
cd suno-mcp
npm install
npm test
npm run dev
```

--------------------------------

### Natural Language Music Generation with Claude Desktop (Example)

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

This example illustrates how a user can interact with Suno MCP through natural language commands via Claude Desktop. It showcases a conversational flow where the user requests music generation, track downloads, and variations, and Claude interprets these requests to execute the corresponding Suno MCP functions. This highlights the user-friendly interface enabled by natural language processing.

```text
User: "Generate a dreamy synthwave track about neon-lit Tokyo streets at night"

Claude: I'll create that synthwave track for you using Suno AI.
[Calls suno_generate_track with appropriate parameters]
✅ Track generation started! The track will feature dreamy synthwave
   elements with a Tokyo cyberpunk atmosphere.

User: "Download the track and include the stems"

Claude: I'll download the generated track with stems for you.
[Calls suno_download_track with include_stems=True]
✅ Download completed! Track saved with individual stems for mixing.

User: "Create three more variations with different moods"

Claude: I'll generate three variations with different emotional tones.
[Calls suno_generate_track multiple times with mood variations]
```

--------------------------------

### Install Suno MCP Python Package

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Installs the Suno MCP server and its dependencies using pip. Includes cloning the repository, installing requirements, and setting up Playwright browsers. Also covers installation as an editable package for development.

```bash
# Clone repository
git clone https://github.com/sandra/suno-mcp.git
cd suno-mcp

# Install dependencies
pip install -r requirements.txt

# Install Playwright browsers
playwright install chromium

# Verify installation
python -m suno_mcp.server --help

# Install as editable package for development
pip install -e .

# Test MCP server in stdio mode
python -m suno_mcp.server
```

--------------------------------

### Install Dependencies and Browsers for Suno-MCP

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

These commands install the necessary Python dependencies for the Suno-MCP project and the Playwright browsers required for browser automation. Ensure Python 3.10+ is installed.

```bash
cd D:\Dev\repos\suno-mcp
pip install -r requirements.txt
playwright install chromium
```

--------------------------------

### Basic Suno AI Music Generation Workflow using JavaScript

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

A JavaScript example demonstrating the basic workflow for generating music with Suno AI via the Suno-MCP integration. This includes opening the browser, logging in, generating a track with specific prompts and styles, checking its status, downloading the result, and closing the browser.

```javascript
// 1. Open browser and navigate to Suno
suno_open_browser({headless: false})

// 2. Login to your account  
suno_login({
  email: "your-email@example.com",
  password: "your-password"
})

// 3. Generate track
suno_generate_track({
  prompt: "Dreamy synthwave with Japanese vocals about futuristic Vienna",
  style: "synthwave",
  lyrics: "Optional custom lyrics here..."
})

// 4. Check status
suno_get_status()

// 5. Download when ready
suno_download_track({
  track_id: "generated-track-id",
  download_path: "D:\\Music\\Suno_Downloads",
  include_stems: true
})

// 6. Cleanup
suno_close_browser()
```

--------------------------------

### Configure Claude Desktop for Suno-MCP Integration

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

Configuration examples for Claude Desktop to integrate with the Suno-MCP server. This involves specifying the command to run the server and setting the Python path. The configuration should be added to `claude_desktop_config.json`.

```json
{
  "mcpServers": {
    "suno-mcp": {
      "command": "python",
      "args": ["-m", "suno_mcp.server"],
      "env": {
        "PYTHONPATH": "D:\\Dev\\repos\\suno-mcp\\src"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "suno-mcp": {
      "command": "python",
      "args": ["-m", "suno_mcp.server"],
      "env": {
        "PYTHONPATH": "/path/to/suno-mcp/src"
      }
    }
  }
}
```

```json
{
  "mcpServers": {
    "suno-mcp": {
      "command": "suno-mcp",
      "args": [],
      "env": {}
    }
  }
}
```

--------------------------------

### Advanced Suno Studio Workflow Example (JavaScript)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

This JavaScript code demonstrates a complete Suno Studio workflow, covering project creation, AI stem generation (vocals, drums, bass), waiting for generations, arranging tracks, setting BPM, creating song sections, applying effects, and exporting the final project. It assumes the Suno Studio API is available and configured.

```javascript
// 1. Open Suno Studio
suno_studio_open({headless: false})

// 2. Create new project
suno_studio_create_project({
  name: "My Vienna Synthwave Project",
  template: "electronic",
  bpm: 120,
  key: "C"
})

// 3. Generate multiple stems
suno_studio_generate_stem({
  prompt: "Dreamy synthwave lead with Japanese-style vocals",
  type: "vocals",
  position: 0,
  duration: 120,
  mood: "mysterious"
})

suno_studio_generate_stem({
  prompt: "Driving synthwave drums with heavy reverb",
  type: "drums",
  position: 0,
  duration: 120
})

suno_studio_generate_stem({
  prompt: "Deep analog bass line in C minor",
  type: "bass",
  position: 0,
  duration: 120
})

// 4. Wait for generations to complete
suno_studio_wait_generation({generationId: "generation-id-1"})
suno_studio_wait_generation({generationId: "generation-id-2"})
suno_studio_wait_generation({generationId: "generation-id-3"})

// 5. Arrange tracks on timeline
suno_studio_arrange_track({
  trackId: "track-1",
  startTime: 0,
  endTime: 120,
  loop: true
})

// 6. Set project BPM
suno_studio_set_bpm({bpm: 128})

// 7. Create song sections
suno_studio_create_sections({
  sections: [
    {name: "Intro", startTime: 0, endTime: 16},
    {name: "Verse", startTime: 16, endTime: 48},
    {name: "Chorus", startTime: 48, endTime: 80},
    {name: "Outro", startTime: 80, endTime: 120}
  ]
})

// 8. Mix and master
suno_studio_adjust_volume({
  trackId: "track-1",
  volume: 85
})

suno_studio_add_effect({
  trackId: "track-1",
  effect: "reverb",
  parameters: {roomSize: 0.7, wetDry: 30}
})

// 9. Export final project
suno_studio_export_project({
  format: "wav",
  quality: "lossless",
  includeStems: true,
  includeMIDI: true,
  downloadPath: "D:\\Music\\Suno_Studio_Exports"
})

// 10. Cleanup
suno_studio_close({saveSession: true})
```

--------------------------------

### Batch Music Generation with Suno AI (Python)

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

This Python example demonstrates how to automate the generation of multiple music tracks, suitable for album production. It initializes a session once, then iterates through a list of track configurations to generate each one. Finally, it downloads all generated tracks, including their stems, into separate directories. This approach is efficient for creating multiple distinct pieces of music.

```python
# Initialize session once
await suno_open_browser(headless=True)
await suno_login(email="producer@studio.com", password="pass123")

# Generate multiple tracks with different styles
tracks = [
    {
        "prompt": "Uplifting electronic dance music with euphoric melody",
        "style": "electronic",
        "name": "Track_01_Euphoria"
    },
    {
        "prompt": "Dark ambient soundscape with mysterious atmosphere",
        "style": "ambient",
        "name": "Track_02_Mystery"
    },
    {
        "prompt": "Funky disco groove with vintage synthesizers",
        "style": "disco",
        "name": "Track_03_Groove"
    }
]

# Generate all tracks
generated_ids = []
for track in tracks:
    result = await suno_generate_track(
        prompt=track["prompt"],
        style=track["style"],
        duration="long"
    )
    # Parse track ID from result and store
    # generated_ids.append(track_id)
    print(f"Generated: {track['name']}")

# Download all tracks when ready
for track_id, track in zip(generated_ids, tracks):
    await suno_download_track(
        track_id=track_id,
        download_path=f"./album/{track['name']}/",
        include_stems=True
    )

await suno_close_browser()
```

--------------------------------

### Open Suno Studio Session (JavaScript)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Initializes a Suno Studio session, with options to run in headless mode, restore previous sessions, and configure viewport dimensions. This function is crucial for starting any Suno Studio interaction.

```javascript
{
  name: "suno_studio_open",
  description: "Open Suno Studio and initialize session",
  inputSchema: {
    type: "object",
    properties: {
      headless: {
        type: "boolean",
        description: "Run browser in headless mode",
        default: true
      },
      restoreSession: {
        type: "boolean",
        description: "Restore previous session if available",
        default: true
      },
      viewport: {
        type: "object",
        properties: {
          width: { type: "number", default: 1920 },
          height: { type: "number", default: 1080 }
        }
      }
    }
  }
}
```

--------------------------------

### Launch FastAPI HTTP API Server

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Starts the FastAPI HTTP API server for the Suno MCP. This enables web-based integrations and remote access to the server's functionalities. The command `python -m suno_mcp.server --api` is used, and it provides URLs for the API, documentation, and ReDoc.

```bash
# Start FastAPI server
python -m suno_mcp.server --api

# Server starts at:
# API: http://0.0.0.0:3000
# Docs: http://0.0.0.0:3000/api/docs
# ReDoc: http://0.0.0.0:3000/api/redoc

# Test API endpoint
curl http://localhost:3000/health

# Access interactive API documentation
# Navigate to http://localhost:3000/api/docs in browser
```

--------------------------------

### FastAPI List Available Tools Endpoint

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Returns a catalog of all registered MCP tools, including their names, descriptions, and categories. This endpoint is useful for discovering available functionalities. Accessed via GET request to /api/v1/tools.

```bash
# List all available tools
curl http://localhost:3000/api/v1/tools

# Response:
{
  "tools": [
    {
      "name": "suno_open_browser",
      "description": "Open browser and navigate to Suno AI create page",
      "category": "basic"
    },
    {
      "name": "suno_login",
      "description": "Login to Suno AI account",
      "category": "basic"
    },
    {
      "name": "suno_generate_track",
      "description": "Generate a new music track using Suno AI",
      "category": "basic"
    }
  ]
}
```

--------------------------------

### Suno MCP HTTP API Integration (Python)

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

This Python example demonstrates how to interact with the Suno MCP backend services using HTTP requests. It shows how to check server health, initiate browser sessions, authenticate users, and generate music tracks by sending JSON payloads to specific API endpoints. This is useful for integrating Suno MCP capabilities into web applications or other services.

```python
import requests

BASE_URL = "http://localhost:3000"

# Check server health
health = requests.get(f"{BASE_URL}/health").json()
print(f"Server status: {health['status']}, uptime: {health['uptime']}s")

# Open browser via API
response = requests.post(
    f"{BASE_URL}/api/v1/tools/suno_open_browser",
    json={"arguments": {"headless": True}}
)
print(response.json()["result"])

# Login via API
login_response = requests.post(
    f"{BASE_URL}/api/v1/tools/suno_login",
    json={
        "arguments": {
            "email": "api_user@example.com",
            "password": "api_password"
        }
    }
)
print(login_response.json()["result"])

# Generate track via API
generate_response = requests.post(
    f"{BASE_URL}/api/v1/tools/suno_generate_track",
    json={
        "arguments": {
            "prompt": "Chill lofi hip hop beats for studying",
            "style": "lofi",
            "duration": "long"
        }
    }
)
print(generate_response.json()["result"])

# Get server status
status = requests.get(f"{BASE_URL}/api/v1/status").json()
print(f"Browser: {status['browser_open']}, Page: {status['page_ready']}")
```

--------------------------------

### JavaScript Integration Tests for Suno Studio Workflow

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/playwright-automation-strategy.md

Illustrates integration testing for end-to-end workflows. This example tests the complete process of creating a project and generating stems within the Suno Studio, verifying that the workflow executes successfully and produces the expected number of generations.

```javascript
// Test complete workflows
describe('Suno Studio Workflow', () => {
  test('should create project and generate stems', async () => {
    const workflow = new SunoStudioWorkflow();
    
    const result = await workflow.executeWorkflow({
      projectName: 'Test Project',
      stems: [
        { prompt: 'upbeat drums', type: 'drums' },
        { prompt: 'melodic bass line', type: 'bass' }
      ]
    });
    
    expect(result.success).toBe(true);
    expect(result.generations).toHaveLength(2);
  });
});
```

--------------------------------

### Configure Environment Variables

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Sets environment variables to configure the Suno MCP server's behavior for different deployment scenarios. Key variables include PYTHONPATH, PYTHONUNBUFFERED, SUNO_HEADLESS, and SUNO_DOWNLOAD_PATH. Examples for setting variables in bash and creating a Docker environment file are provided.

```bash
# Set Python path
export PYTHONPATH="/path/to/suno-mcp/src"

# Enable unbuffered output for logging
export PYTHONUNBUFFERED="1"

# Configure browser headless mode
export SUNO_HEADLESS="true"

# Set download directory
export SUNO_DOWNLOAD_PATH="./downloads"

# Run server with environment
python -m suno_mcp.server

# Docker environment file
cat > .env << EOF
PYTHONPATH=/app/src
PYTHONUNBUFFERED=1
SUNO_HEADLESS=true
SUNO_DOWNLOAD_PATH=/app/downloads
EOF
```

--------------------------------

### Extend SunoMCPServer for Studio Features (JavaScript)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

This class extends the base SunoMCPServer to incorporate Suno Studio functionalities. It initializes various managers and overrides setup methods to include studio-specific tool handlers. Dependencies include SunoMCPServer, SunoStudioManager, SunoProjectManager, SunoGenerationController, SunoTimelineManager, SunoMixingEngine, and SunoExportManager.

```javascript
class SunoStudioMCPServer extends SunoMCPServer {
  constructor() {
    super();
    this.studioManager = new SunoStudioManager();
    this.projectManager = new SunoProjectManager();
    this.generationController = new SunoGenerationController();
    this.timelineManager = new SunoTimelineManager();
    this.mixingEngine = new SunoMixingEngine();
    this.exportManager = new SunoExportManager();
  }

  async setupToolHandlers() {
    await super.setupToolHandlers();
    await this.setupStudioToolHandlers();
  }

  async setupStudioToolHandlers() {
    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params;
      
      switch (name) {
        case "suno_studio_open":
          return await this.openStudio(args);
        case "suno_studio_create_project":
          return await this.createProject(args);
        case "suno_studio_generate_stem":
          return await this.generateStem(args);
      }
    });
  }
}
```

--------------------------------

### Configure Claude Desktop Integration

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Configures Claude Desktop to use the Suno MCP server via the MCP stdio interface. This involves modifying the `claude_desktop_config.json` file with the correct command and arguments for running the server. Two configuration examples are provided: one for local development and one for an installed package.

```json
// Windows: %APPDATA%/Claude/claude_desktop_config.json
// macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
// Linux: ~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "suno-mcp": {
      "command": "python",
      "args": ["-m", "suno_mcp.server"],
      "env": {
        "PYTHONPATH": "D:\\Dev\\repos\\suno-mcp\\src"
      }
    }
  }
}

// Alternative: Using installed package
{
  "mcpServers": {
    "suno-mcp": {
      "command": "suno-mcp",
      "args": [],
      "env": {}
    }
  }
}

// After configuration, restart Claude Desktop
// Tools will appear automatically in Claude's tool list
```

--------------------------------

### JavaScript Performance Monitor Class

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/playwright-automation-strategy.md

A class designed for tracking the performance of operations. It allows starting and ending operations, recording their start times, end times, and durations. The `getMetrics` method provides an array of all recorded performance data, useful for monitoring and analysis.

```javascript
class PerformanceMonitor {
  constructor() {
    this.metrics = new Map();
  }

  startOperation(operationId) {
    this.metrics.set(operationId, {
      startTime: Date.now(),
      status: 'running'
    });
  }

  endOperation(operationId, success = true) {
    const metric = this.metrics.get(operationId);
    if (metric) {
      metric.endTime = Date.now();
      metric.duration = metric.endTime - metric.startTime;
      metric.success = success;
    }
  }

  getMetrics() {
    return Array.from(this.metrics.values());
  }
}
```

--------------------------------

### Create New Suno Studio Project (Python)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/HALLUCINATED_STUDIO_TOOLS.md

A placeholder for initializing a new Studio project with specified parameters like name, template, BPM, and key. The implementation details, including clicking buttons, filling forms, and waiting for project load, are entirely made up.

```python
# Fake project creation steps
# Click "New Project" button
# Fill project creation form
# Select template, set BPM/key
# Submit and wait for project load
```

--------------------------------

### Basic Music Generation Workflow with Suno AI (Python)

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

This Python snippet outlines the fundamental steps for generating and downloading a single music track using the Suno AI library. It includes initializing the browser, logging in, generating a track with specified parameters, waiting for completion, downloading the track with stems, and finally closing the browser session. Ensure Suno AI credentials and a valid track ID are used.

```python
# Step 1: Initialize browser session
await suno_open_browser(headless=True)

# Step 2: Authenticate with Suno AI
await suno_login(
    email="musician@example.com",
    password="secure_password"
)

# Step 3: Generate track with detailed prompt
await suno_generate_track(
    prompt="Energetic rock anthem with powerful guitar riffs and driving drums, "
           "inspired by 80s stadium rock with modern production",
    style="rock",
    duration="medium"
)

# Step 4: Wait for generation (typically 2-5 minutes)
# Check status periodically
await suno_get_status()

# Step 5: Download completed track
# Note: Use actual track_id from Suno AI interface
await suno_download_track(
    track_id="abc123xyz789",
    download_path="./my_music/",
    include_stems=True
)

# Step 6: Cleanup session
await suno_close_browser()
```

--------------------------------

### Export Section API

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Allows exporting a specific section of the project with defined start and end times and desired format.

```APIDOC
## POST /suno_studio_export_section

### Description
Export a specific section of the project by its name, start time, and end time.

### Method
POST

### Endpoint
/suno_studio_export_section

### Parameters
#### Request Body
- **sectionName** (string) - Required - The name of the section to export.
- **startTime** (number) - Optional - The start time in seconds for the section export.
- **endTime** (number) - Optional - The end time in seconds for the section export.
- **format** (string) - Optional - Export format. Enum: ["mp3", "wav", "flac"]. Default: "mp3"
- **downloadPath** (string) - Optional - Download directory path. Default: "D:\\Dev\\repos\\temp"

### Response
#### Success Response (200)
- **message** (string) - Success message indicating section export completion.

#### Response Example
```json
{
  "message": "Section exported successfully."
}
```
```

--------------------------------

### FastAPI Health Check Endpoint

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Provides server health status, version, and operational metrics. Useful for monitoring and load balancing. Accepts GET requests to the /health endpoint.

```bash
# Check server health
curl http://localhost:3000/health

# Response:
{
  "status": "ok",
  "version": "1.0.0",
  "uptime": 3847.2,
  "tools_loaded": 23
}
```

--------------------------------

### List Available Tools

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Returns a catalog of all registered MCP tools, including their names, descriptions, and categories.

```APIDOC
## GET /api/v1/tools

### Description
Returns a catalog of all registered MCP tools with descriptions and categories.

### Method
GET

### Endpoint
/api/v1/tools

### Parameters
None

### Request Example
```bash
curl http://localhost:3000/api/v1/tools
```

### Response
#### Success Response (200)
- **tools** (array) - An array of tool objects.
  - **name** (string) - The name of the tool.
  - **description** (string) - A brief description of the tool's functionality.
  - **category** (string) - The category the tool belongs to.

#### Response Example
```json
{
  "tools": [
    {
      "name": "suno_open_browser",
      "description": "Open browser and navigate to Suno AI create page",
      "category": "basic"
    },
    {
      "name": "suno_login",
      "description": "Login to Suno AI account",
      "category": "basic"
    },
    {
      "name": "suno_generate_track",
      "description": "Generate a new music track using Suno AI",
      "category": "basic"
    }
  ]
}
```
```

--------------------------------

### Get Generation Status (JavaScript)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Retrieves the status of a specific generation using its unique ID. This function requires the 'generationId' as input to identify the generation whose status is to be fetched.

```javascript
{
  name: "suno_studio_get_generation_status",
  description: "Get status of specific generation",
  inputSchema: {
    type: "object",
    properties: {
      generationId: {
        type: "string",
        description: "Generation ID"
      }
    },
    required: ["generationId"]
  }
}
```

--------------------------------

### Launch Suno Studio DAW Interface (Python)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/HALLUCINATED_STUDIO_TOOLS.md

Attempts to launch the Suno Studio DAW interface. It navigates to the Studio URL and waits for a fake selector to indicate the interface has loaded. This implementation is purely theoretical and requires Premier access, which was not available.

```python
await page.goto("https://app.suno.ai/studio/")
# Fake selectors for Studio detection
await page.locator('[data-testid*="studio"], .studio-interface').wait_for()
```

--------------------------------

### Arrange Tracks on Timeline with Suno Studio

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Arranges tracks on the timeline by setting their start and end times. It supports looping and fade-in/fade-out effects. This tool is essential for structuring the audio project.

```javascript
{
  name: "suno_studio_arrange_track",
  description: "Arrange tracks on the timeline",
  inputSchema: {
    type: "object",
    properties: {
      trackId: { 
        type: "string", 
        description: "Track ID to arrange" 
      },
      startTime: { 
        type: "number", 
        description: "Start time in seconds" 
      },
      endTime: { 
        type: "number", 
        description: "End time in seconds" 
      },
      loop: { 
        type: "boolean", 
        description: "Loop the track",
        default: false 
      },
      fadeIn: { 
        type: "number", 
        description: "Fade in duration in seconds",
        default: 0 
      },
      fadeOut: { 
        type: "number", 
        description: "Fade out duration in seconds",
        default: 0 
      }
    },
    required: ["trackId", "startTime"]
  }
}
```

--------------------------------

### FastAPI Server Status Endpoint

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Retrieves detailed status of the MCP server, including browser session state, current URL, page title, and operational mode. Accessible via a GET request to /api/v1/status.

```bash
# Get detailed server status
curl http://localhost:3000/api/v1/status

# Response:
{
  "browser_open": true,
  "page_ready": true,
  "current_url": "https://app.suno.ai/create/",
  "page_title": "Suno AI - Create Music",
  "in_studio": false,
  "server_mode": "dual"
}
```

--------------------------------

### Suno Studio Tools (Beta)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

This section details the available tools within the Suno Studio for advanced music generation workflows.

```APIDOC
## Suno Studio Tools (Beta)

This section details the available tools within the Suno Studio for advanced music generation workflows.

### `suno_studio_open`

- **Description**: Opens Suno Studio.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_open({headless: false})`

### `suno_studio_close`

- **Description**: Closes Suno Studio and saves the session.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_close({saveSession: true})`

### `suno_studio_create_project`

- **Description**: Creates a new project in Suno Studio.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_create_project({
  name: "My Vienna Synthwave Project",
  template: "electronic",
  bpm: 120,
  key: "C"
})`

### `suno_studio_generate_stem`

- **Description**: Generates an AI stem for the current project.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_generate_stem({
  prompt: "Dreamy synthwave lead with Japanese-style vocals",
  type: "vocals",
  position: 0,
  duration: 120,
  mood: "mysterious"
})`

### `suno_studio_wait_generation`

- **Description**: Waits for a specific generation to complete.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_wait_generation({generationId: "generation-id-1"})`

### `suno_studio_arrange_track`

- **Description**: Arranges a track on the timeline.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_arrange_track({
  trackId: "track-1",
  startTime: 0,
  endTime: 120,
  loop: true
})`

### `suno_studio_set_bpm`

- **Description**: Sets the project's BPM.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_set_bpm({bpm: 128})`

### `suno_studio_create_sections`

- **Description**: Creates song sections within the project.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_create_sections({
  sections: [
    {name: "Intro", startTime: 0, endTime: 16},
    {name: "Verse", startTime: 16, endTime: 48},
    {name: "Chorus", startTime: 48, endTime: 80},
    {name: "Outro", startTime: 80, endTime: 120}
  ]
})`

### `suno_studio_adjust_volume`

- **Description**: Adjusts the volume of a specific track.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_adjust_volume({
  trackId: "track-1",
  volume: 85
})`

### `suno_studio_add_effect`

- **Description**: Adds an audio effect to a track.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_add_effect({
  trackId: "track-1",
  effect: "reverb",
  parameters: {roomSize: 0.7, wetDry: 30}
})`

### `suno_studio_export_project`

- **Description**: Exports the current project.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_studio_export_project({
  format: "wav",
  quality: "lossless",
  includeStems: true,
  includeMIDI: true,
  downloadPath: "D:\\Music\\Suno_Studio_Exports"
})`
```

--------------------------------

### Get Comprehensive Studio Status (JavaScript)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Retrieves the comprehensive status of the Suno Studio. Options include whether to include active generation status, current project information, and track details. Defaults to including all status information.

```javascript
{
  name: "suno_studio_get_status",
  description: "Get comprehensive Studio status",
  inputSchema: {
    type: "object",
    properties: {
      includeGenerations: {
        type: "boolean",
        description: "Include active generation status",
        default: true
      },
      includeProject: {
        type: "boolean",
        description: "Include current project info",
        default: true
      },
      includeTracks: {
        type: "boolean",
        description: "Include track information",
        default: true
      }
    }
  }
}
```

--------------------------------

### Core Suno AI Tools

Source: https://github.com/kritsanan1/suno-mcp/blob/main/README.md

This section details the core tools available for interacting with the Suno AI platform.

```APIDOC
## Core Suno AI Tools

This section details the core tools available for interacting with the Suno AI platform.

### `suno_open_browser`

- **Description**: Launch browser automation.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_open_browser({headless: false})`

### `suno_login`

- **Description**: Authenticate with Suno AI.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_login({email: "user@example.com", password: "password123"})`

### `suno_generate_track`

- **Description**: Create a new music track.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_generate_track({
  prompt: "Epic orchestral score for a space battle",
  style: "cinematic",
  lyrics: "Engage engines, full power ahead!",
  duration: 180
})`

### `suno_download_track`

- **Description**: Download completed tracks.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_download_track({
  track_id: "track-abc-123",
  download_path: "/path/to/downloads",
  include_stems: true
})`

### `suno_get_status`

- **Description**: Check current system status.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_get_status()`

### `suno_close_browser`

- **Description**: Cleanup and close the browser.
- **Method**: (Implicitly called)
- **Endpoint**: N/A
- **Parameters**:
  - **Path Parameters**: None
  - **Query Parameters**: None
  - **Request Body**: None
- **Request Example**: `suno_close_browser()`
```

--------------------------------

### Create Song Sections with Suno Studio

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/suno-studio-mcp-enhancement-plan.md

Creates distinct sections within a song, such as verses, choruses, and bridges. Each section is defined by its name, start time, end time, and an optional repeat count. This facilitates song structure definition.

```javascript
{
  name: "suno_studio_create_sections",
  description: "Create song sections (verse, chorus, bridge)",
  inputSchema: {
    type: "object",
    properties: {
      sections: {
        type: "array",
        items: {
          type: "object",
          properties: {
            name: { type: "string" },
            startTime: { type: "number" },
            endTime: { type: "number" },
            repeat: { type: "number", default: 1 }
          },
          required: ["name", "startTime", "endTime"]
        }
      }
    },
    required: ["sections"]
  }
}
```

--------------------------------

### Open Browser Session with Playwright

Source: https://context7.com/kritsanan1/suno-mcp/llms.txt

Opens a Playwright browser instance and navigates to Suno AI's create page. Supports headless mode for background operation or visible GUI for debugging. Initializes the automation session for subsequent operations.

```python
await suno_open_browser(headless=True)
# Response: ✅ Browser opened successfully. Navigated to Suno AI.
#           Page title: Suno AI - Create Music
#           URL: https://app.suno.ai/create/
#           Headless mode: True

await suno_open_browser(headless=False)
# Shows browser window for visual debugging
```

--------------------------------

### Load Existing Suno Studio Project (Python)

Source: https://github.com/kritsanan1/suno-mcp/blob/main/docs/HALLUCINATED_STUDIO_TOOLS.md

Represents the functionality to load an existing Studio project using a unique project identifier. It uses a series of fake selectors to attempt to locate and click the project. The actual project storage and listing system is unknown.

```python
# Fake project browser
project_selectors = [
    f'[data-project-id="{project_id}"]',
    f'[data-testid="project-{project_id}"]',
    f'button:has-text("{project_id}")'
]
await SelectorHelper.try_selectors(page, project_selectors, "click")
```