FastPix PHP SDK

The FastPix PHP SDK is a strongly typed PHP client for the FastPix video API. From any PHP application you can upload and manage videos, run live streams and simulcasts, create and secure playback IDs, manage playlists and signing keys, retrieve video analytics, and use in-video AI features.

Find more in the SDK reference

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

Before you begin

Make sure you have:

• PHP 8.2 or later
• Composer
• 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 installation, dependency loading, authentication, client initialization, or the first API request fails, fix that problem before continuing.

Check your PHP version

php --version

The output is similar to PHP 8.5.10 (cli) .... The SDK supports PHP 8.2 and later. If your version is earlier than 8.2, install a supported version before continuing.

You can also print the exact version:

php -r 'echo PHP_VERSION, PHP_EOL;'

Check your Composer installation

The SDK uses Composer to install and manage dependencies.

composer --version

The expected output is similar to Composer version 2.x.x. If you see command not found, Composer is not available in your shell. Install Composer before continuing.

Create a PHP project

Create a directory for your application and initialize a Composer project:

mkdir fastpix-php-demo
cd fastpix-php-demo
composer init

Accept the default values when prompted. When Composer asks whether to define dependencies interactively, select no; you add the SDK in the next step. After initialization, the project contains a composer.json file.

Note: Do not enter ls at the package-name prompt. ls is a shell command, not a valid Composer package name.

Install the FastPix SDK

composer require fastpix/sdk

After installation, your project contains composer.json, composer.lock, and a vendor/ directory. The vendor/ directory holds the installed SDK and Composer’s autoloader.

Verify the SDK installation

composer show fastpix/sdk

The output identifies the FastPix SDK package and the installed version. You can also search all installed packages:

# macOS and Linux
composer show | grep fastpix

# Windows PowerShell
composer show | Select-String fastpix

If fastpix/sdk is not listed, run composer install, then verify again with composer show fastpix/sdk.

Verify that PHP can load the SDK

Create a file named verify.php:

<?php
require 'vendor/autoload.php';
use FastPix\Sdk;
echo "FastPix SDK loaded successfully" . PHP_EOL;

Run it:

php verify.php

The expected output is FastPix SDK loaded successfully. This confirms that PHP can execute the application, Composer’s autoloader is available, and the SDK can be loaded. If it fails, confirm that PHP 8.2 or later is installed, composer require fastpix/sdk completed, vendor/autoload.php exists, and you are running the command from the project directory.

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:

# 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 the variables are set without printing their values:

# macOS and Linux
if [ -n "$FASTPIX_USERNAME" ]; then echo "Access Token: set"; else echo "Access Token: missing"; fi
if [ -n "$FASTPIX_PASSWORD" ]; then echo "Secret Key: set"; else echo "Secret Key: missing"; fi

# Windows PowerShell
if ($env:FASTPIX_USERNAME) { "Access Token: set" } else { "Access Token: missing" }
if ($env:FASTPIX_PASSWORD) { "Secret Key: set" } else { "Secret Key: missing" }

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

Initialize the FastPix client

Create a file named main.php:

<?php
require 'vendor/autoload.php';
use FastPix\Sdk;
use FastPix\Sdk\Models\Components;
$username = getenv('FASTPIX_USERNAME');
$password = getenv('FASTPIX_PASSWORD');
if ($username === false || $username === '') {
    throw new RuntimeException('FASTPIX_USERNAME is not set');
}
if ($password === false || $password === '') {
    throw new RuntimeException('FASTPIX_PASSWORD is not set');
}
$sdk = Sdk\Fastpixsdk::builder()
    ->setSecurity(
        new Components\Security(
            username: $username,
            password: $password,
        )
    )
    ->build();
echo "FastPix client initialized" . PHP_EOL;

Run it:

php main.php

The expected output is FastPix client initialized. Initializing the client does not make an API request; a request happens only when you call an SDK operation such as $sdk->inputVideo->createMedia(...).

Make your first API request

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

Replace the contents of main.php with:

<?php
require 'vendor/autoload.php';
use FastPix\Sdk;
use FastPix\Sdk\Models\Components;
$username = getenv('FASTPIX_USERNAME');
$password = getenv('FASTPIX_PASSWORD');
if ($username === false || $username === '') {
    throw new RuntimeException('FASTPIX_USERNAME is not set');
}
if ($password === false || $password === '') {
    throw new RuntimeException('FASTPIX_PASSWORD is not set');
}
$sdk = Sdk\Fastpixsdk::builder()
    ->setSecurity(
        new Components\Security(
            username: $username,
            password: $password,
        )
    )
    ->build();
try {
    $request = new Components\CreateMediaRequest(
        inputs: [
            new Components\PullVideoInput(
                url: 'https://static.fastpix.com/fp-sample-video.mp4',
            ),
        ],
        metadata: [
            'source' => 'fastpix-php-demo',
        ],
    );
    $response = $sdk->inputVideo->createMedia(request: $request);
    if ($response->statusCode >= 200 && $response->statusCode < 300) {
        $rawBody = (string) $response->rawResponse->getBody();
        $decoded = json_decode($rawBody, true);
        echo json_encode($decoded ?? $rawBody, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . PHP_EOL;
    } else {
        $errorPayload = $response->defaultError ?? $response->error ?? null;
        echo json_encode($errorPayload ?? ['message' => 'No response data'], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . PHP_EOL;
        exit(1);
    }
} catch (\Exception $e) {
    echo json_encode(['error' => $e->getMessage()], JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . PHP_EOL;
    exit(1);
}

Run it:

php main.php

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 PHP is installed and supported, Composer is installed, the project is initialized, the SDK is installed and loadable, your credentials are configured, the client can authenticate, and FastPix returns a media ID.

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, and server selection: the FastPix PHP 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 PHP SDK in the examples folder of the GitHub repository.

Release notes

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