Guide to live streaming an event using FastPix

It’s 2025, and live streaming has become the go-to way to connect with audiences. Did you know that 80% of businesses now use live streaming for webinars, product launches, and events? And 70% of churches broadcast their services weekly? Live streaming isn’t just popular it’s essential for staying connected in real time.

But let’s be real: getting a live stream right isn’t always easy. There are plenty of hurdles, from buffering issues to figuring out how to stream on multiple platforms without losing quality. That’s where FastPix comes in.

In this guide, we’ll walk you through how to set up and manage live streams using the FastPix Dashboard and API, plus share tips to make sure your streams are high-quality, reliable. Let’s dive in!

‍

Main challenges for developer while setting up a live stream

‍

Managing inconsistent video input

Developers often deal with varying video formats, resolutions, and frame rates from different sources. Standardizing these inputs for ingestion and encoding requires extra effort to avoid quality degradation or compatibility issues.

‍

Balancing quality and latency

Achieving high-quality video while maintaining low latency is a tricky tradeoff. Encoding settings, bitrate adjustments, and network optimizations all need to align for a seamless experience without delays.

‍

Network reliability and adaptive streaming

Unpredictable network conditions can disrupt live streams. Developers must implement adaptive bitrate streaming (ABR) to dynamically adjust quality based on the viewer's bandwidth, ensuring uninterrupted playback.

‍

Protocol selection and integration

Choosing the right protocols (e.g., RTMP for ingest, HLS for delivery, or SRT for secure streams) and ensuring they work together smoothly requires careful configuration and testing for compatibility.

‍

Real-time monitoring and error recovery

Debugging and troubleshooting during a live stream is a major challenge. Developers need robust monitoring tools to detect issues like dropped frames or network interruptions and implement mechanisms to recover without disrupting the viewer experience.

‍

Scaling for large audiences

Handling sudden spikes in traffic requires a scalable architecture. Integrating with CDNs and designing infrastructure that can distribute content globally without latency is critical for a successful stream.

‍

How FastPix can help

FastPix simplifies live streaming for developers by addressing these common challenges:

• Inconsistent video input: Our platform automatically standardizes video formats, resolutions, and frame rates during ingestion, reducing manual pre-processing efforts.
• Quality and latency balance: FastPix adaptive encoding pipeline ensures optimal video quality while maintaining ultra-low latency, even under varying network conditions.
• Network reliability: With built-in adaptive bitrate streaming (ABR) and SRT protocol support, FastPix ensures smooth playback and secure delivery, regardless of bandwidth fluctuations.
• Protocol integration: FastPix seamlessly handles ingest (RTMPS) and delivery (HLS, DASH) protocols, removing the complexity of configuration and testing.
• Monitoring and error recovery: Real-time analytics allow developers to monitor streams and quickly address issues like frame drops or connectivity problems.
• Scalability: Our cloud-based infrastructure, integrated with global CDNs, lets you scale effortlessly to support millions of concurrent viewers without performance loss.

‍

Setting up a live stream with FastPix: A step-by-step guide

‍

Step1: Prepare your streaming environment

Before setting up a live stream on FastPix, ensure you have the right tools and infrastructure:

• Streaming equipment: Use high-quality cameras and microphones. For professional streams, a multi-camera setup can enhance the experience with dynamic angles.
• Internet connection: A stable and high-speed connection is essential. For 1080p streaming, aim for an upload speed of at least 5 Mbps.
• Streaming software: Use software like OBS Studio for stream management, overlay graphics, and camera switching.

‍

Step 2: Create a livestream using the FastPix dashboard

Follow these steps to create a live stream on FastPix:

1. Signup and log in:
   • Visit FastPix Dashboard.
   • Complete the sign-up process by providing your details.
   • Once logged in, navigate the main dashboard to access all features.
     ‍
2. Navigate to the "Live" section:
   • Hover over the left-hand menu and select "Live" to access the live streaming interface.
     ‍
     ‍

‍

3. Create a test live stream
   • Click the "Create Live Stream" button.
   • Note: Test streams are limited to 5 minutes and up to 30 streams per organization.
     ‍
4. Upgrade to the Pro Plan (if needed):
   • Go to Account Settings > Billing and Payment and select the "Upgrade"option.
   • Enter payment details to unlock Pro plan features like extended streaming duration and unlimited streams.
     ‍

‍

Step 3: Configure your live stream using API requests

For customization, use FastPix API parameters to fine-tune your live stream:

1. playbackSettings:
   • accessPolicy: Set your stream to public or private access.
2. InputMediaSettings:
   • maxResolution: Define the maximum resolution for your stream.
   • reconnectWindow: Set a time window (in seconds) for reconnection in case of network failure.
   • mediaPolicy: Control whether recorded streams are public or private.
3. metadata: Add custom tags or information relevant to your stream.

‍

1curl -X POST 'https://v1.fastpix.io/live/streams'
2   --user {Access Token ID}:{Secret Key} \
3   -H 'Content-Type: application/json' \
4   -d '{
5   "playbackSettings": {
6      "accessPolicy": "public"
7   },
8   "inputMediaSettings": {
9      "maxResolution": "1080p",
10      "reconnectWindow": 60,
11      "mediaPolicy": "public",
12      "metadata": {
13         "livestream_name": "fastpix_livestream"
14      },
15      "enableDvrMode": false
16   }
17}'
18

‍

To execute the API request:

• Click "Run Request"to create the livestream entity.
• Use the Stream Details page to access your stream settings and keys.
  ‍

‍

Step 4: Go Live with OBS

Once your stream is set up, follow these steps to broadcast using OBS Studio:

1. Open OBS and navigate to Settings> Stream.
2. Set the service to "Custom"and input the FastPix server URL
   • rtmps://live.ibee.ai:443/live
3. Copy the Stream Key from the Stream Details page and paste it into OBS.
4. Connect your camera to OBS:
   • Use a video capture card to connect a DSLR or other cameras.
   • Alternatively, use a webcam or other input sources.
5. Create a scene in OBS (e.g., "Your Live Event Name") and add sources:
   • Video capture device for your camera.
   • Audio input capture for your microphone.
6. Adjust output settings in OBS to optimize quality and performance.

Click "Start streaming"to go live!

‍

Step 5:  Share your stream

To share the stream:

• Use the Stream URL and Playback ID from the Live Stream Details page.
  ‍

‍

• Embed the URL into any HLS player to allow viewers access.

‍

Step 6: Secure your live stream

FastPix offers two primary methods to secure your stream:

1. SRT protocol (Secure Reliable Transport):

• Provides end-to-end encryption during transmission.
• Ideal for high-quality, real-time video over unreliable networks.

2. Private access policy:

• Restricts access to authorized users through secure authentication.

‍

Which to choose?

• Use SRT for better encryption and reliable delivery in critical scenarios.
• Opt for Private Access Policy when controlling access is a priority.

‍

Best Practices for RTMPS Live Streaming with FastPix

‍

Enforce RTMPS for secure transmission

Always configure your live stream to use RTMPS instead of RTMP. RTMPS ensures end-to-end encryption, protecting your data and video stream from interception or tampering. Set your broadcast software (e.g., OBS) to use RTMPS with the FastPix RTMPS server URL.

Handle stream keys securely

Stream Keys are sensitive credentials. Store them securely in your application and environment variables. Never expose them in the front-end or publicly accessible code. Use secure methods like environment variables or encrypted storage for backend storage and retrieval.

‍‍

Test your stream setup using API requests

Before going live, test your stream setup using tools like Postman or curl. Make sure to send API requests to /streams and validate the response. Confirm that your stream is correctly created and you have the right Stream Key and Playback ID. Use these APIs for validating stream status and debugging issues before live broadcasting.

‍

Monitor stream performance with Webhooks

Utilize Webhooks to monitor stream status in real time. Set up listeners for events such as video.live_stream.active and video.live_stream.disconnected to track stream health and react to changes automatically. Automating stream monitoring allows you to programmatically detect and address stream issues.

‍

Implement error handling and auto-reconnect logic

Implement error handling in your application to catch stream interruptions. Use the reconnectWindow parameter to allow automatic reconnections if your stream faces issues. In case of prolonged downtime or stream failure, set up a fallback mechanism to notify your users or restart the stream.

‍

Set stream duration limits programmatically

Be mindful of FastPix's 12-hour stream duration limit. Use the API to track the status of your stream, and set automated checks to warn when the stream is nearing its expiration. Build your app to gracefully end or restart streams within the allowed timeframe to avoid unexpected cuts.

‍

Closing thoughts

Hope you found this insightful! We’d love to hear what features you'd like to see next let us know!‍