A common follow-up once people start editing their Hit the Road Dude clip: they add a line of their own ("hit the road, d—"), or they want a clean version for a work chat or a family group. Then they ask an assistant "how do I bleep one word in a video?" The usual answer is a one-liner with a hard-coded time. It almost works. The beep lands where you think the word is, and the first syllable sticks out in front of it.

This post does it in a way you can check. You give a rough time ("somewhere around 1.9 s"). The script finds the edges of the word near that time, mutes exactly that span, lays a 1 kHz tone over it, and copies the video stream untouched. Then it measures three things: is the beep window really only tone, is the rest of the audio unchanged, and did any of the word survive outside the beep.

Context: the generated clips at hittheroaddude.app are 15 seconds, vertical, with a newly generated voice rather than the original recording (original audio or a new voice). That matters here: whatever you bleep is your own edit or your own recorded line, not the source TikTok. I tested everything below on a synthetic test line. No real voices and no customer clips are used.

A test line with known word edges

Four "words" made of harmonic bursts with a syllable-shaped envelope on a quiet noise floor, in a 4-second vertical clip. The third word is the one to bleep, and the script prints where every word really starts and ends, so we can grade the result.

#!/usr/bin/env python3 """Make test_line.mp4: a 4-second vertical clip whose audio is four voice-like "words" (harmonic bursts with a syllable envelope) on a quiet room-noise floor. The third word is the one to bleep. True word boundaries are printed so the bleep can be checked. Fixed seed, 48 kHz mono.""" import subprocess, wave import numpy as np SR = 48000 rng = np.random.default_rng(1116) dur = 4.0 t = np.arange(int(SR * dur)) / SR audio = rng.normal(0, 0.002, t.size) # room noise, about -54 dBFS words = [(0.40, 0.78, 140), (0.95, 1.30, 125), (1.62, 2.08, 150), (2.30, 2.95, 118)] for start, end, f0 in words: m = (t >= start) & (t < end) tt = t[m] - start env = np.sin(np.pi * tt / (end - start)) ** 0.6 # syllable-shaped envelope vib = 1 + 0.03 * np.sin(2 * np.pi * 5 * tt) voice = sum(np.sin(2 * np.pi * f0 * k * vib * tt) / k for k in range(1, 12)) audio[m] += 0.18 * env * voice audio = np.clip(audio, -1, 1) with wave.open("test_line.wav", "wb") as w: w.setnchannels(1); w.setsampwidth(2); w.setframerate(SR) w.writeframes((audio * 32767).astype("<i2").tobytes()) subprocess.run(["ffmpeg", "-v", "error", "-y", "-f", "lavfi", "-i", "color=c=0x6b8e5a:s=432x768:r=24:d=4", "-i", "test_line.wav", "-c:v", "libx264", "-pix_fmt", "yuv420p", "-c:a", "aac", "-b:a", "160k", "-shortest", "test_line.mp4"], check=True) for i, (s, e, _) in enumerate(words, 1): print(f"word {i}: {s:.2f}-{e:.2f} s") 
$ python3 make_bleep_test_clip.py word 1: 0.40-0.78 s word 2: 0.95-1.30 s word 3: 1.62-2.08 s word 4: 2.30-2.95 s 

The script

Detection is deliberately simple: RMS in 10 ms frames, and "voiced" means 15 dB above the room noise (the 10th percentile of all frames). It picks the voiced run that contains your rough time, or the one nearest to it, and pads it by 30 ms on both sides. The bleep is two filters and a mix:

  • volume=enable='between(t,START,END)':volume=0 mutes the original only inside the window.
  • A sine source, gated with the opposite enable expression, is silent everywhere except inside the window.
  • amix ... normalize=0 adds them without the automatic level drop amix applies by default.

The video is -c:v copy, so it is bit-identical and sync can't move. The script checks that too.

#!/usr/bin/env python3 """Bleep one word in a clip: find the word around a rough time, mute exactly that span, lay a 1 kHz tone over it, keep the video stream untouched, then verify. usage: bleep.py in.mp4 out.mp4 --near 1.9 [--pad 0.03] [--tone 1000] [--span START END] --near roughly when you hear the word (seconds); the script snaps to the word's edges --span skip detection and bleep exactly START..END """ import argparse, json, subprocess import numpy as np SR = 48000 def pcm(path): raw = subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-vn", "-ac", "1", "-ar", str(SR), "-f", "s16le", "-"], capture_output=True, check=True).stdout return np.frombuffer(raw, "<i2").astype(np.float64) / 32768 def find_word(x, near, hop=0.01): """Return (start, end) of the voiced burst that contains, or is nearest to, `near`.""" n = int(SR * hop) frames = x[: len(x) // n * n].reshape(-1, n) db = 20 * np.log10(np.sqrt((frames ** 2).mean(axis=1)) + 1e-9) floor = np.percentile(db, 10) voiced = db > floor + 15 # 15 dB above the room noise runs, i = [], 0 while i < len(voiced): if voiced[i]: j = i while j < len(voiced) and voiced[j]: j += 1 runs.append((i * hop, j * hop)); i = j else: i += 1 runs = [r for r in runs if r[1] - r[0] >= 0.08] # drop clicks if not runs: raise SystemExit("no voiced audio found") return min(runs, key=lambda r: 0 if r[0] <= near <= r[1] else min(abs(near - r[0]), abs(near - r[1]))) def band_share(seg, f0, width=60): spec = np.abs(np.fft.rfft(seg * np.hanning(len(seg)))) ** 2 freqs = np.fft.rfftfreq(len(seg), 1 / SR) return spec[(freqs > f0 - width) & (freqs < f0 + width)].sum() / spec.sum() def bleep(src, dst, start, end, tone): mute = f"volume=enable='between(t,{start:.3f},{end:.3f})':volume=0" gate = f"volume=enable='not(between(t,{start:.3f},{end:.3f}))':volume=0" graph = (f"[0:a]aresample={SR},aformat=channel_layouts=mono,{mute}[v];" f"sine=frequency={tone}:sample_rate={SR},volume=1.6,{gate}[b];" f"[v][b]amix=inputs=2:duration=first:normalize=0[a]") subprocess.run(["ffmpeg", "-v", "error", "-y", "-i", src, "-filter_complex", graph, "-map", "0:v?", "-map", "[a]", "-c:v", "copy", "-c:a", "aac", "-b:a", "160k", "-movflags", "+faststart", dst], check=True) def duration(path, stream): out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", stream, "-show_entries", "stream=duration", "-of", "json", path], capture_output=True, text=True).stdout return float(json.loads(out)["streams"][0]["duration"]) def video_md5(path): return subprocess.run(["ffmpeg", "-v", "error", "-i", path, "-map", "0:v:0", "-c", "copy", "-f", "md5", "-"], capture_output=True, text=True).stdout.strip() def verify(src, dst, start, end, tone): a, b = pcm(src), pcm(dst) s, e = int(start * SR), int(end * SR) inside = b[s + 480:e - 480] # skip 10 ms at each edge share = band_share(inside, tone) outside = np.r_[a[: s - 4800], a[e + 4800: len(b)]], np.r_[b[: s - 4800], b[e + 4800:]] n = min(len(outside[0]), len(outside[1])) corr = np.corrcoef(outside[0][:n], outside[1][:n])[0, 1] print(f"bleep window {start:.2f}-{end:.2f} s: {share * 100:.1f}% of the energy is the {tone} Hz tone") print(f"audio outside the window vs original: correlation {corr:.4f}") ws, we = find_word(a, (start + end) / 2) left, right = max(0.0, start - ws), max(0.0, we - end) print(f"target word in the original: {ws:.2f}-{we:.2f} s; left audible: " f"{left * 1000:.0f} ms before the beep, {right * 1000:.0f} ms after" + (" <- widen the span" if left + right > 0 else "")) same = video_md5(src) == video_md5(dst) print(f"video stream bit-identical to the original: {same}") print(f"durations: video {duration(src, 'v:0'):.3f} -> {duration(dst, 'v:0'):.3f} s, " f"audio {len(a) / SR:.3f} -> {len(b) / SR:.3f} s") if __name__ == "__main__": ap = argparse.ArgumentParser() ap.add_argument("src"); ap.add_argument("dst") g = ap.add_mutually_exclusive_group(required=True) g.add_argument("--near", type=float) g.add_argument("--span", type=float, nargs=2) ap.add_argument("--pad", type=float, default=0.03) ap.add_argument("--tone", type=float, default=1000) a = ap.parse_args() if a.span: start, end = a.span else: ws, we = find_word(pcm(a.src), a.near) print(f"word found at {ws:.2f}-{we:.2f} s (you said ~{a.near})") start, end = max(0, ws - a.pad), we + a.pad bleep(a.src, a.dst, start, end, a.tone) verify(a.src, a.dst, start, end, a.tone) 

Results

Snapping to the word from a rough time:

$ python3 bleep.py test_line.mp4 bleeped.mp4 --near 1.9 word found at 1.62-2.08 s (you said ~1.9) bleep window 1.59-2.11 s: 100.0% of the energy is the 1000 Hz tone audio outside the window vs original: correlation 1.0000 target word in the original: 1.62-2.08 s; left audible: 0 ms before the beep, 0 ms after video stream bit-identical to the original: True durations: video 4.000 -> 4.000 s, audio 4.011 -> 4.011 s 

The same job done the usual way, with a fixed span typed in from listening (1.75 to 2.05 s):

$ python3 bleep.py test_line.mp4 naive.mp4 --span 1.75 2.05 bleep window 1.75-2.05 s: 100.0% of the energy is the 1000 Hz tone audio outside the window vs original: correlation 1.0000 target word in the original: 1.62-2.08 s; left audible: 130 ms before the beep, 30 ms after <- widen the span video stream bit-identical to the original: True 

Both files "have a beep", but only one hides the word. Inside the naive window everything is tone, which is why a quick listen sounds fine. The 130 ms before it is the start of the word, and that's often the part that makes the word recognisable. People hear words from their onsets. A beep that starts late is a censor that doesn't censor.

What the numbers mean:

  • 100.0% tone inside the window (rounded): the mute worked. Nothing of the voice is mixed under the beep.
  • Correlation 1.0000 outside the window: the audio around it is unchanged apart from AAC re-encoding. You can't avoid that re-encode once you edit the audio, but it doesn't shift anything.
  • Same durations, video bit-identical: nothing moved, so lip sync is exactly what it was. (The 4.011 s audio length is AAC's normal padding and is the same in the input.)
  • Level: I set the tone so that it sits about where the voice does. Over the word it measured -17.0 dBFS RMS against -18.2 dBFS for the word itself. A beep much quieter than the voice sounds like a mistake, and a much louder one is unpleasant on earbuds.

Practical notes

  • Get the rough time from your editor or from captions. If you have word timestamps (from an auto-caption tool), pass the middle of the word as --near. The script only needs to be in the right neighbourhood.
  • Words that run into each other have no gap for the detector to find. Then the voiced run covers two words. The script will report a long span, and you should use --span with times you've checked by ear.
  • Clicks at the beep edges: the tone is switched on and off hard. On this test it sounds like a normal TV bleep. If you want it softer, swap the gate for a short afade in and out on the tone.
  • Mouth still visible: the audio is clean, but a lip-reader can still see the word. If that matters, blur or cover the mouth for the same window with boxblur plus enable='between(t,...)'. Then the video has to be re-encoded, so you lose the bit-identical guarantee.

Before you post

Bleeping doesn't change what the clip is: a generated comedy remake. The check-before-posting guide covers what to watch for in the clip itself and how to label it. Use only a photo of yourself, an adult who agreed, or your own pet.

For reference, checked on November 16, 2026 at 09:34 (UTC+8): one clip at hittheroaddude.app is $9.99 at 480p (6 credits) or $12.99 at 720p (14 credits), and signed-in accounts can buy packs of 30 credits for $27.99, 100 for $71.99 or 200 for $129.99, one-time with no renewal (pricing).