StemSplit API

https://stemsplit.io/developers
Admin
StemSplit API is an AI-powered stem separation service that enables developers to integrate vocal...
Tokens:40,199
Snippets:259
Trust Score:5.4
Update:9 months ago
Show doc for...
Tokens:
Raw
### Upload File (Presigned Upload)

Source: https://stemsplit.io/developers/docs

Upload your local audio file to the provided presigned URL.

```APIDOC
## Upload File

Upload your local file to the presigned URL obtained in the previous step.

### Method

`PUT`

### Endpoint

`[uploadUrl from previous request]`

### Parameters

#### Request Headers

- **Content-Type** (string) - Required - The MIME type of the audio file (e.g., `audio/mpeg`).

#### Request Body

- **file** (binary) - Required - The content of the audio file.

### Request Example

```bash
curl -X PUT "https://storage.example.com/presigned-url..." \
  -H "Content-Type: audio/mpeg" \
  --data-binary @my-song.mp3
```
```

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

### Create Job

Source: https://stemsplit.io/developers/docs

Create a stem separation job, providing either an `uploadKey` from a presigned upload or a `sourceUrl` for an online audio file.

```APIDOC
## Create Job

Create a stem separation job. Provide either `uploadKey` for a presigned upload or `sourceUrl` for an online file.

### Method

`POST`

### Endpoint

`/api/v1/jobs`

### Parameters

#### Request Body

- **uploadKey** (string) - Required (if `sourceUrl` is not provided) - The key obtained from the `/api/v1/upload` endpoint.
- **sourceUrl** (string) - Required (if `uploadKey` is not provided) - The URL of the audio file hosted online.
- **outputType** (string) - Optional - Specifies which stems to extract. Accepted values: `VOCALS`, `INSTRUMENTAL`, `BOTH`, `FOUR_STEMS`, `SIX_STEMS`. Defaults to `BOTH`.
- **quality** (string) - Optional - Sets the processing quality. Accepted values: `FAST`, `BALANCED`, `BEST`. Defaults to `BALANCED`.
- **outputFormat** (string) - Optional - The desired format for the output stems. Accepted values: `MP3`, `WAV`, `FLAC`. Defaults to `MP3`.

### Request Example (using uploadKey)

```json
{
  "uploadKey": "uploads/api_xxx/input.mp3",
  "outputType": "BOTH",
  "quality": "BEST",
  "outputFormat": "MP3"
}
```

### Request Example (using sourceUrl)

```json
{
  "sourceUrl": "https://example.com/song.mp3",
  "outputType": "BOTH"
}
```

### Response

#### Success Response (200)

- **id** (string) - The unique identifier for the job.
- **status** (string) - The current status of the job (e.g., `PENDING`, `PROCESSING`, `COMPLETED`, `FAILED`).
- **progress** (integer) - The completion progress of the job (0-100).
- **creditsRequired** (integer) - The number of credits the job will cost.
- **input** (object) - Information about the input audio file.
  - **fileName** (string) - The name of the input file.
  - **durationSeconds** (integer) - The duration of the audio in seconds.
  - **fileSizeBytes** (integer) - The size of the input file in bytes.
- **options** (object) - The options used for the job.
  - **outputType** (string) - The selected output type.
  - **quality** (string) - The selected quality.
  - **outputFormat** (string) - The selected output format.

### Response Example

```json
{
  "id": "clxxx123...",
  "status": "PENDING",
  "progress": 0,
  "creditsRequired": 180,
  "input": {
    "fileName": "my-song.mp3",
    "durationSeconds": 180,
    "fileSizeBytes": 4500000
  },
  "options": {
    "outputType": "BOTH",
    "quality": "BEST",
    "outputFormat": "MP3"
  }
}
```
```

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

### Webhooks API

Source: https://stemsplit.io/developers/docs

Endpoints for registering and managing webhooks to receive real-time notifications about job status changes.

```APIDOC
## POST /api/v1/webhooks

### Description
Registers a webhook endpoint to receive notifications when jobs complete or fail. This allows for automated workflows without manual polling.

### Method
POST

### Endpoint
https://stemsplit.io/api/v1/webhooks

### Parameters
#### Request Body
- **url** (string) - Required - The URL of your server that will receive the webhook notifications.
- **events** (array of strings) - Required - A list of events to subscribe to (e.g., ["job.completed", "job.failed"]).

### Request Example
```json
{
  "url": "https://your-server.com/webhook",
  "events": ["job.completed", "job.failed"]
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the webhook.
- **url** (string) - The registered webhook URL.
- **events** (array of strings) - The events the webhook is subscribed to.
- **createdAt** (string) - The timestamp when the webhook was created.

### Webhook Payload
When a subscribed event occurs, a POST request will be sent to your registered webhook URL with a payload similar to this:

#### Payload Example
```json
{
  "event": "job.completed",
  "timestamp": "2024-01-05T12:30:00Z",
  "data": {
    "jobId": "clxxx123...",
    "status": "COMPLETED",
    "outputs": {
      "vocals": { "url": "https://...", "expiresAt": "..." },
      "instrumental": { "url": "https://...", "expiresAt": "..." }
    },
    "creditsCharged": 180
  }
}
```

### Verify Webhook Signatures
Incoming webhooks are signed with an HMAC-SHA256 signature in the `X-Webhook-Signature` header. It is crucial to verify this signature to ensure the request originated from StemSplit.io.

#### Signature Verification Example (Python)
```python
import hmac
import hashlib

def verify_webhook(payload: bytes, signature: str, secret: str) -> bool:
    """Verify webhook signature"""
    expected = "sha256=" + hmac.new(
        secret.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

# In your webhook handler:
# @app.post("/webhook")
# def handle_webhook(request):
#     signature = request.headers.get("X-Webhook-Signature")
#     if not verify_webhook(request.body, signature, WEBHOOK_SECRET):
#         return {"error": "Invalid signature"}, 401
#     
#     data = request.json()
#     if data["event"] == "job.completed":
#         # Process completed job
#         print(f"Job {data['data']['jobId']} completed!")
```
```

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

### Request Upload URL (Presigned Upload)

Source: https://stemsplit.io/developers/docs

Request a presigned URL for uploading local audio files directly to cloud storage.

```APIDOC
## Request Upload URL

Request a presigned URL for uploading local files.

### Method

`POST`

### Endpoint

`/api/v1/upload`

### Parameters

#### Request Body

- **filename** (string) - Required - The name of the file to be uploaded.

### Request Example

```json
{
  "filename": "my-song.mp3"
}
```

### Response

#### Success Response (200)

- **uploadUrl** (string) - The presigned URL for uploading the file.
- **uploadKey** (string) - The key to be used when creating a job with this upload.
- **expiresAt** (string) - The expiration time of the presigned URL.
- **maxFileSizeMb** (integer) - The maximum allowed file size in megabytes.

### Response Example

```json
{
  "uploadUrl": "https://storage.example.com/presigned-url...",
  "uploadKey": "uploads/api_xxx/input.mp3",
  "expiresAt": "2024-01-05T12:15:00Z",
  "maxFileSizeMb": 50
}
```
```

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

### Initialize Node.js Project and Install Dependencies

Source: https://stemsplit.io/developers/guides/discord-bot

This snippet demonstrates the terminal commands to create a new Node.js project directory, initialize an npm project, and install the necessary dependencies: discord.js for Discord bot functionality, axios for making API requests, and dotenv for managing environment variables.

```bash
# Create project directory
mkdir stemsplit-discord-bot && cd stemsplit-discord-bot

# Initialize npm project
npm init -y

# Install dependencies
npm install discord.js axios dotenv

# Create files
touch index.js .env
```

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

### Authentication

Source: https://stemsplit.io/developers/docs

All API requests require authentication using a Bearer token. Obtain your API key from your dashboard's settings.

```APIDOC
## Authentication

All API requests require authentication using a Bearer token.

### Method

No specific HTTP method, this is a header.

### Endpoint

N/A

### Parameters

#### Request Headers

- **Authorization** (string) - Required - The Bearer token for authentication. Example: `Bearer sk_live_xxxxxxxxxxxxxxxxxxxxx`
```

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

### Download Stem Audio via HTTP GET

Source: https://stemsplit.io/developers/guides/power-automate

This action downloads a specific audio stem (e.g., vocals or instrumental) using the provided URL from the job results. The downloaded content can then be used in subsequent actions, such as creating a file in SharePoint or OneDrive.

```http
GET @{body('HTTP_2')['outputs']['vocals']['url']}
```

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

### Upload Local File to Presigned URL (cURL)

Source: https://stemsplit.io/developers/docs

This cURL command uploads a local audio file to a presigned URL obtained in the previous step. It uses the PUT method and specifies the audio file content type. Ensure the provided URL is still valid.

```shell
curl -X PUT "https://storage.example.com/presigned-url..." \
  -H "Content-Type: audio/mpeg" \
  --data-binary @my-song.mp3
```

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

### Request Upload URL for Local Files (cURL)

Source: https://stemsplit.io/developers/docs

This cURL command requests a presigned upload URL for local audio files. It requires authentication and specifies the filename. The response provides the upload URL, an upload key, and an expiration time for the URL.

```shell
curl -X POST https://stemsplit.io/api/v1/upload \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"filename": "my-song.mp3"}'
```

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

### Create YouTube Job using cURL

Source: https://stemsplit.io/developers/docs

This snippet demonstrates how to create a new job to extract audio stems from a YouTube video using a cURL command. It requires the YouTube video URL and an API key for authentication. The response includes job details and status.

```curl
curl -X POST https://stemsplit.io/api/v1/youtube-jobs \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"youtubeUrl": "https://youtube.com/watch?v=dQw4w9WgXcQ"}'
```

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

### YouTube Jobs API

Source: https://stemsplit.io/developers/docs

Endpoints for creating and retrieving the status of YouTube jobs, which extract vocals and instrumentals from YouTube videos.

```APIDOC
## POST /api/v1/youtube-jobs

### Description
Creates a new job to extract vocals and instrumentals from a given YouTube video URL. The audio is processed without requiring a download.

### Method
POST

### Endpoint
https://stemsplit.io/api/v1/youtube-jobs

### Parameters
#### Request Body
- **youtubeUrl** (string) - Required - The URL of the YouTube video to process.

### Request Example
```json
{
  "youtubeUrl": "https://youtube.com/watch?v=dQw4w9WgXcQ"
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the job.
- **status** (string) - The current status of the job (e.g., PENDING).
- **videoId** (string) - The ID of the YouTube video.
- **videoTitle** (string) - The title of the YouTube video.
- **videoDuration** (integer) - The duration of the video in seconds.
- **videoThumbnail** (string) - The URL of the video thumbnail.
- **channelName** (string) - The name of the YouTube channel.
- **creditsRequired** (integer) - The number of credits required for this job.
- **outputs** (array) - An array of desired outputs (e.g., ["vocals", "instrumental"]).
- **createdAt** (string) - The timestamp when the job was created.

#### Response Example
```json
{
  "id": "clxxx123...",
  "status": "PENDING",
  "videoId": "dQw4w9WgXcQ",
  "videoTitle": "Rick Astley - Never Gonna Give You Up",
  "videoDuration": 213,
  "videoThumbnail": "https://i.ytimg.com/vi/...",
  "channelName": "Rick Astley",
  "creditsRequired": 213,
  "outputs": ["vocals", "instrumental"],
  "createdAt": "2024-01-05T12:00:00Z"
}
```

## GET /api/v1/youtube-jobs/:id

### Description
Retrieves the status and results of a specific YouTube job using its ID. This endpoint can also be used to poll for job completion.

### Method
GET

### Endpoint
https://stemsplit.io/api/v1/youtube-jobs/:id

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the YouTube job.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the job.
- **status** (string) - The current status of the job (e.g., COMPLETED).
- **progress** (integer) - The completion progress of the job (0-100).
- **videoTitle** (string) - The title of the YouTube video.
- **outputs** (object) - An object containing URLs and expiration times for the extracted audio files (e.g., fullAudio, vocals, instrumental).

#### Response Example
```json
{
  "id": "clxxx123...",
  "status": "COMPLETED",
  "progress": 100,
  "videoTitle": "Rick Astley - Never Gonna Give You Up",
  "outputs": {
    "fullAudio": {
      "url": "https://storage.example.com/full.mp3?sig=...",
      "expiresAt": "2024-01-05T13:00:00Z"
    },
    "vocals": {
      "url": "https://storage.example.com/vocals.mp3?sig=...",
      "expiresAt": "2024-01-05T13:00:00Z"
    },
    "instrumental": {
      "url": "https://storage.example.com/instrumental.mp3?sig=...",
      "expiresAt": "2024-01-05T13:00:00Z"
    }
  }
}
```
```

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

### POST /api/v1/youtube-jobs

Source: https://stemsplit.io/developers/guides/karaoke-mugen

Creates a job to process a YouTube video for vocal removal, generating an instrumental track.

```APIDOC
## POST /api/v1/youtube-jobs

### Description
This endpoint allows you to create a job to process a YouTube video. StemSplit will extract the audio, remove vocals, and provide an instrumental track. This is useful for creating karaoke versions of songs directly from YouTube.

### Method
POST

### Endpoint
`/api/v1/youtube-jobs`

### Parameters
#### Headers
- **Authorization** (string) - Required - Bearer token for authentication (e.g., `Bearer sk_live_xxx`)
- **Content-Type** (string) - Required - `application/json`

#### Request Body
- **youtubeUrl** (string) - Required - The URL of the YouTube video to process.

### Request Example
```json
{
  "youtubeUrl": "https://youtube.com/watch?v=VIDEO_ID"
}
```

### Response
#### Success Response (200)
* The response indicates that the job has been created. The actual instrumental track will be available after processing.

#### Response Example
*The specific response format for job creation confirmation is not detailed in the provided text, but it would typically include a job ID or status.*
```

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

### Get Presigned Upload URL using cURL

Source: https://stemsplit.io/developers/index

This example shows how to obtain a presigned URL for uploading an audio file directly to the StemSplit service using cURL. It requires a POST request to the /api/v1/upload endpoint with the desired filename.

```curl
POST /api/v1/upload \
  -H "Authorization: Bearer sk_live_xxxxxxxxxxxxx" \
  -d '{"filename": "my_audio.wav"}'
```

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

### Register a Webhook using cURL

Source: https://stemsplit.io/developers/docs

This snippet demonstrates how to register a webhook to receive real-time notifications for job completion or failure events. It requires a callback URL and a list of events to subscribe to.

```curl
curl -X POST https://stemsplit.io/api/v1/webhooks \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-server.com/webhook",
    "events": ["job.completed", "job.failed"]
  }'
```

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

### Create Stem Separation Job (cURL)

Source: https://stemsplit.io/developers/docs

This cURL command demonstrates how to create a new stem separation job. It requires an API key for authentication and specifies the source audio URL and desired output type. The response includes job details such as ID, status, and credits required.

```shell
curl -X POST https://stemsplit.io/api/v1/jobs \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{"sourceUrl": "https://example.com/song.mp3", "outputType": "BOTH"}'
```

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

### Webhook Payload Examples

Source: https://stemsplit.io/developers/guides/white-label

Examples of the JSON payloads received via webhooks for different job events.

```APIDOC
## Webhook Event Payloads

### Description
These are example payloads for the events you can receive via webhooks.

#### `job.completed` Event Payload
```json
{
  "event": "job.completed",
  "timestamp": "2024-01-15T10:30:00Z",
  "data": {
    "jobId": "job_abc123",
    "status": "COMPLETED",
    "outputs": {
      "vocals": { "url": "https://.../vocals.mp3", "size": 4521984 },
      "instrumental": { "url": "https://.../instrumental.mp3", "size": 5832192 }
    }
  }
}
```

#### `job.failed` Event Payload
```json
{
  "event": "job.failed",
  "timestamp": "2024-01-15T10:35:00Z",
  "data": {
    "jobId": "job_def456",
    "status": "FAILED",
    "error": "Invalid audio format provided."
  }
}
```
```

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

### POST /upload

Source: https://stemsplit.io/developers/reference

Get a presigned URL for uploading an audio file. Use the returned uploadKey when creating a job.

```APIDOC
## POST /upload

### Description
Get a presigned URL for uploading an audio file. Use the returned `uploadKey` when creating a job.

### Method
POST

### Endpoint
`/upload`

### Parameters
#### Request Body
- **filename** (string) - Required - The desired filename for the uploaded file.
- **contentType** (string) - Optional - The MIME type of the file (e.g., `audio/mpeg`). If not provided, it will be auto-detected.

### Request Example
```json
{
  "filename": "my-song.mp3",
  "contentType": "audio/mpeg"
}
```

### Response
#### Success Response (200)
- **uploadUrl** (string) - The presigned URL to upload the file to.
- **uploadKey** (string) - The key to be used when creating a job.
- **expiresAt** (string) - Timestamp when the upload URL expires.
- **maxFileSizeBytes** (integer) - Maximum allowed file size in bytes.
- **maxFileSizeMb** (integer) - Maximum allowed file size in megabytes.
- **contentType** (string) - The determined content type of the file.
- **instructions** (object) - Instructions for uploading the file.
  - **step1** (string) - The first step of the upload process.
  - **step2** (string) - The second step of the upload process.
  - **note** (string) - Additional notes about the upload.

#### Response Example
```json
{
  "uploadUrl": "https://storage.example.com/presigned-url...",
  "uploadKey": "uploads/api_xxx/input.mp3",
  "expiresAt": "2024-01-05T12:15:00Z",
  "maxFileSizeBytes": 52428800,
  "maxFileSizeMb": 50,
  "contentType": "audio/mpeg",
  "instructions": {
    "step1": "PUT your file to the uploadUrl with Content-Type: audio/mpeg",
    "step2": "Use the uploadKey when calling POST /api/v1/jobs",
    "note": "The upload URL expires in 15 minutes"
  }
}
```
```

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

### Create Job with Upload Key (cURL)

Source: https://stemsplit.io/developers/docs

This cURL command creates a stem separation job using an upload key for a file that has already been uploaded. It specifies options like output type, quality, and output format. The response details the job status and associated costs.

```shell
curl -X POST https://stemsplit.io/api/v1/jobs \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "uploadKey": "uploads/api_xxx/input.mp3",
    "outputType": "BOTH",
    "quality": "BEST",
    "outputFormat": "MP3"
  }'
```

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

### Webhook Payload Example (job.completed)

Source: https://stemsplit.io/developers/guides/white-label

An example of the JSON payload received when a stem separation job is successfully completed. It includes the event type, timestamp, job ID, status, and URLs to the separated stems.

```json
{
  "event": "job.completed",
  "timestamp": "2024-01-15T10:30:00Z",
  "data": {
    "jobId": "job_abc123",
    "status": "COMPLETED",
    "outputs": {
      "vocals": { "url": "https://...", "size": 4521984 },
      "instrumental": { "url": "https://...", "size": 5832192 }
    }
  }
}
```

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

### Create Job API

Source: https://stemsplit.io/developers/guides/zapier

This endpoint initiates a new audio stem separation job with StemSplit.

```APIDOC
## POST /api/v1/jobs

### Description
Initiates a new audio stem separation job. Accepts a source URL for the audio file and specifies output preferences.

### Method
POST

### Endpoint
https://stemsplit.io/api/v1/jobs

### Parameters
#### Headers
- **Authorization** (string) - Required - `Bearer sk_live_xxx`
- **Content-Type** (string) - Required - `application/json`

#### Request Body
- **sourceUrl** (string) - Required - The publicly accessible URL of the audio file to process. For Dropbox, use the direct download link ending in `?dl=1`.
- **outputType** (string) - Optional - Specifies the types of stems to output. Options include `BOTH`, `VOCALS`, `INSTRUMENTAL`, `FOUR_STEMS`, `SIX_STEMS`. Defaults to `BOTH`.
- **quality** (string) - Optional - Desired quality of the separated stems. Options include `BEST`, `GOOD`. Defaults to `BEST`.
- **outputFormat** (string) - Optional - The format for the output stems. Options include `MP3`, `WAV`. Defaults to `MP3`.

### Request Example
```json
{
  "sourceUrl": "{{1. Direct URL to file}}",
  "outputType": "BOTH",
  "quality": "BEST",
  "outputFormat": "MP3"
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the created job.
- **status** (string) - The initial status of the job (e.g., "PROCESSING").

#### Response Example
```json
{
  "id": "job_abc123",
  "status": "PROCESSING"
}
```
```

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

### Get Job Status and Results

Source: https://stemsplit.io/developers/docs

Poll the job status endpoint to track the progress of a stem separation job. Once completed, the response will include URLs for the separated stems.

```APIDOC
## Get Job Status and Results

Poll the job status endpoint to retrieve the current status and, upon completion, the download URLs for the separated stems.

### Method

`GET`

### Endpoint

`/api/v1/jobs/{jobId}`

- **jobId** (string) - Required - The ID of the job to query.

### Parameters

#### Path Parameters

- **jobId** (string) - Required - The unique identifier of the job.

### Response

#### Success Response (200)

- **id** (string) - The job ID.
- **status** (string) - The job status (`PENDING`, `PROCESSING`, `COMPLETED`, `FAILED`).
- **progress** (integer) - The job completion progress (0-100).
- **outputs** (object) - Contains URLs for the separated stems if the job is `COMPLETED`.
  - **vocals** (object) - Information for the vocals stem.
    - **url** (string) - The download URL for the vocals stem.
    - **expiresAt** (string) - The expiration time of the download URL.
  - **instrumental** (object) - Information for the instrumental stem.
    - **url** (string) - The download URL for the instrumental stem.
    - **expiresAt** (string) - The expiration time of the download URL.
  *(Other stems like drums, bass, etc., will be present if requested via `outputType`)*
- **creditsCharged** (integer) - The number of credits charged for the completed job.

### Response Example (Completed Job)

```json
{
  "id": "clxxx123...",
  "status": "COMPLETED",
  "progress": 100,
  "outputs": {
    "vocals": {
      "url": "https://storage.example.com/vocals.mp3?signature=...",
      "expiresAt": "2024-01-05T13:00:00Z"
    },
    "instrumental": {
      "url": "https://storage.example.com/instrumental.mp3?signature=...",
      "expiresAt": "2024-01-05T13:00:00Z"
    }
  },
  "creditsCharged": 180
}
```
```

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

### Get Job Status and Results - GET /api/v1/jobs/{id}

Source: https://stemsplit.io/developers/guides/make

This endpoint retrieves the status and results of a previously created job using its job ID. Once processing is complete, this will return URLs for the processed audio files.

```APIDOC
## GET /api/v1/jobs/{id}

### Description
Retrieves the status and results of a specific audio processing job.

### Method
GET

### Endpoint
`https://stemsplit.io/api/v1/jobs/:id`

### Parameters
#### Path Parameters
- **id** (string) - Required - The unique identifier of the job to retrieve.

#### Headers
- **Authorization** (string) - Required - `Bearer YOUR_API_KEY`

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the job.
- **status** (string) - The current status of the job (e.g., 'PROCESSING', 'COMPLETED', 'FAILED').
- **outputs** (object) - Contains URLs for processed outputs if the job is completed. Structure:
  - **vocals** (object) - Details for the vocals output.
    - **url** (string) - URL of the vocals audio file.
    - **format** (string) - Format of the vocals file.
  - **instrumental** (object) - Details for the instrumental output.
    - **url** (string) - URL of the instrumental audio file.
    - **format** (string) - Format of the instrumental file.

#### Response Example (Job Completed)
```json
{
  "id": "job_abc123xyz",
  "status": "COMPLETED",
  "outputs": {
    "vocals": {
      "url": "https://stemsplit.io/outputs/vocals_abc123.mp3",
      "format": "MP3"
    },
    "instrumental": {
      "url": "https://stemsplit.io/outputs/instrumental_abc123.mp3",
      "format": "MP3"
    }
  }
}
```
```

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

### Create Karaoke Track with StemSplit API (cURL)

Source: https://stemsplit.io/developers/guides/openkj

This snippet demonstrates how to use cURL to send a POST request to the StemSplit API to process an audio file and generate an instrumental version. It specifies the source URL, desired output type (INSTRUMENTAL), quality, and output format. Ensure you replace the placeholder URL and API key with your actual details.

```bash
# Process a song and get instrumental
curl -X POST https://stemsplit.io/api/v1/jobs \
  -H "Authorization: Bearer sk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "sourceUrl": "https://your-storage.com/Queen - Bohemian Rhapsody.mp3",
    "outputType": "INSTRUMENTAL",
    "quality": "BEST",
    "outputFormat": "MP3"
  }'
```

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

### Get Job Status with HTTP GET Request in Make

Source: https://stemsplit.io/developers/guides/make

This snippet shows how to use an HTTP module in Make to perform a GET request to the StemSplit API to retrieve the status and results of a previously created job. It specifies the endpoint URL using a dynamic job ID placeholder and includes the necessary Authorization header.

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

### Get YouTube Job Status using cURL

Source: https://stemsplit.io/developers/docs

This snippet shows how to retrieve the status of a YouTube job by its ID using a cURL command. The response provides the job's current status, progress, and output links if completed.

```curl
GET /api/v1/youtube-jobs/:id
```

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

### Get Job Status API

Source: https://stemsplit.io/developers/guides/n8n

This endpoint allows you to retrieve the current status and results of a previously submitted separation job.

```APIDOC
## GET /api/v1/jobs/{jobId}

### Description
Retrieves the status and results of a specific stem separation job.

### Method
GET

### Endpoint
https://stemsplit.io/api/v1/jobs/{jobId}

### Parameters
#### Path Parameters
- **jobId** (string) - Required - The unique identifier of the job to retrieve.

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the separation job.
- **status** (string) - The current status of the job (e.g., "PROCESSING", "COMPLETED", "FAILED").
- **outputs** (object) - An object containing URLs to the separated stems if the job is completed.
  - **vocals** (object) - Information about the separated vocals.
    - **url** (string) - URL to the separated vocals file.
    - **format** (string) - Format of the vocals file.
  - **instrumental** (object) - Information about the separated instrumental.
    - **url** (string) - URL to the separated instrumental file.
    - **format** (string) - Format of the instrumental file.
- **errorMessage** (string) - If the job failed, this contains the error message.

#### Response Example
```json
{
  "id": "job_abc123",
  "status": "COMPLETED",
  "outputs": {
    "vocals": {
      "url": "https://stemsplit.io/results/job_abc123_vocals.mp3",
      "format": "MP3"
    },
    "instrumental": {
      "url": "https://stemsplit.io/results/job_abc123_instrumental.mp3",
      "format": "MP3"
    }
  }
}
```
```

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

### Get Job Status and Results API

Source: https://stemsplit.io/developers/guides/zapier

Retrieves the status and output URLs for a previously created stem separation job.

```APIDOC
## GET /api/v1/jobs/{job_id}

### Description
Fetches the status and download URLs for a specific audio processing job using its ID.

### Method
GET

### Endpoint
https://stemsplit.io/api/v1/jobs/{{4. ID from Create Job}}

### Parameters
#### Path Parameters
- **job_id** (string) - Required - The unique identifier of the job to retrieve.

#### Headers
- **Authorization** (string) - Required - `Bearer sk_live_xxx`

### Response
#### Success Response (200)
- **id** (string) - The job ID.
- **status** (string) - The current status of the job (e.g., "COMPLETED", "FAILED").
- **outputs** (object) - Contains URLs for the separated stems if the job is completed.
  - **vocals** (object) - Details for vocal stems.
    - **url** (string) - Download URL for the vocal stem.
  - **instrumental** (object) - Details for instrumental stems.
    - **url** (string) - Download URL for the instrumental stem.
  - (Other stem types may be present depending on `outputType`)

#### Response Example
```json
{
  "id": "job_abc123",
  "status": "COMPLETED",
  "outputs": {
    "vocals": {
      "url": "https://stemsplit.io/output/vocals_xyz.mp3"
    },
    "instrumental": {
      "url": "https://stemsplit.io/output/instrumental_xyz.mp3"
    }
  }
}
```
```

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

### Create Job with HTTP POST Request in Make

Source: https://stemsplit.io/developers/guides/make

This snippet demonstrates how to add an HTTP module in Make to send a POST request to the StemSplit API to create a new audio processing job. It includes the endpoint URL, HTTP method, required headers (Authorization and Content-Type), and a sample JSON request body with placeholders for source URL and output preferences.

```json
{
  "sourceUrl": "{{1.url}}",
  "outputType": "BOTH",
  "quality": "BEST",
  "outputFormat": "MP3"
}
```

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

### Batch Process Songs for Karaoke with StemSplit API (Python)

Source: https://stemsplit.io/developers/guides/openkj

This Python snippet outlines a batch processing approach using the StemSplit API. It iterates through a list of audio file URLs, sending individual requests to create instrumental versions. This is useful for processing multiple songs efficiently. Ensure your API key and storage URLs are correctly configured.

```python
# Example Python snippet for batch processing
import requests

api_key = "sk_live_xxx"

song_urls = [
    "https://your-storage.com/song1.mp3",
    "https://your-storage.com/song2.mp3",
    "https://your-storage.com/song3.mp3"
]

for url in song_urls:
    payload = {
        "sourceUrl": url,
        "outputType": "INSTRUMENTAL",
        "quality": "BEST",
        "outputFormat": "MP3"
    }
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    response = requests.post("https://stemsplit.io/api/v1/jobs", json=payload, headers=headers)
    
    if response.status_code == 200:
        print(f"Job created for {url}: {response.json()}")
    else:
        print(f"Error creating job for {url}: {response.status_code} - {response.text}")

```

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

### Create Job with Upload Key using cURL

Source: https://stemsplit.io/developers/index

This example shows how to create an audio separation job after uploading a file directly. It uses a POST request to the /api/v1/jobs endpoint, providing the uploadKey received after the file upload and any desired job options.

```curl
POST /api/v1/jobs \
  -H "Authorization: Bearer sk_live_xxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "uploadKey": "upload_key_from_previous_step",
    "outputType": "STEMS",
    "quality": "HIGH"
  }'
```

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

### StemSplit API - Get Job Results

Source: https://stemsplit.io/developers/guides/power-automate

Retrieve the status and results of a previously created audio processing job using its unique job ID.

```APIDOC
## GET /api/v1/jobs/{jobId}

### Description
Retrieves the status and output URLs for a specific audio processing job.

### Method
GET

### Endpoint
`https://stemsplit.io/api/v1/jobs/{jobId}`

### Parameters
#### Path Parameters
- **jobId** (string) - Required - The unique identifier of the job to retrieve.

#### Headers
- **Authorization** (string) - Required - `Bearer sk_live_xxx` (Your StemSplit API key)

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the job.
- **status** (string) - The current status of the job (e.g., 'PROCESSING', 'COMPLETED', 'FAILED').
- **outputs** (object) - Contains URLs for the processed audio stems if the job is completed.

#### Response Example
```json
{
  "id": "job_abc123",
  "status": "COMPLETED",
  "outputs": {
    "vocals": {
      "url": "https://stemsplit.io/output/vocals.mp3",
      "size": 1024000
    },
    "instrumental": {
      "url": "https://stemsplit.io/output/instrumental.mp3",
      "size": 1234567
    }
  }
}
```
```

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

### Audio Separation Job Request Example

Source: https://stemsplit.io/developers/index

This JSON object represents a sample request payload for creating an audio separation job. It specifies the remote URL of the audio file to be processed, the desired output format (e.g., 'BOTH' for stems and separated tracks), and the quality level.

```json
{
  "sourceUrl": "https://example.com/song.mp3",
  "outputType": "BOTH",
  "quality": "BEST"
}
```

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

### Retrieve StemSplit Job Status via HTTP GET

Source: https://stemsplit.io/developers/guides/power-automate

This action sends a GET request to the StemSplit API to retrieve the status and results of a previously created job. It uses the job ID obtained from the 'Create Job' step. The response contains URLs for the processed audio stems.

```http
GET https://stemsplit.io/api/v1/jobs/@{body('HTTP')['id']}
Authorization: Bearer sk_live_xxx
```

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

### Error Response Structure

Source: https://stemsplit.io/developers/docs

This is the standard JSON format for error responses from the Stemsplit.io API. It includes an error code, a descriptive message, and any relevant details like required credits or duration.

```json
{
  "error": {
    "code": "INSUFFICIENT_CREDITS",
    "message": "Not enough credits for this job.",
    "requiredSeconds": 180
  }
}
```

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

### Batch Process Songs for Stem Separation with Python

Source: https://stemsplit.io/developers/guides/sample-packs

Automates the process of uploading and separating stems from multiple songs using the StemSplit API. This Python script requires the 'requests' library and an API key. It takes a list of song filenames and sends POST requests to the API endpoint, specifying output type and quality.

```python
import requests
import os

API_KEY = "sk_live_xxx"
SONGS = ["song1.mp3", "song2.mp3", "song3.mp3"]

for song in SONGS:
    # Upload and process each song
    response = requests.post(
        "https://stemsplit.io/api/v1/jobs",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={
            "sourceUrl": f"https://your-storage.com/{song}",
            "outputType": "ALL_STEMS",
            "quality": "BEST"
        }
    )
    print(f"Processing {song}: Job ID {response.json()['id']}")
```

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

### Poll Job Status using cURL

Source: https://stemsplit.io/developers/index

This example demonstrates how to check the status of an ongoing audio separation job by polling the API. It involves a GET request to the /api/v1/jobs/:id endpoint, where :id is the unique identifier of the job.

```curl
GET /api/v1/jobs/:id
```

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

### Run Discord Bot Locally (Shell)

Source: https://stemsplit.io/developers/guides/discord-bot

This command initiates the Node.js Discord bot. Ensure you have Node.js installed and your environment variables (DISCORD_TOKEN, STEMSPLIT_API_KEY) are set up.

```shell
node index.js
```

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

### n8n Switch Node Configuration for Job Events

Source: https://stemsplit.io/developers/guides/n8n

Configure an n8n Switch node to route incoming webhook events based on their type. This example routes events to 'Completed' or 'Failed' outputs based on the 'event' field.

```JSON
{
  "Mode": "Rules",
  "Rules": [
    {
      "Output": "Completed",
      "Conditions": {
        "String": {
          "Value1": "{{ $json.event }}",
          "Operation": "equals",
          "Value2": "job.completed"
        }
      }
    },
    {
      "Output": "Failed",
      "Conditions": {
        "String": {
          "Value1": "{{ $json.event }}",
          "Operation": "equals",
          "Value2": "job.failed"
        }
      }
    }
  ]
}
```

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

### Processing Webhook Payload from StemSplit (Conceptual)

Source: https://stemsplit.io/developers/guides/zapier

This example shows how to access the processed stem URLs from a webhook payload sent by StemSplit. The structure typically includes a 'data' object containing 'outputs' for different stem types.

```json
{
  "data": {
    "outputs": {
      "vocals": {
        "url": "https://stemsplit.io/path/to/vocals.mp3"
      },
      "instrumental": {
        "url": "https://stemsplit.io/path/to/instrumental.mp3"
      }
    }
  }
}
```

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

### Poll Job Status (cURL)

Source: https://stemsplit.io/developers/docs

This cURL command polls the status of a specific stem separation job using its ID. It requires authentication. A completed job response will include URLs for the extracted stems, which are valid for a limited time.

```shell
curl https://stemsplit.io/api/v1/jobs/clxxx123 \
  -H "Authorization: Bearer sk_live_xxx"
```

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

### Audio Separation Job Response Example

Source: https://stemsplit.io/developers/index

This JSON object illustrates a typical response from the StemSplit API after creating a job. It includes a unique job ID, the initial status ('PENDING'), progress, the number of credits consumed, and details about the input audio file.

```json
{
  "id": "clxxx123...",
  "status": "PENDING",
  "progress": 0,
  "creditsRequired": 180,
  "input": {
    "fileName": "song.mp3",
    "durationSeconds": 180
  }
}
```

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

### Verify Webhook Signature using Python

Source: https://stemsplit.io/developers/docs

This Python function verifies the integrity of incoming webhook payloads by comparing the provided signature with a computed one using a shared secret. It's crucial for ensuring that the webhook data originates from Stemsplit.io.

```python
import hmac
import hashlib

def verify_webhook(payload: bytes, signature: str, secret: str) -> bool:
    """Verify webhook signature"""
    expected = "sha256=" + hmac.new(
        secret.encode(),
        payload,
        hashlib.sha256
    ).hexdigest()
    return hmac.compare_digest(expected, signature)

# In your webhook handler:
@app.post("/webhook")
def handle_webhook(request):
    signature = request.headers.get("X-Webhook-Signature")
    if not verify_webhook(request.body, signature, WEBHOOK_SECRET):
        return {"error": "Invalid signature"}, 401
    
    data = request.json()
    if data["event"] == "job.completed":
        # Process completed job
        print(f"Job {data['data']['jobId']} completed!")
```
Tokens:
Raw