> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://fastpix.com/docs/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://fastpix.com/docs/_mcp/server.

# Get info of media inputs

GET https://api.fastpix.com/v1/on-demand/{mediaId}/input-info

This endpoint lets you retrieve detailed information about the media inputs associated with a specific media item. You can use it to verify the media file’s input URL, track its creation status, and check its container format. You must provide the mediaId (either the uploadId or the id) to fetch this information.


#### How it works

Upon making a `GET` request with the mediaId, FastPix returns a response with: 

* The public storage input `url` of the uploaded media file. 

* Information about the media’s video and audio tracks, including whether they were successfully created.

* The container format of the uploaded media file (for example, MP4, MKV).

This endpoint is particularly useful for ensuring that all necessary tracks (video and audio) have been correctly associated with the media during the upload or media creation process.


Reference: https://fastpix.com/docs/video-on-demand-api/manage-videos/retrieve-media-input-info

## Authentication

- `Authorization` header (basic auth, required) — FastPix APIs are secured with Basic Authentication. Use your Access Token ID as the username and Secret Key as the password in the Authorization header of each API request. * Username: Access Token ID * Password: Secret Key Activate your FastPix account to generate your API credentials. See the guide here

## Request

### Path parameters

- `mediaId` (string, required) — Pass the list of the input objects used to create the media, along with applied settings.

## Response

### 200

Get video media input information

- `success` (boolean, optional) — Shows the request status. Returns true for success and false for failure.
- `data` (OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaData, optional) — Displays the result of the request.

## Types

### OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaData

Displays the result of the request.

- `configuration` (OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataConfiguration, optional) — Represents configuration details for the media.
- `file` (OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataFile, optional) — Contains metadata and structural details about the media file.

### OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataConfiguration

Represents configuration details for the media.

- `url` (string, optional) — The URL hosting the media file to be downloaded and processed by FastPix. Supports formats like MP4, MOV, MKV, TS, MP3, and text tracks (SRT/VTT). Using standard formats ensures optimal processing speed.

### OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataFile

Contains metadata and structural details about the media file.

- `containerFormat` (string, optional) — Specifies the container format that encapsulates audio, video, subtitles, and metadata.
- `tracks` (list of OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataFileTracksItems, optional) — A list of all media tracks including video, audio, and subtitles.

### OnDemandMediaIdInputInfoGetResponsesContentApplicationJsonSchemaDataFileTracksItems

- VIDEO_TRACK: VideoTrack
- AUDIO_TRACK: AudioTrack
- SUBTITLE_TRACK: SubtitleTrack

### VideoTrack

A media consists of different media tracks, like video, audio, and subtitle, all combined.

- `id` (string, optional) — FastPix generates a unique identifier for each track.
- `type` (enum, optional) — Defines the type of input. This option is mandatory.
  - Allowed values: `video`
- `width` (double, optional) — Track width denotes the range of widths applicable to a specific track. Currently, this setting can be modified only for video tracks
- `height` (double, optional) — Track height denotes the range of height applicable to a specific track. Currently, this setting can be modified only for video tracks.
- `frameRate` (string, optional) — Frame rate quantifies the speed at which frames are displayed per second. It represents the range of frames available for a specific track. The indeterminable frame rate of the input file is indicated by a value of -1.
- `status` (string, optional) — Indicates the current state of the track. 'available' means the track has been processed successfully and is ready to be used or played.
- `title` (string, optional) — Title of the track.

### AudioTrack

A media consists of different media tracks, like video, audio, and subtitle, all combined.

- `id` (string, optional) — FastPix generates a unique identifier for each track.
- `type` (enum, optional) — Defines the type of input track.
  - Allowed values: `audio`
- `status` (string, optional) — Indicates the current state of the track. 'available' means the track has been processed successfully and is ready to be used or played.
- `title` (string, optional) — Title of the track.
- `languageName` (string, optional) — Name of the language in which the subtitles will be generated.
- `languageCode` (string, optional) — Language codes are concise, standardized symbols that denote languages, utilizing either two or three characters for identification. The language code must be compliant with the BCP 47 standard to ensure compatibility. (for text only).

### SubtitleTrack

A media consists of different media tracks, like video, audio, and subtitle, all combined.

- `id` (string, optional) — FastPix generates a unique identifier for each track.
- `type` (enum, optional) — Defines the type of input track.
  - Allowed values: `subtitle`
- `status` (string, optional) — Indicates the current state of the track. 'available' means the track has been processed successfully and is ready to be used or played.
- `title` (string, optional) — Title of the track.
- `languageName` (string, optional) — Name of the language in which the subtitles will be generated.
- `languageCode` (string, optional) — Language codes are concise, standardized symbols that denote languages, utilizing either two or three characters for identification. The language code must be compliant with the BCP 47 standard to ensure compatibility. (for text only).

## Examples

**Response**

```json
{
  "success": true,
  "data": {
    "configuration": {
      "url": "https://static.fastpix.com/fp-sample-video.mp4"
    },
    "file": {
      "containerFormat": "mp4",
      "tracks": [
        {
          "id": "6eb56a83-9a8b-47a5-94b2-cadb4458cf4d",
          "type": "video",
          "width": 1280,
          "height": 720,
          "frameRate": "30/1",
          "status": "available"
        }
      ]
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info"

response = requests.get(url, auth=("<username>", "<password>"))

print(response.json())
```

```javascript
const url = 'https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info';
const credentials = btoa("<username>:<password>");

const options = {method: 'GET', headers: {Authorization: `Basic ${credentials}`}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info"

	req, _ := http.NewRequest("GET", url, nil)

	req.SetBasicAuth("<username>", "<password>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request.basic_auth("<username>", "<password>")

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info")
  .basicAuth("<username>", "<password>")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info', [
  'headers' => [
  ],
    'auth' => ['<username>', '<password>'],
]);

echo $response->getBody();
```

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.GET);

IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = ["Authorization": "Basic \(credentials)"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api.fastpix.com/v1/on-demand/4fa85f64-5717-4562-b3fc-2c963f66afa6/input-info")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```