ForHosting KIT · Audio & Voice

Podcast ad slot timestamp calculator

Turn a podcast episode duration and three percentage-based ad positions into exact, production-ready timestamps.

● BetaFree · in your browser
Use it from WebAPIEmailTelegramApp soon

Enter the duration in seconds, choose where the pre-roll, mid-roll, and post-roll should occur from 0 to 100 percent, and receive both numeric offsets and readable timecodes. The calculation is deterministic, so producers, ad operations teams, and publishing systems can use the same placement rules repeatedly without dragging a playhead across every episode or estimating positions by hand.

Convert campaign percentages into edit-ready timestamps

Podcast advertising plans often describe placement as a percentage because a relative position transfers cleanly between episodes of different lengths. A direction such as “place the mid-roll at 50 percent” is easy to standardize, but an editor or publishing system still needs an exact timecode. This calculator multiplies the episode duration by each requested percentage and returns the resulting offset in seconds together with a readable HH:MM:SS.mmm timestamp. Provide the full duration in seconds, then enter one percentage for the pre-roll, mid-roll, and post-roll. For a 3,600-second episode, 2.5 percent becomes 90 seconds, 50 percent becomes 1,800 seconds, and 97.5 percent becomes 3,510 seconds. The named results keep each placement attached to its intended role, reducing the chance that values are copied into the wrong field. Because the same deterministic arithmetic is used every time, the output is suitable for production notes, insertion manifests, approval sheets, and automated workflows that need consistent ad markers across an episode catalog.

Understand precision, boundaries, and validation

Every percentage is measured from the start of the episode. Zero percent therefore resolves to the opening timestamp, while 100 percent resolves to the exact episode duration. Values between those boundaries produce proportional positions, including fractional percentages such as 12.5 or 87.25. Numeric offsets are returned with up to six decimal places, and display timestamps are rounded to the nearest millisecond, which matches the precision commonly used by audio editing and publishing interfaces. The calculator rejects a percentage below 0 or above 100 instead of silently clipping it, because clipping could move an advertisement to a materially different location while making the request appear successful. It also rejects missing, nonnumeric, infinite, or nonpositive durations. These checks make mistakes visible before timestamps reach an insertion workflow. The calculator does not decide whether a chosen location is editorially appropriate, detect speech boundaries, or move a marker away from music or dialogue. It performs the percentage-to-time conversion exactly and leaves content-aware placement decisions to the producer or a separate analysis tool.

Use the results in podcast production workflows

The returned slot list is ordered as pre-roll, mid-roll, and post-roll, with each record containing the original percentage, a numeric second offset, and a formatted timestamp. A producer can paste the readable value into an edit decision list or episode worksheet, while an integration can consume the numeric offset without parsing a timecode string. This dual representation is useful when one team reviews placements visually and another sends structured values to an ad server. For recurring shows, keep the campaign percentages as the stable policy and run each new episode duration through the calculator. That approach preserves the intended relative spacing even when episode lengths vary from week to week. Before publishing, compare the markers with the final mastered file rather than an earlier rough cut, because trimming an intro or adding credits changes the total duration and therefore every proportional timestamp. The API price is $0.002 per request, while the browser implementation uses the same calculation logic. No audio upload is required: only duration and percentage values are processed, so the calculation can fit into lightweight planning and automation steps.

Prepare an ad insertion sheet

Convert a sponsor's percentage-based placement plan into timestamps an editor can enter directly into an episode worksheet.

Standardize placements across a series

Apply the same relative pre-roll, mid-roll, and post-roll policy to episodes whose final durations vary each week.

Feed an automated publishing workflow

Use numeric second offsets in an integration while retaining readable timecodes for human review and approval.

What does the calculator cost through the API?

Each API request costs $0.002. The calculation can also run in the browser using the same deterministic logic.

What unit should I use for episode duration?

Enter the complete episode duration in seconds. Decimal seconds are accepted when the source duration includes subsecond precision.

Can a percentage be exactly 0 or 100?

Yes. Zero points to the beginning of the episode, and 100 points to the episode's ending timestamp.

What happens when a percentage is outside the allowed range?

The request returns an invalid input error identifying the percentage field. Values are never clipped or wrapped into range.

How precise are the returned timestamps?

Numeric offsets retain up to six decimal places, and the readable timecode is rounded to the nearest millisecond.

Does this tool inspect or upload my podcast audio?

No. It uses only the duration and percentages you provide; it does not receive, analyze, or store an audio file.

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.

POSThttps://api.kit.forhosting.com/audio/podcast-ad-slot-timing

Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.

curl -X POST https://api.kit.forhosting.com/audio/podcast-ad-slot-timing \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"duration_seconds":3600,"pre_roll_percent":2.5,"mid_roll_percent":50,"post_roll_percent":97.5}'
{
  "duration_seconds": 3600,
  "pre_roll_percent": 2.5,
  "mid_roll_percent": 50,
  "post_roll_percent": 97.5
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "audio.podcast_ad_slot_timing",
  "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.

Per request$0.002

Published price — no tokens, no invented credits. A failed task is never charged.

max_mb200
max_minutes180
HTTPCodeMeaning
401unauthorizedMissing or invalid API key.
402insufficient_balanceYour balance doesn't cover the task price.
404unknown_typeThat task type doesn't exist.
429rate_limitedToo many requests. Use the webhook instead of polling.

Read the full KIT documentation →