Split audio
Turn a ninety-minute recording into the pieces you need: chapters at exact timestamps, a two-minute teaser, or equal segments of a fixed length, each delivered as its own file. No waveform editor, no cutting by hand. Pay per use, no subscription.
This task is not available right now, so it cannot be purchased. Nothing is charged for it.
How it works & APIA ninety-minute recording is rarely useful as ninety minutes: you need the three-minute highlight, the individual speaker turns, or ten equal chunks for a playlist.
One long file, many useful pieces
A ninety-minute recording is rarely useful as ninety minutes. You need the three-minute highlight, each chapter of a narration, or ten equal chunks for a playlist. One cut in a desktop editor is easy; repeating it fifty times across an archive is not. This tool takes the source file and a single description of the cuts, either exact timestamps or a fixed segment length, and returns every piece as its own file, in order, so nobody has to sit in front of a waveform all day.
Timestamps or equal lengths: which to choose
Use timestamps when you know the moments that matter: the chapter starts an audiobook distributor requires, the two-minute teaser inside a full episode, or the start of each customer call in a long call-center session. Use a fixed length when you want mechanical division, for example equal clips for review or analysis. The cuts are precise to the millisecond, so check your markers against the recording before sending them; a marker a little early clips the first word of the next part. You pay per use, with no subscription.
Why cutting audio by hand doesn't scale
A single edit in a desktop tool is easy; doing it fifty times across an archive of recordings is not. Audiobook publishers dividing a manuscript reading into chapters, podcast networks trimming a raw recording into episode-length pieces, and call-center teams isolating individual calls from one long recording session all face the same repetitive task, and none of them want an editor open all day to do it.
What you can do with it
Audiobook chaptering
Cut one long narration file at chapter timestamps to produce the individual chapter files a distributor requires.
Podcast highlight extraction
Pull a specific two-minute segment out of a full episode to publish as a standalone teaser clip.
Recorded call isolation
Split one continuous call-center recording session into the individual customer calls it contains.
Equal-length training clips
Divide a long recording into fixed-duration segments to feed a downstream analysis or review pipeline.
FAQ
Can I split audio by exact timestamps instead of equal chunks?
Yes, you can specify explicit cut points, or ask for fixed-duration segments if you just want equal-length pieces.
What formats can I split?
It accepts standard audio formats commonly used for recordings, narration and calls.
How do I get the split files back?
All the segments arrive together as an ordered set of separate files, so nobody has to cut the long recording again. They are available through a secure download link that stays valid for 24 hours.
How precise are the cut points when splitting audio?
Cuts land where you put them, precise to the millisecond. Check your markers against the recording first, because a marker placed slightly early will clip the first word of the next segment.
Does splitting tell me how big each file will be?
No. This tool cuts the recording into separate files at the points you set; it does not predict file sizes or bitrates. For a size estimate before you record or export, use an audio file size calculator instead.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
One authenticated POST creates the task; the result comes back by webhook or a signed link. This capability is currently available through the API, not as an interactive Web tool.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/audio/split \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"audio":"https://example.com/clip.mp3"}'const res = await fetch("https://api.kit.forhosting.com/audio/split", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"audio": "https://example.com/clip.mp3"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/audio/split",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"audio": "https://example.com/clip.mp3"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/audio/split", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"audio":"https://example.com/clip.mp3"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"audio":"https://example.com/clip.mp3"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/audio/split", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"audio": "https://example.com/clip.mp3"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "audio.split",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 200 |
max_minutes | 180 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
This split audio file API cuts one input into the exact segments you specify and returns each piece as its own file, without you touching a waveform editor.
Why cutting audio by hand doesn't scale
The split endpoint turns that repetitive cutting into a single specification you send once.
How you tell it where to cut
You submit the source audio file to POST /audio/split along with the cut points, either explicit timestamps or a fixed segment duration, and the task queues asynchronously and returns a task_id right away. When the split completes, each resulting segment is delivered together through a signed webhook or a signed link valid for 24 hours, so your system receives a clean, ordered set of files rather than one long recording you'd still have to cut yourself.
Splitting has always been the other half of editing
Long before digital audio, tape editors physically cut and spliced reels to isolate a segment; the goal was always the same, extracting the useful part from the whole. Timestamp-based splitting is the direct descendant of that razor blade, just precise to the millisecond and applied through an API call instead of a tape deck, which is why it remains one of the most requested operations in any audio pipeline regardless of how the source was recorded.
Where it plugs into automation
Because the endpoint accepts either timestamps or fixed durations, it covers both use cases automation usually needs: precise extraction of a known moment, and mechanical division into equal chunks for batch processing. Pricing is $0.077 per request plus $0.0045 per minute of the source audio, so cost is tied to what you send in, not the number of segments produced, and a task that fails after automatic retries is never billed.
Access and status
As with every endpoint, calling it requires prepaid balance; without one the API responds with HTTP 402 rather than a partial result. This endpoint is currently in deployment and will begin accepting jobs soon; source audio and generated segments are retained only long enough to deliver your result and are never used to train models.
Technical questions
How do I split an audio file into segments?
Send the file to POST /audio/split with either timestamps or a fixed duration, and the task returns each resulting segment via webhook or a signed link.
Is there a free way to split audio with this API?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
How much does splitting an audio file cost?
It costs $0.077 per request plus $0.0045 per minute of the source audio, regardless of how many segments the cut produces.
Is the split audio API live yet?
It is currently in deployment and will start accepting jobs soon; the cutting behavior and pricing described here are what will ship at launch.
How precise are the cut points?
Cuts are made at the timestamps or duration boundaries you provide, so precision matches what you specify in the request.
How do I retrieve the split segments?
Results are delivered through a signed webhook, the recommended method, or a signed link valid for 24 hours.