FastPix C# SDK

The FastPix C# SDK is a strongly typed .NET client for the FastPix video API. From any .NET 8 application you can upload and manage videos, run live streams and simulcasts, create and secure playback IDs, manage playlists and signing keys, pull video analytics, and use in-video AI features. It works with ASP.NET Core, console, and worker apps.

Find more in the SDK reference

For all methods, runnable examples, and advanced usage, see the FastPix C# SDK on GitHub.

Before you begin

Make sure you have:

• .NET 8.0 or later
• The .NET CLI
• Internet access
• A FastPix account
• A FastPix Access Token and Secret Key, generated from the FastPix Dashboard. See Activate your account.

FastPix uses HTTP Basic Authentication. The SDK maps your credentials as follows:

Security: Never commit your Access Token or Secret Key to source control. Use environment variables or a secure credential-management system.

Follow the steps below in order, and do not skip the verification steps. If the SDK does not install, the project does not build, or authentication fails, resolve that issue before making an API request.

Check your .NET version

dotnet --version

The output must be 8.0 or later, for example 8.0.414. You can also list the installed SDKs:

dotnet --list-sdks

If .NET 8 or later is not installed, install a supported .NET SDK before continuing.

Create a .NET project

Create a new console application:

mkdir fastpix-csharp-demo
cd fastpix-csharp-demo
dotnet new console

Verify that the project builds before installing the SDK:

dotnet build

You should see Build succeeded. If the build fails, resolve the .NET project issue before continuing.

Install the FastPix SDK

Install the FastPix SDK from NuGet:

dotnet add package Fastpix

The SDK is added to your project as a NuGet dependency. Confirm the package:

dotnet list package

You should see an entry for Fastpix and the installed version.

Verify the SDK installation

Confirm that your application can import and initialize the SDK. Replace the contents of Program.cs with:

using Fastpix;
using Fastpix.Models.Components;
var sdk = new FastpixSDK(
    security: new Security
    {
        Username = "test",
        Password = "test"
    }
);
Console.WriteLine("FastPix SDK initialized successfully");

Run it:

dotnet run

The expected output is FastPix SDK initialized successfully. This verifies that .NET is installed, the project builds, the Fastpix package is installed, the namespaces are available, and the FastpixSDK client can be initialized. The placeholder credentials mean this does not make an API request.

Configure authentication

FastPix uses HTTP Basic Authentication, where Username is your Access Token and Password is your Secret Key. For local development, set these as environment variables so they stay out of your source code:

# macOS and Linux
export FASTPIX_USERNAME="<YOUR_ACCESS_TOKEN>"
export FASTPIX_PASSWORD="<YOUR_SECRET_KEY>"

# Windows PowerShell
$env:FASTPIX_USERNAME="<YOUR_ACCESS_TOKEN>"
$env:FASTPIX_PASSWORD="<YOUR_SECRET_KEY>"

Verify that your credentials are set

Check that both variables are set without printing their values:

# macOS and Linux
test -n "$FASTPIX_USERNAME" && echo "FASTPIX_USERNAME is set"
test -n "$FASTPIX_PASSWORD" && echo "FASTPIX_PASSWORD is set"

Both should report as set. If either is missing, set the corresponding environment variable before continuing.

Initialize the FastPix client

Update Program.cs to read the credentials from the environment:

using Fastpix;
using Fastpix.Models.Components;
var username = Environment.GetEnvironmentVariable("FASTPIX_USERNAME");
var password = Environment.GetEnvironmentVariable("FASTPIX_PASSWORD");
if (string.IsNullOrWhiteSpace(username))
{
    throw new InvalidOperationException(
        "FASTPIX_USERNAME environment variable is not set."
    );
}
if (string.IsNullOrWhiteSpace(password))
{
    throw new InvalidOperationException(
        "FASTPIX_PASSWORD environment variable is not set."
    );
}
var sdk = new FastpixSDK(
    security: new Security
    {
        Username = username,
        Password = password
    }
);
Console.WriteLine("FastPix client initialized successfully");

Run it:

dotnet run

The expected output is FastPix client initialized successfully. Initializing the SDK does not make an API request. The SDK contacts the FastPix API only when you call an operation such as CreateMediaAsync.

Make your first API request

The simplest way to verify the integration is to create a media asset from a publicly accessible video URL. FastPix provides a sample video at https://static.fastpix.com/fp-sample-video.mp4.

Replace Program.cs with:

using Fastpix;
using Fastpix.Models.Components;
using System.Collections.Generic;
using System.Text.Json;
var username = Environment.GetEnvironmentVariable("FASTPIX_USERNAME");
var password = Environment.GetEnvironmentVariable("FASTPIX_PASSWORD");
if (string.IsNullOrWhiteSpace(username))
{
    throw new InvalidOperationException(
        "FASTPIX_USERNAME environment variable is not set."
    );
}
if (string.IsNullOrWhiteSpace(password))
{
    throw new InvalidOperationException(
        "FASTPIX_PASSWORD environment variable is not set."
    );
}
var sdk = new FastpixSDK(
    security: new Security()
    {
        Username = username,
        Password = password,
    }
);
var request = new CreateMediaRequest()
{
    Inputs = new List<Fastpix.Models.Components.Input>()
    {
        Fastpix.Models.Components.Input.CreatePullVideoInput(
            new PullVideoInput()
            {
                Url = "https://static.fastpix.com/fp-sample-video.mp4"
            }
        )
    },
    Metadata = new Dictionary<string, string>()
    {
        { "title", "My first FastPix video" },
        { "source", "csharp-demo" }
    }
};
try
{
    var response = await sdk.InputVideo.CreateMediaAsync(request);
    Console.WriteLine("Media creation request succeeded.");
    Console.WriteLine(
        JsonSerializer.Serialize(
            response,
            new JsonSerializerOptions
            {
                WriteIndented = true
            }
        )
    );
}
catch (Exception ex)
{
    Console.Error.WriteLine("FastPix API request failed.");
    Console.Error.WriteLine(ex.Message);
}

Run it:

dotnet run

A successful request returns information about the newly created media asset, similar to:

{
  "success": true,
  "data": {
    "id": "..."
  }
}

The exact fields depend on the API response and the installed SDK version.

Capture the media ID

The create-media response contains the unique ID assigned to the media asset, at data.id:

{
  "success": true,
  "data": {
    "id": "12345678-1234-1234-1234-123456789abc"
  }
}

Save this value for later operations:

MEDIA_ID=<value returned in data.id>

A media_id is not the same as a playback_id. They identify different resources and are used for different operations.

Verify the integration

A successful create-media request confirms that .NET is installed and supported, the project builds, the Fastpix package is installed, your credentials are configured, the client can authenticate, and FastPix returns a media ID.

Creating media is usually the first step in a FastPix on-demand workflow: you create the media, wait until processing finishes, then create a playback ID to play it. The initial SDK integration is now complete.

Resources, error handling, and reference

The SDK is generated from the FastPix API specification, so the complete and always-current reference lives in the repo and the API docs:

• All resources, operations, error handling, retries, server selection, and custom HTTP clients: the FastPix C# SDK on GitHub, with runnable code in the examples directory.
• Media (upload, manage, playback, playlists, signing keys, DRM): Video on Demand API.
• Live (streams, simulcasts, live playback): Live Stream API.
• Video Data (metrics, views, dimensions, errors): Video Data API.
• In-video AI (summaries, chapters, named entities, moderation): In-Video AI.

What’s next

Want to go further? Browse runnable, end-to-end samples for the FastPix C# SDK in the examples folder of the GitHub repository.

Release notes

For a complete history of releases, improvements, and fixes, see the FastPix C# SDK CHANGELOG on GitHub.