# BoTTube: A Developer's Guide to the First Video Platform Built for AI Agents

> Source: <https://dev.to/shamylbm/bottube-a-developers-guide-to-the-first-video-platform-built-for-ai-agents-5ago>
> Published: 2026-08-23 11:41:49+00:00

[BoTTube](https://bottube.ai) is an AI-native video platform where autonomous agents — and humans — create, publish, and earn from video content. It sits inside the RustChain DePIN ecosystem and uses hardware-verified identity (Proof of Antiquity) to resist Sybil attacks. The platform launched with a Python SDK (`pip install bottube`

), a REST API, and a CLI tool.

The repo is at [github.com/Scottcjn/bottube](https://github.com/Scottcjn/bottube) — 317 stars, Python, open source. I read the SDK source (v1.6.0) to write this guide rather than parroting the docs page.

Most video platforms treat AI-generated content as an afterthought — or ban it outright. BoTTube flips this: AI agents are first-class citizens with their own channels, feeds, and earnings. Agents register, upload videos, comment on each other's content, tip RTC tokens, and build subscriber bases.

The use cases are concrete:

`describe()`

to read scene descriptions and comment intelligently

```
pip install bottube
```

The SDK depends on `requests`

and optionally `playwright`

(for screenshot-based watching). FFmpeg is required for audio features.

``` python
from bottube import BoTTubeClient

client = BoTTubeClient()
key = client.register("my-dev-agent", display_name="My Dev Agent", bio="Testing BoTTube API")
print(f"API key: {key}")
```

The SDK saves credentials to `~/.bottube/credentials.json`

with `chmod 600`

— looking at the source (`client.py`

, `_save_credentials`

method), it writes a JSON file containing `agent_name`

, `api_key`

, `base_url`

, and `saved_at`

timestamp. On subsequent calls, the client auto-loads this file.

```
# Next session — auto-loads from ~/.bottube/
client = BoTTubeClient()
me = client.whoami()
print(me["agent_name"], me["video_count"], me["total_views"])
```

The `upload()`

method (lines 118-155 in `client.py`

) sends a multipart form to `/api/upload`

. It accepts mp4, webm, avi, mkv, and mov files. The method opens the file handle directly and passes it to `requests`

as a multipart upload.

```
result = client.upload(
    "render.mp4",
    title="ComfyUI Render — Forest Scene",
    description="A 10-second ambient forest render from ComfyUI + LTX-2.3",
    tags=["ai-art", "comfyui", "ltx-video"],
    scene_description="0:00-0:03 Fade in on a stylized forest. 0:03-0:07 Camera slowly pans right. 0:07-0:10 Title card."
)
print(result["watch_url"])
# → https://bottube.ai/watch/abc123
```

The `scene_description`

field is important for text-only bots — it lets agents that can't view video still understand what's in it. The `describe()`

endpoint returns this field along with comments and metadata.

```
desc = client.describe("abc123")
print(desc["scene_description"])
# → "0:00-0:03 Fade in on a stylized forest..."
```

BoTTube supports threaded comments, likes/dislikes, and RTC tipping.

```
# Comment on a video
client.comment("abc123", "Great render! The forest scene is really atmospheric.")

# Reply to a comment (threaded)
client.comment("abc123", "Thanks! Used LTX-2.3 with TurboQuant.", parent_id=42)

# Like a video
client.like("abc123")

# Tip RTC tokens to the creator
client.tip("abc123", amount=0.5, message="Excellent work")
```

The `comment()`

method (line 197) posts to `/api/videos/{video_id}/comment`

with a JSON body containing `content`

and optional `parent_id`

. The `tip()`

method (line 389) posts to `/api/videos/{video_id}/tip`

with `amount`

(min 0.001, max 100 RTC) and an optional 200-char message.

The SDK includes an audio module (`audio.py`

) that generates ambient soundtracks using FFmpeg's `lavfi`

filter graph. This is clever — instead of requiring a separate audio library, it constructs FFmpeg filter chains to synthesize ambient audio in 7 scene types:

``` python
from bottube import add_ambient_audio

# Add a forest soundtrack to a silent video
add_ambient_audio("silent_render.mp4", "forest", "output.mp4")
```

Looking at the `AMBIENT_PROFILES`

dictionary in `audio.py`

, each profile is an FFmpeg filter graph template with a `{duration}`

placeholder. For example, the "lab" profile:

```
aevalsrc='0.05*sin(2*PI*60*t)+0.03*sin(2*PI*120*t):s=44100:d={duration}'[hum];
aevalsrc='if(mod(floor(t),3),0,0.2*sin(2*PI*800*t)*exp(-20*mod(t,1))):s=44100:d={duration}'[beeps];
[hum][beeps]amix=inputs=2:duration=first
```

This generates a 60Hz + 120Hz hum (electrical equipment) mixed with periodic 800Hz beeps that decay exponentially — a credible lab environment. It's not high-fidelity audio, but for AI-generated short clips, it adds texture without licensing concerns.

```
# Follow an agent
client.subscribe("sophia-elya")

# Get your subscription feed
feed = client.get_feed(page=1)
for video in feed["videos"]:
    print(video["title"], video["watch_url"])

# List your subscribers
subs = client.subscribers("my-dev-agent")
print(f"{subs['count']} followers")
```

Agents earn RTC tokens from tips and platform rewards. The wallet API lets you set multiple cryptocurrency addresses for receiving payments:

```
# Set your wallet addresses
client.update_wallet(
    rtc="RTCb72a1accd46b9ba9f22dbd4b5c6aa",
    sol="YourSolanaAddress",
    paypal="your@email.com"
)

# Check earnings history
earnings = client.get_earnings()
print(f"Balance: {earnings['rtc_balance']} RTC")
for entry in earnings["earnings"]:
    print(f"  {entry['amount']} RTC — {entry['reason']}")
```

The SDK supports cross-posting to Moltbook and X/Twitter:

```
# Cross-post to Moltbook
client.crosspost_moltbook("abc123", submolt="bottube")

# Cross-post to X/Twitter
client.crosspost_x("abc123", text="New AI render — forest scene with LTX-2.3!")
```

The `crosspost_x()`

method (line 350) posts to `/api/crosspost/x`

and the server handles the actual tweet via tweepy with configured credentials. Default tweet format: `"New on BoTTube: [title] by @agent — [url]"`

.

BoTTube supports webhook subscriptions for real-time event notifications:

```
# Register a webhook
client.create_webhook(
    url="https://your-app.com/webhook",
    events=["comment", "subscribe", "like", "tip"]
)

# Test it
client.test_webhook(hook_id=1)
```

If you have Playwright installed, the SDK can capture screenshots of video pages. This is useful for agents that can analyze images but not video:

```
screenshot_path = client.screenshot_watch("abc123")
# → /tmp/bottube_watch_abc123.png
```

The method (line 415) launches Chromium, navigates to the watch page, waits for `networkidle`

, captures a full-page screenshot at 1280x900, and saves it to a file. It requires `pip install playwright && playwright install chromium`

.

After reading the SDK source, here are some architectural notes:

**Auth model**: Simple API key in `X-API-Key`

header. No OAuth, no JWT, no refresh tokens. Keys are stored in plaintext JSON at `~/.bottube/credentials.json`

with `chmod 600`

. This is adequate for agent-to-server auth but wouldn't work for human-facing apps needing session management.

**Error handling**: The `BoTTubeError`

class wraps HTTP errors with `status_code`

and `response`

dict. The `_request()`

method (line 87) raises on any status >= 400. This is clean but means callers need try/except around any network call.

**No rate limiting in the SDK**: The SDK doesn't implement client-side rate limiting or retry logic. The server-side limits are documented (avatar uploads: 5/hour) but not consistently enforced in the client.

**File handle management**: The `upload()`

method opens file handles and closes them in a `finally`

block (line 150). Good practice — prevents leaked file descriptors on upload failures.

**FFmpeg dependency for audio**: The `audio.py`

module shells out to FFmpeg via `subprocess.run(cmd, check=True)`

. If FFmpeg isn't installed, you get a `FileNotFoundError`

at runtime, not at import time. A try/except at module level with a helpful message would be better.

**Video constraints**: Max 720x720 resolution and 2MB file size (per the homepage). This limits production quality significantly — you won't be uploading 1080p content.

**No streaming**: The upload is a single multipart POST, not chunked or resumable. Large files (approaching 2MB) on slow connections could time out. The default timeout is 120 seconds.

**Audio quality**: The ambient audio is synthesized from FFmpeg filter graphs — it's functional ambient noise, not music or speech. For production content, you'd want to bring your own audio track.

**No SDK for JavaScript/TypeScript**: Python only. If your agent runs in Node.js, you'd need to use the REST API directly.

**X/Twitter cross-posting requires server credentials**: The `crosspost_x()`

method relies on the BoTTube server's configured Twitter credentials, not your own. You can't post to a custom Twitter account via the SDK.

**Webhook reliability**: No documented retry policy or dead-letter queue for failed webhook deliveries.

**Limited video metadata**: The `upload()`

method accepts title, description, tags, and `scene_description`

— but no categories, custom thumbnails (the parameter exists but the docs are sparse), or scheduled publishing.

BoTTube is an interesting experiment in agent-native content platforms. The SDK is straightforward — a thin REST wrapper with some conveniences (credential storage, ambient audio generation, screenshot watching). For agents already operating in the RustChain ecosystem, it's a natural fit. For developers building AI content pipelines, the API is clean enough to integrate in an afternoon.

The 720x720 / 2MB limit keeps it firmly in the "short clip" territory, and the synthesized ambient audio won't replace real sound design. But as infrastructure for autonomous agents to publish and monetize video content, it's one of the few platforms that explicitly welcomes AI-generated work.

The bounty for writing this article is [GitHub issue #450](https://github.com/Scottcjn/rustchain-bounties/issues/450) — 15 RTC. If you're interested in earning RTC for content, check the [bounties repo](https://github.com/Scottcjn/rustchain-bounties) for open issues.

*This article was written after reading the BoTTube SDK v1.6.0 source code ( bottube PyPI package), the API docs, and the GitHub repo. All code examples are from the actual SDK. The ambient audio filter graphs are quoted directly from audio.py.*