# Bitrate

Represents a bitrate value.

The amount can be specified either as a literal value (e.g: `10`) which
cannot be negative, or as an unresolved number token.

When the amount is passed as a token, unit conversion is not possible.

Obtainable from: Bitrate.bps, Bitrate.gbps, Bitrate.kbps, Bitrate.mbps
Used as argument in: [BitrateExpression.range](https://docs.aws.amazon.com/cdk/api/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.BitrateExpression.html#range), [BitrateExpression.value](https://docs.aws.amazon.com/cdk/api/v2/docs/@aws-cdk_aws-mediapackagev2-alpha.BitrateExpression.html#value), ManifestFilter.bitrate, ManifestFilter.bitrateRange

- Source: [`core/lib/bitrate.ts`](https://github.com/aws/aws-cdk/blob/v2.278.0/packages/aws-cdk-lib/core/lib/bitrate.ts#L13)
- Type last changed: v2.244.0 · 19 Mar 2026

## Example

TypeScript:

```ts
declare const stack: Stack;
declare const networkInterface: RouterNetworkInterface;

const input = new RouterInput(stack, 'FailoverInput', {
  routerInputName: 'failover-input',
  maximumBitrate: Bitrate.mbps(10),
  routingScope: RoutingScope.REGIONAL,
  tier: RouterInputTier.INPUT_20,
  configuration: RouterInputConfiguration.failover({
    networkInterface: networkInterface,
    protocols: [
      RouterInputProtocol.rist({
        port: 5000,
        recoveryLatency: Duration.millis(1000),
      }),
      RouterInputProtocol.rist({
        port: 5002, // Must not be consecutive with primary port
        recoveryLatency: Duration.millis(1000),
      }),
    ],
    sourcePriority: SourcePriorityConfig.primarySecondary(PrimarySource.FIRST_SOURCE),
  }),
});
```

Python:

```python
# stack: Stack
# network_interface: RouterNetworkInterface

input = RouterInput(stack, "FailoverInput",
    router_input_name="failover-input",
    maximum_bitrate=Bitrate.mbps(10),
    routing_scope=RoutingScope.REGIONAL,
    tier=RouterInputTier.INPUT_20,
    configuration=RouterInputConfiguration.failover(
        network_interface=network_interface,
        protocols=[
            RouterInputProtocol.rist(
                port=5000,
                recovery_latency=Duration.millis(1000)
            ),
            RouterInputProtocol.rist(
                port=5002,  # Must not be consecutive with primary port
                recovery_latency=Duration.millis(1000)
            )
        ],
        source_priority=SourcePriorityConfig.primary_secondary(PrimarySource.FIRST_SOURCE)
    )
)
```

Java:

```java
Stack stack;
RouterNetworkInterface networkInterface;

RouterInput input = RouterInput.Builder.create(stack, "FailoverInput")
        .routerInputName("failover-input")
        .maximumBitrate(Bitrate.mbps(10))
        .routingScope(RoutingScope.REGIONAL)
        .tier(RouterInputTier.INPUT_20)
        .configuration(RouterInputConfiguration.failover(FailoverConfigurationProps.builder()
                .networkInterface(networkInterface)
                .protocols(List.of(RouterInputProtocol.rist(RistProtocolProps.builder()
                        .port(5000)
                        .recoveryLatency(Duration.millis(1000))
                        .build()), RouterInputProtocol.rist(RistProtocolProps.builder()
                        .port(5002) // Must not be consecutive with primary port
                        .recoveryLatency(Duration.millis(1000))
                        .build())))
                .sourcePriority(SourcePriorityConfig.primarySecondary(PrimarySource.FIRST_SOURCE))
                .build()))
        .build();
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
Stack stack;
RouterNetworkInterface networkInterface;

var input = new RouterInput(stack, "FailoverInput", new RouterInputProps {
    RouterInputName = "failover-input",
    MaximumBitrate = Bitrate.Mbps(10),
    RoutingScope = RoutingScope.REGIONAL,
    Tier = RouterInputTier.INPUT_20,
    Configuration = RouterInputConfiguration.Failover(new FailoverConfigurationProps {
        NetworkInterface = networkInterface,
        Protocols = new [] { RouterInputProtocol.Rist(new RistProtocolProps {
            Port = 5000,
            RecoveryLatency = Duration.Millis(1000)
        }), RouterInputProtocol.Rist(new RistProtocolProps {
            Port = 5002,  // Must not be consecutive with primary port
            RecoveryLatency = Duration.Millis(1000)
        }) },
        SourcePriority = SourcePriorityConfig.PrimarySecondary(PrimarySource.FIRST_SOURCE)
    })
});
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
var stack Stack
var networkInterface RouterNetworkInterface

input := awsmediaconnectalpha.NewRouterInput(stack, jsii.String("FailoverInput"), &RouterInputProps{
	RouterInputName: jsii.String("failover-input"),
	MaximumBitrate: awscdk.Bitrate_Mbps(jsii.Number(10)),
	RoutingScope: awsmediaconnectalpha.RoutingScope_REGIONAL(),
	Tier: awsmediaconnectalpha.RouterInputTier_INPUT_20(),
	Configuration: awsmediaconnectalpha.RouterInputConfiguration_Failover(&FailoverConfigurationProps{
		NetworkInterface: networkInterface,
		Protocols: []RouterInputProtocol{
			awsmediaconnectalpha.RouterInputProtocol_Rist(&RistProtocolProps{
				Port: jsii.Number(5000),
				RecoveryLatency: awscdk.Duration_Millis(jsii.Number(1000)),
			}),
			awsmediaconnectalpha.RouterInputProtocol_*Rist(&RistProtocolProps{
				Port: jsii.Number(5002),
				 // Must not be consecutive with primary port
				RecoveryLatency: awscdk.Duration_*Millis(jsii.Number(1000)),
			}),
		},
		SourcePriority: awsmediaconnectalpha.SourcePriorityConfig_PrimarySecondary(awsmediaconnectalpha.PrimarySource_FIRST_SOURCE),
	}),
})
```

## Methods

- `bps(amount: number): Bitrate // chainable` (static) — Create a Bitrate representing an amount of bits per second.

  **Parameters**

  - `amount` — the amount of bits per second.

- `gbps(amount: number): Bitrate // chainable` (static) — Create a Bitrate representing an amount of gigabits per second.

  **Parameters**

  - `amount` — the amount of gigabits per second.

- `isUnresolved(): boolean` — Checks if bitrate is a token or a resolvable object.

- `kbps(amount: number): Bitrate // chainable` (static) — Create a Bitrate representing an amount of kilobits per second.

  **Parameters**

  - `amount` — the amount of kilobits per second.

- `mbps(amount: number): Bitrate // chainable` (static) — Create a Bitrate representing an amount of megabits per second.

  **Parameters**

  - `amount` — the amount of megabits per second.

- `toBps(): number` — Return the total number of bits per second.

- `toGbps(): number` — Return the total number of gigabits per second.

- `toKbps(): number` — Return the total number of kilobits per second.

- `toMbps(): number` — Return the total number of megabits per second.
