> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the Splice MCP server

The Splice MCP connector routes your AI agent's tool calls to Splice's own MCP server through Scalekit. Each user signs in to Splice once, and Scalekit stores and refreshes their tokens, so your agent never handles credentials. It comes with 6 tools.

**Authentication:** OAuth 2.1/DCR
**Categories:** Media, AI, Productivity
**Tools:** 6: 1 read, 3 write, 2 destructive
**Users sign in with:** OAuth
**OAuth app:** Scalekit's or your own
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=SPLICEMCP)

## What you can do

- **Find samples**: search the Splice catalog by natural language description, with BPM and loop or one-shot filters
- **Build stacks**: create a multi-track stack from a sample or generate a full arrangement from a text prompt
- **Edit stacks**: add, remove, or swap layers, rename a stack, or change its BPM
- **Buy and share samples**: purchase a sample to get its audio download, and create a public link for a stack

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the Splice MCP connection

   In **AgentKit > Connections**, create a Splice MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

   Scalekit credentials are available for Splice MCP server, so you don't need to register an OAuth app.

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'splicemcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize Splice MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'splicemcp_describe_a_sound',
     toolInput: { query: 'YOUR_QUERY' },
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "splicemcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize Splice MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={"query":"YOUR_QUERY"},
       tool_name="splicemcp_describe_a_sound",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user signs in once. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'splicemcp_describe_a_sound',
  toolInput: {
    query: '<query>',
  },
  connector: 'splicemcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="splicemcp_describe_a_sound",
    tool_input={
        "query": "<query>",
    },
    connection_name="splicemcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `splicemcp_describe_a_sound`

Describe A Sound · Read-only

Search the Splice catalog for samples matching a natural language description, with optional BPM and type filters.

Read only: yes. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `query` (`string`, required): Natural language description of the sound you are looking for
- `bpm_max` (`integer`, optional): Maximum BPM filter
- `bpm_min` (`integer`, optional): Minimum BPM filter
- `type` (`string`, optional): Sample type: loop or oneshot. One of: `loop`, `oneshot`.

Example input: `{"query":"<query>"}`

### `splicemcp_create_stack`

Create Stack · Write

Create a multi-track stack from an existing Splice sample, optionally generating a public share URL.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `asset_uuid` (`string`, required): The UUID of the sample to use as the seed for the stack
- `bpm` (`integer`, optional): Target BPM for the stack (e.g. use the seed sample's BPM). Omit to let the backend decide.
- `generate_public_url` (`boolean`, optional): Set to true ONLY if the user explicitly asks for a shareable, public, or web link. Defaults to false.
- `name` (`string`, optional): An optional name for the stack

Example input: `{"asset_uuid":"<asset_uuid>"}`

### `splicemcp_prompt_to_stack`

Prompt To Stack · Write

Generate a complete multi-track arrangement of compatible samples from a text prompt describing the desired sound.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `prompt` (`string`, required): Your prompt describing the sound you want to create (e.g. "lo-fi hip hop beat at 80 bpm with a groovy bassline and jazzy piano", "an upbeat pop song in the style of Bruno Mars in the key of C major")
- `bpm_max` (`integer`, optional): Maximum BPM for sample selection based on the genre. Must be provided together with bpm_min.
- `bpm_min` (`integer`, optional): Minimum BPM for sample selection based on the genre. Infer from genre when the user does not specify a BPM. Typical ranges: lo-fi/chill 60–100, soulful beats/R&B 70–120, pop 100–130, disco/funk 110–130, house/techno/dance 115–135, industrial/experimental 110–150, drum and bass/jungle 160–180. For genres not listed, ensure at least a 30 BPM spread between bpm_min and bpm_max.
- `generate_public_url` (`boolean`, optional): Set to true ONLY if the user explicitly asks for a shareable, public, or web link. Defaults to false.

Example input: `{"prompt":"lo-fi hip hop beat at 80 bpm with a groovy bassline and jazzy piano"}`

### `splicemcp_share_stack`

Share Stack · Write

Generate a public shareable URL for an existing stack by its UUID.

Read only: no. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `stack_uuid` (`string`, required): UUID of the stack to share

Example input: `{"stack_uuid":"<stack_uuid>"}`

### `splicemcp_download_asset`

Download Asset · Destructive

Purchase a Splice sample and return a presigned download URL for the audio file.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `asset_uuid` (`string`, required): UUID of the asset to download
- `download_path` (`string`, optional): Optional hint indicating where the client should save the downloaded file. The server returns a presigned URL; the client is responsible for fetching and saving the file. Omit when the client does not have local filesystem access (e.g. web-based clients).

Example input: `{"asset_uuid":"<asset_uuid>"}`

### `splicemcp_update_stack`

Update Stack · Destructive

Modify an existing stack by adding, removing, or swapping sounds, or by renaming it or changing its BPM.

Read only: no. Destructive: yes. Idempotent (safe to retry): no.

Inputs:

- `stack_uuid` (`string`, required): The UUID of the stack to modify (returned as Stack UUID by create_stack or prompt_to_stack). Use the UUID value, not a URL.
- `add_asset_uuids` (`string`, optional): Asset UUIDs to add as new layers at the end of the stack. Mutually exclusive with add_compatible_layers.
- `add_compatible_layers` (`string`, optional): Layers to add using harmonically compatible samples. Specify the instrument type for each layer. Mutually exclusive with add_asset_uuids.
- `bpm` (`integer`, optional): New playback BPM for the stack
- `name` (`string`, optional): New name for the stack (max 64 characters)
- `remove_layer_uuids` (`string`, optional): Layer UUIDs to remove from the stack (use the Layer UUID values shown in the stack output)
- `swap_compatible_layers` (`string`, optional): Layers to swap with harmonically compatible replacements. Mutually exclusive with swap_layers.
- `swap_layers` (`string`, optional): Layers whose sample content should be replaced with a specific asset. Mutually exclusive with swap_compatible_layers.

Example input: `{"stack_uuid":"<stack_uuid>"}`

## Related

Other Media connectors ([all 23](/agentkit/connectors/?category=media)):

- [Reddit](/agentkit/connectors/reddit/): Scalekit connector, OAuth, 105 tools
- [Diarize](/agentkit/connectors/diarize/): Scalekit connector, Access token, 3 tools
- [YouTube](/agentkit/connectors/youtube/): Scalekit connector, OAuth, 45 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |