PRODUCTS
If you're building a creator subscription platform, video is at the center, and that’s the part we’ll handle with FastPix.
But the product you’re building is more than just streaming and uploads.
You’ll need to support gated content, recurring payments, tipping, private messaging, access rules, notifications, dashboards, and a dozen small systems that all need to work together.
So, before we show you how to handle uploads, playback, and video security with FastPix, this tutorial walks through everything else your app needs, and how to build it.
This is the foundation the rest of your stack will sit on.
Start by designing your user model.
Both creators and fans can sign up, but they have different permissions. Use a single users table with a role field (fan, creator, maybe admin). You’ll also want a profiles table that stores public-facing details like:
For authentication, tools like Clerk.dev, Auth.js, or Supabase Auth let you move fast. You’ll need password login and email verification at minimum. Social auth is optional but useful.
Subscriptions are the core revenue engine. Fans subscribe to creators, creators get paid, and the platform takes a cut.
The easiest way to do this is with Stripe Connect (Standard accounts).
stripe.accounts.create() stripe_account_id in your database Then, when a fan subscribes:
transfer_data invoice.paid webhook to mark the sub as active in your DB subscriptions table with start_date, end_date, and status This way, Stripe handles the payments, taxes, retries, and cancellations. You handle the access logic and UI.
Every piece of content on your platform, whether it’s a teaser clip, a private video, or a paid DM needs to answer one question:
Who’s allowed to watch this?
This isn’t just about showing or hiding a post in the UI. It directly affects whether FastPix will generate a valid, playable stream for that user.
Start by storing posts like this:
1posts (
2 id UUID PRIMARY KEY,
3 creator_id UUID,
4 title TEXT,
5 media_asset_id TEXT, -- FastPix asset ID, not a raw URL
6 is_locked BOOLEAN DEFAULT TRUE,
7 unlock_price_cents INTEGER,
8 created_at TIMESTAMP
9)
Instead of storing a direct URL to a file, you store the FastPix asset ID, which will later be used to generate a tokenized stream URL.
Next, track access:
1post_access (
2 post_id UUID,
3 user_id UUID,
4 unlocked_at TIMESTAMP
5)
Now, in your API layer, when a fan requests a post:
If the answer is yes, you call FastPix’s API to generate a secure, time-limited stream token for that video. The stream URL returned is:
If the answer is no, you don’t request a stream, you return the metadata and a preview image or teaser.
Not all content is behind subscriptions. Some posts are pay-per-view. Some messages are locked until tipped. This is the second half of your monetization engine.
The flow:
post_access table Creators still get paid through their Stripe Connect account. You just route a single charge instead of a subscription.
Tips and unlocks can share the same infrastructure - just attach metadata like reason: tip or reason: unlock.
Once you have subscriptions and content access in place, adding messaging is straightforward.
Create a messages table with:
1messages (
2 id UUID,
3 sender_id UUID,
4 receiver_id UUID,
5 text TEXT,
6 media_url TEXT,
7 is_locked BOOLEAN DEFAULT FALSE,
8 unlock_price_cents INTEGER,
9 created_at TIMESTAMP
10)
Only fans with active subscriptions (or who have unlocked the message) should be able to view the contents.
In v1, use REST and polling. /messages?with_user=xyz is enough.
Later, you can add:
Your creators will expect real-time insights and historical earnings.
Build a /creator/dashboard endpoint that shows:
Use a scheduled job (e.g., with BullMQ) to aggregate earnings nightly.
If you want real-time numbers, sync them from Stripe webhooks and write them to a reporting table.
You don’t need a BI tool to start, just solid queries and consistent data.
Even if you allow adult content, you’ll need moderation.
reports table for fans to flag content FastPix can help moderate media later using AI pipelines (NSFW detection, scene classification), but for now, you need to support manual review.
Also: keep in mind App Store guidelines. Messaging, tips, and adult content all have different requirements. If you’re building native apps, compliance will affect your backend.
By this point, you’ve built:
The platform is functional, users can sign up, subscribe, tip, unlock content, and send messages.
But all the media so far is just metadata. You still need to handle:
This is where FastPix comes in.
Here’s a look at what our platform will provide:
Every subscription platform needs a secure way to move media between your app and your video backend. With FastPix, that connection begins with API authentication.
From your FastPix dashboard, generate a token pair. You’ll receive two keys:
Your backend will use this pair whenever it talks to FastPix, whether that’s to upload creator content, check processing status, or generate secure playback links for subscribers.
If you haven’t set this up before, the activation guide covers everything: choosing an auth method, scoping permissions, and testing your first request. Once your token pair is active, you’ve laid the foundation for gated uploads, subscriber-only streaming, and everything else your platform needs.
Every subscription-based platform runs on one thing: creator uploads. Whether it’s a short teaser for everyone or a full-length video locked behind a premium tier, creators need a smooth, reliable way to publish content from any device.
But uploads aren’t just about storing files. You also need to account for slow or unstable networks, tag content by access level, attach metadata, and monitor processing status in real time.
With FastPix, you get a complete pipeline that handles all of it. Let’s walk through how to set it up.
To ensure smooth and reliable uploads especially for platforms like OnlyFans where creators often upload long videos from mobile or web, we recommend using the Resumable Upload SDK. It’s built to handle large files and flaky connections by breaking videos into chunks that upload piece by piece.
If the network drops mid-upload (a common issue on mobile), the SDK automatically pauses and resumes without losing progress so creators never have to start over. Whether it’s a 30-second clip or a 30-minute video.
Install the SDK:
1npm install @fastpix/uploader
Initialize the uploader:
1import { Uploader } from "@fastpix/uploader";
2
3const uploader = Uploader.init({
4 endpoint: 'https://example.com/signed-url',
5 file: selectedVideoFile,
6 chunkSize: 4096, // in KB
7});
This automatically breaks large videos into small chunks, uploads them in parallel, and resumes from where they left off. It’s especially useful when uploading from mobile networks or when creators upload hour-long tutorials, fan shoutouts, or exclusive behind-the-scenes content.
To enable uploads in your videos app, start by setting up a backend endpoint to validate essentials like video duration, file size, and supported formats.
Once that’s in place, integrate the FastPix Web Upload SDK into your frontend. This powers the upload experience letting users record or choose videos, monitor upload progress, and even apply filters if needed.
Every uploaded video gets a unique media ID from FastPix, which you can use later to manage, display, or track the video. Creators uploading from mobile, or desktop can use local storage, but FastPix also supports direct imports from cloud storage platforms like AWS S3, Google Cloud Storage, Azure or even public links like Dropbox.
If the content already lives in the cloud, simply send a POST request to the /on-demand endpoint with the video’s public URL. Check out this guide.
FastPix will handle the rest, importing the media directly no manual upload required.
To upload via URL:
1POST https://api.fastpix.io/v1/on-demand
2
3{
4 "url": "https://s3.amazonaws.com/my-bucket/creator-video.mp4",
5 "metadata": {
6 "creator": "ammendaxoxo",
7 "tier": "gold",
8 "tags": ["fitness", "Q&A"]
9 }
10}
Alternatively, use the SDK for device uploads and show real-time progress with retry logic built in.
On platforms like OnlyFans, personalization isn’t optional, it’s the product. That means your backend needs to do more than just store videos. It needs to organize them in ways that support discovery, filtering, and tiered access.
With FastPix, you can attach flexible key: value metadata to every upload. Creators can label videos by "genre": "fitness", "mood": "intimate", or even "access": "top-tier"and you can use those tags in your API to sort, search, or segment content on demand.
Encourage creators to use hashtags like #asmr, #behindthescenes, or #tutorial, and let them pick categories like “Free Preview” or “Subscribers Only” during upload. These small inputs make a big difference in powering personalized feeds and keeping your platform organized as your content catalog grows. Refer for more: metadata
Use FastPix’s metadata system to tag videos with keys like:
1"metadata": {
2 "creator": "amandaxoxo",
3 "tier": "silver",
4 "series": "Monthly Stretch Routine",
5 "episode": "4",
6 "visibility": "paid"
7}
These tags can be used later to:
Metadata also powers your analytics more on that later.
Once a creator uploads a video, you want to notify them when it’s ready for publishing. FastPix sends real-time webhook events like:
Check out the guide: Events
Here’s what a webhook might look like:
1{
2 "type": "video.media.ready",
3 "object": {
4 "id": "9a3b1c33-xyn"
5 },
6 "data": {
7 "thumbnail": "https://images.fastpix.io/xyz/thumbnail.jpg",
8 "playbackIds": [
9 {
10 "id": "xyz",
11 "accessPolicy": "private"
12 }
13 ],
14 "metadata": {
15 "creator": "amandaxoxo",
16 "tier": "gold"
17 }
18 }
19}
An NSFW (Not Safe For Work) filter is essential for spotting and managing inappropriate content, helping to keep your platform safe and welcoming for everyone.
Related guide: Moderate NSFW & Profanity
In a recent test of our NSFW filter using a sample video primarily featuring violent content, we observed the following scores:
You can enable moderation like this:
1PATCH /on-demand/<mediaId>/moderation
2
3{
4 "moderation": true
5}
The system will return confidence scores so you can flag or auto-approve videos based on thresholds. Combine this with manual review queues for full control. For more advice on managing your content, take a look at our blog about using AI for NSFW and profanity filters.
Live content is a big part of creator monetization. Platforms like OnlyFans let creators connect directly with subscribers through gated, interactive streams, often with tipping, PPV unlocks, and fan requests baked in.
If you’re adding live video to your creator app, FastPix gives you the tools to handle it cleanly, securely, and at scale.
To create a new stream, send a POST request to the /streams endpoint using your FastPix access token. You’ll get back a streamKey and one or more playbackIds - which power broadcasting and viewer playback.
Here’s what the response includes:
status: Current stream state (idle, active, or disabled) streamKey: Needed to connect tools like OBS playbackId: Used to stream to users createdAt: Timestamp of stream creation FastPix supports both RTMP and SRT ingest. Your creators can stream using software like OBS Studio, just plug in the stream key and use the FastPix server URL.
Related guides:
Once the stream ends (or OBS disconnects), the session automatically switches back to idle. Long streams beyond 12 hours? Contact support.
FastPix gives you full control over your live sessions through simple API calls.
You can:
POST request GET /streams ID PATCH DELETE This makes it easy to build features like stream scheduling, real-time status panels, or creator dashboards.
View the full API guide → Managing Live Streams
Want your creators to stream on multiple platforms at once? FastPix lets you simulcast to any RTMP-compatible service, like YouTube Live, Facebook Live, or Twitch, directly from your app.
Use the Simulcast API to define targets when the stream is created (or add them later while the stream is idle).
You’ll need to send the following:
Related guide: Set up simulcast streaming
Every live stream on FastPix is automatically recorded and saved as a VOD asset. Once the session ends, you can use the playbackId to serve the full recording on demand.
You can also enable DVR mode for live rewinds during the broadcast. For long-form streams, you may want to disable this to reduce buffering.
Docs: DVR or Timeshifting
For creators who want to schedule “live” events without being present, FastPix supports simulated live streaming.
You can broadcast a pre-recorded video using tools like OBS. Here’s how:
streamKey and ingest URL Related guide: Stream pre-recorded live
FastPix also supports real-time clipping, useful when creators want to instantly share a teaser from a live session (e.g., post on social, promote replays).
To create a highlight, use this URL format:
https://stream.fastpix.io/<playbackId>.m3u8?start=10s&end=25s
Max clip duration is 30 seconds. Start and end must be valid timestamps within the current stream duration.
Example use cases:
Related docs: Live clipping
OnlyFans-style apps are built around exclusivity. That means not every video should be public. Some content is free; others are locked behind a paywall, and users gain access only after subscribing to a specific creator or tier.
In this chapter, we’ll show you how to set up paywalled access, enforce content tiers, and protect private content using FastPix.
When a creator uploads a new video, you’ll want to define who can watch it. With FastPix, you can set the access policy as:
Most subscription content will use either private or signed.
Example:
1{
2 "accessPolicy": "signed",
3 "metadata": {
4 "creator": "jax_fitness",
5 "tier": "gold",
6 "visibility": "paid"
7 }
8}
This ensures only users with a valid signed token (see next section) can play the video.
Signed URLs are time-bound tokens that restrict access. They’re perfect for granting limited-time viewing to users who are logged in or have an active subscription.
To create a signed playback link:
Sample signed playback URL:
https://stream.fastpix.io/abc12345.m3u8?token=abcde12345&expires=1729898230
Only users with valid subscriptions should get this link. For added security, you can also scope it by IP, device, or user agent.
More info: Secure playback with signed URLs
Many platforms tease content with a 10–15 second preview before asking users to subscribe. FastPix lets you generate short clips from any video, perfect for free previews.
Here’s how to generate a teaser:
1POST /on-demand
2
3{
4 "inputs": [
5 {
6 "type": "video",
7 "url": "fp_media://<mediaId>",
8 "startTime": 0,
9 "endTime": 15
10 }
11 ],
12 "accessPolicy": "public"
13}
This creates a lightweight, public-facing version of a private video. Show it on the content preview page, then prompt users to unlock the full version by subscribing.
Creators want to stand out. Whether it’s custom thumbnails, branded watermarks, or trailer-style teasers good post-production tools make content feel polished. But traditional editing workflows are slow, manual, and incompatible with mobile-first creators uploading on the go.
FastPix solves that by giving you API-level control over editing workflows. No desktop tools, no third-party plugins. Just quick, programmable enhancements that run server-side.
Thumbnails are critical for engagement. Whether it’s the creator’s pose, the lighting, or the text overlay a compelling preview gets clicks.
FastPix auto-generates a default thumbnail on upload. You can also extract one from a specific moment using time-based params:
Related guide: Create thumbnails from video
GET https://images.fastpix.io/<playbackId>/thumbnail.jpg?at=12s&width=480
Want to rotate or watermark it? Add:
...&rotate=90&watermark_url=https://cdn.yoursite.com/logo.png
Use smaller dimensions like width=160&height=284 for mobile feed previews. Since thumbnails are CDN-backed, they load instantly in your app UI.
Watermarking is a great way to protect your brand and ensure content ownership. With just a few settings, you can overlay a consistent, subtle watermark across all videos. For step-by-step instructions, check out our guide: Watermark your videos.
To add watermarking to your video-sharing app, begin by configuring an API request that includes both the video file and watermark details. FastPix makes it easy to position your watermark using alignment and margin settings, while also allowing you to customize its size and opacity.
Related guide: Add watermark to videos
Here’s what a watermark config looks like:
1{
2 "type": "watermark",
3 "url": "https://static.myapp.io/logos/amandaxoxo.png",
4 "placement": {
5 "xAlign": "right",
6 "xMargin": "5%",
7 "yAlign": "bottom",
8 "yMargin": "5%"
9 },
10 "width": "30%",
11 "opacity": "70%"
12}
You can store one watermark per creator and apply it automatically post-upload.
Many platforms tease the first few seconds of an episode to hook viewers. With FastPix’s media API, you can clip sections from longer videos and save them as new, lightweight media assets.
Related guide: Create clips from existing media
Begin by adding "fp_mediaId://" to the existing media ID in the URL parameter of your payload to activate the clipping feature.
Then, define the startTime and endTime of the clip. If these parameters are omitted, the entire length of the original video will be used by default.
Your request body should be structured like this:
1POST /on-demand
2
3{
4 "inputs": [
5 {
6 "type": "video",
7 "url": "fp_media://<mediaId>",
8 "startTime": 0,
9 "endTime": 10
10 }
11 ],
12 "accessPolicy": "public",
13 "maxResolution": "720p"
14}
This creates a new media asset that’s smaller, shareable, and optimized for public preview. Many platforms autoplay these previews on the creator profile page or behind a blurred thumbnail.
Subtitles improve accessibility and engagement especially on mobile. FastPix offers two options:
Attach subtitles during media creation:
1"subtitles": {
2 "languageCode": "en",
3 "name": "English",
4 "url": "https://cdn.myapp.io/subtitles/vid123_en.vtt"
5}
The player UI will include a CC toggle, and you can localize for multiple languages as needed
Related guides:
ReelShort often teases an episode with a “Last time on…” segment or quick recap. FastPix’s API lets you auto-generate these synopses:
1"summary": {
2 "generate": true,
3 "summaryLength": 100
4},
The response returns a concise summary of what happens in the clip. You can display it:
Combine with Chapter 2’s clipping feature to generate 10–15s highlight teasers programmatically.
1{
2 "summary": {
3 "generate": true,
4 "summaryLength": 100
5 }
6}
You’ll receive a short synopsis, and key topics detected great for mobile previews or user feeds.
Once a video is uploaded, enhanced, and locked behind a paywall, everything hinges on one thing: smooth playback. If a video lags, buffers endlessly, or fails to load, the entire subscription experience takes a hit.
FastPix solves this with a lightweight, secure video player that delivers fast startup times, adaptive streaming, mobile-first rendering, and detailed event tracking. It’s built for performance and control letting you tailor the viewing experience based on user tiers, content types, or access rules.
The FastPix Player is available for web, iOS, and Android, making it easy to embed consistent, high-quality playback across all platforms your app supports.
To embed the FastPix Player in your app:
1npm install @fastpix/player
Import and render:
1import "@fastpix/player";
2
3<fp-player
4 playbackId="abc123"
5 autoplay
6 muted
7 playsinline
8 style="aspect-ratio: 16/9; width: 100%; height: auto;"
9></fp-player>
All FastPix videos are automatically encoded with multiple resolutions (240p–1080p+). The player dynamically adjusts quality based on the viewer’s bandwidth no buffering, no dropouts.
There’s nothing to configure, but if you want to cap resolution (e.g., for data-conscious users), set:
player.maxResolution = '720p';
This ensures smoother playback on mobile and slower networks.
If a user watches 3 minutes of a 15-minute video and comes back later, it should resume from the last position.
You can store playback progress using the FastPix Player’s timeupdate event:
1player.addEventListener("timeupdate", (e) => {
2 const secondsWatched = e.detail.currentTime;
3 saveProgress(userId, videoId, secondsWatched);
4});
When the user returns, preload that timestamp:
1player.currentTime = user.lastWatchedTime || 0;
2player.play();
Alternatively, use FastPix Data SDK (coming in Chapter 6) to track this server-side.
If a video is marked as signed or drm access policy, it won’t play unless the request includes a valid token.
Example secure embed:
1<iframe
2 src="https://play.fastpix.io/?playbackId=abc123&token=xyz789&expires=1729898230"
3 width="100%"
4 height="480"
5 allow="autoplay; encrypted-media"
6 frameborder="0">
7</iframe>
This ensures only authenticated, subscribed users can view the video — even if someone tries to share the link.
For DRM-protected content, FastPix handles license delivery for Widevine/FairPlay automatically.
Related guide: DRM
If subtitles are attached to the video, the player will automatically display a toggle. You can load multiple tracks like:
1"subtitles": [
2 {
3 "languageCode": "en",
4 "name": "English",
5 "url": "https://cdn.fastpix.io/subtitles/video123_en.vtt"
6 },
7 {
8 "languageCode": "fr",
9 "name": "French",
10 "url": "https://cdn.fastpix.io/subtitles/video123_fr.vtt"
11 }
12]
Users can select their preferred language, and the captions will load instantly. You can also style them via CSS or set default languages per user profile.
FastPix gives you all the building blocks, not a fixed UI. Want a swipe-to-play mobile feed? A lock icon on paywalled videos? A “blurred until subscribed” thumbnail?
You can implement these with:
Example: show next video when one ends
1player.addEventListener("ended", () => {
2 showNextVideo();
3});
For creators, performance isn’t just about views it’s about impact. Did subscribers actually watch the content? Did they drop off in the first 10 seconds? Are Gold-tier videos performing better than free ones?
FastPix’s Video Data SDK makes it easy to measure exactly how users engage with video content, from view counts to playback quality to retention patterns all in real time.
Whether you're surfacing stats in a creator dashboard or optimizing your own platform’s content strategy, FastPix gives you the data you need.
.webp)
The SDK works with any player FastPix, Shaka, HLS.js, ExoPlayer (Android), AVPlayer (iOS).
To install for a web-based FastPix Player setup:
1npm install @fastpix/data-sdk
Initialize it in your app:
1import { initAnalytics } from "@fastpix/data-sdk";
2
3const analytics = initAnalytics({
4 playbackId: "abc123",
5 playerInstance: player,
6 userId: "subscriber_6789" // Optional for per-user stats
7});
You’ll now receive event streams that can be piped into your backend, dashboards, or BI tools.
Every time a user plays a video, FastPix starts recording key events:
Example:
78% of Silver-tier subscribers replayed the “April Q&A” twice
12% skipped within the first 5 seconds
This is especially powerful when mapped against creator ID or subscription tier.
understanding viewer behavior across your content is key to growing engagement and retention.
Here’s how you can use FastPix analytics:
FastPix’s second-by-second retention graphs help you visualize exactly when attention spikes or fades. You can pull session-level data via API or stream it live into your analytics tools giving you the insights needed to optimize content flow and keep fans coming back.
Here’s a retention snapshot:
1{
2 "mediaId": "abc123",
3 "retention": [
4 { "second": 0, "activeViewers": 980 },
5 { "second": 10, "activeViewers": 805 },
6 { "second": 45, "activeViewers": 232 }
7 ]
8}
You can feed this data into:
Use it to fine-tune intros, trim long videos, or find what makes subscribers stick around.
Good content can’t shine if playback fails. FastPix captures key QoE metrics:
You can segment these by region, device, or creator content to fix delivery issues.
Example:
India → 18% higher rebuffer rate on 4G
iOS Safari users → longer startup times on DRM-protected videos
To give creators visibility into their earnings and reach, you can track:
FastPix makes it easy to combine video data with your billing layer to surface insights like:
“March Behind-the-Scenes” earned $345.12 across 219 subscribers
Top 10% of views came from Platinum-tier followers
By tying analytics to userId, creatorId, and videoId, you get a complete picture of what’s working and for whom.
Related guides:
What separates a basic video platform from a sticky, binge-worthy subscription app? The little things: personalized feeds, smooth content discovery, seamless resume playback, and clear access states.
Apps like OnlyFans, Fansly, and Patreon succeed not just because of their paywalls — but because the UX feels personal and intuitive. In this chapter, we’ll show you how to deliver that experience using FastPix + your own frontend logic.
To entice users to subscribe, show a preview with limited visibility:
FastPix lets you generate public teaser clips (see Chapter 3.3) or low-res thumbnails.
Example thumbnail preview:
1<img src="https://images.fastpix.io/xyz/thumbnail.jpg" style="filter: blur(8px);" />
If the user subscribes, refresh with a valid playback URL using a signed token.
Nothing kills engagement like forcing a user to rewatch from the start. To enable progress tracking:
Example iframe embed:
1<iframe
2 src="https://play.fastpix.io/?playbackId=xyz&startTime=128"
3 ...
4></iframe>
This way, when a subscriber re-opens a video, it picks up where they left off.
For global audiences, let creators upload subtitles in multiple languages. FastPix supports .vtt files and lets users toggle CC in the player.
Attach multiple tracks in metadata:
1"subtitles": [
2 {
3 "languageCode": "en",
4 "name": "English",
5 "url": "https://cdn.myapp.io/subs/video_en.vtt"
6 },
7 {
8 "languageCode": "es",
9 "name": "Spanish",
10 "url": "https://cdn.myapp.io/subs/video_es.vtt"
11 }
12]
The player will auto-detect and show a CC toggle. You can also set a preferred language per user.
Most subscription app users are on mobile. FastPix Player is optimized for:
Preload the next video for smoother UX:
1const preload = new Image();
2preload.src = `https://stream.fastpix.io/${nextPlaybackId}.m3u8`;
Use full screen scroll views or swipeable lists to simulate a native “feed” experience.
When creators trust your platform with their exclusive content often paid for by thousands of subscriber’s security becomes mission critical. You can’t afford to let videos leak, URLs get scraped, or downloads bypass paywalls.
FastPix provides robust protection at every layer: upload, storage, playback, and access control. Let’s walk through how to secure your subscription video app the right way.
The first layer of protection is signed URLs time-limited playback links that expire after a few minutes or hours. This ensures only authorized users (like paying subscribers) can stream the content.
Here’s what a signed URL might look like:
https://stream.fastpix.io/abc12345.m3u8?token=eyJhbGciOi...&expires=1729980120
You can generate this server-side using your FastPix secret key, scoped to:
Use these URLs only after verifying subscription status in your backend.
More: Secure playback with signed URLs
For creators who require enterprise-grade protection — especially those working with agencies or licensing deals FastPix supports Digital Rights Management (DRM).
DRM ensures that:
Enable DRM like this:
{
"accessPolicy": "drm"
}
FastPix handles license delivery via Widevine (Android/Chrome) and FairPlay (iOS/Safari). You don’t have to set up your own license server.
Worried about someone embedding your videos outside the app? FastPix lets you restrict playback to specific referrers.
Example access restrictions:
1"accessRestrictions": {
2 "domains": {
3 "defaultPolicy": "deny",
4 "allow": ["myapp.com", "app.myapp.io"]
5 }
6}
If someone tries to play the video from any other domain, it won’t load even with a valid token.
Combine this with signed URLs for two-layer security: origin + identity.
Creators might upload content early for review, editing, or scheduling. You don’t want that to be accidentally accessed or indexed.
Set these videos as private:
{
"accessPolicy": "private"
}
They’ll only play if you generate an admin-level token, or expose them inside a gated interface (e.g., creator dashboard).
You can also allow creators to toggle privacy status themselves, via your CMS.
If you allow adult content, you may want to scan uploads for compliance — especially to block underage, violent, or self-harm material.
FastPix offers an NSFW scoring system with categories like:
You can enable moderation like this:
1PATCH /on-demand/<mediaId>/moderation
2
3{
4 "moderation": true
5}
Based on the results, you can:
More: Moderate NSFW and Profanity
For creators who post frequently, editing trailers, writing captions, and organizing content manually can be exhausting. That’s where in-video AI features come in they help you automate everything from teaser generation to smart tagging to moderation.
These aren’t gimmicks. Used well, they improve discovery, help subscribers engage faster, and reduce friction in content workflows especially on mobile.
Let’s walk through the most useful FastPix AI features for subscription-style platforms.
When creators upload a video, you can automatically create a short description or episode synopsis using FastPix’s summarization API.
Request:
1POST /summary
2
3{
4 "generate": true,
5 "summaryLength": 100
6}
Response:
{
"summary": "In this video, Lexi answers 15 rapid-fire questions from fans, shares her morning routine, and talks about balancing work and dating life."
}
Use this for:
It saves creators time while making the platform feel more polished.
Want to let viewers jump to specific parts of a video - like “Q&A starts”, “Workout begins”, or “Behind-the-scenes”?
FastPix can analyze a video and return timestamped chapters with optional titles and summaries.
Example:
1POST /chapters
2
3{
4 "chapters": [
5 {
6 "chapter": "1",
7 "startTime": "00:00:00",
8 "endTime": "00:01:40",
9 "title": "Intro + Recap",
10 "summary": "Creator shares highlights from last week"
11 },
12 {
13 "chapter": "2",
14 "startTime": "00:01:41",
15 "endTime": "00:05:00",
16 "title": "Fan Questions",
17 "summary": "Answering questions from Gold-tier subs"
18 }
19 ]
20}
These chapters can show up in:
They also help with engagement: viewers can skip to the parts they care about.
FastPix gives you the video infrastructure you need to build an OnlyFans-style platform—without juggling multiple services or writing custom pipelines from scratch. From uploads and live streams to gated playback and subscriber analytics, everything works out of the box and scales with you.
Here’s what you get with FastPix:
Built for creators: Support uploads, live broadcasts, paywalled content, and premium tiers—across mobile and desktop.
Fully controllable: Build your own branded experience, not a clone of YouTube or Twitch. Every feature runs through your own UI and business logic.
Data-rich: Track stream performance, viewer behavior, and subscriber engagement with FastPix Video Data.
API-first: Integrate directly into your stack, Node, React, Flutter, or whatever you use.
If you're building platforms like OnlyFans, Patreon, or Fanhouse, we’ve got more tutorials that dive into paywall logic, subscription access control, and personalized video feeds. Check out these guides:
Thinking about adding video to your creator platform? You can get started for free or talk to us if you want to explore what’s possible.
.png)
.png)
