Presets

Presets are reusable encoding templates that define how a video should be transcoded — the codec, resolution, quality tier, container format, audio settings, and more. Instead of specifying all encoding parameters on every job, you can reference a preset by its ID or slug.

System vs Custom Presets

Transcodely provides two types of presets:

Type	Description	Modifiable	Available To
System	Built-in presets maintained by Transcodely	No	All apps
Custom	Created by your team for your specific needs	Yes	Your app only

System presets cover common use cases (e.g., h264_1080p_standard, av1_4k_premium) and are always available. Custom presets let you fine-tune settings for your specific content and delivery requirements.

Creating a Custom Preset

A custom preset captures the video, audio, container, and quality settings you’d otherwise repeat on every job. A create call sets an identifying slug and name, the container and delivery format, then the video and audio encoding blocks and a quality_tier — each covered in the sections below. The response returns the stored preset with its generated pst_ ID and an estimated_cost_per_minute.

curl -X POST https://api.transcodely.com/transcodely.v1.PresetService/Create 
  -H "Authorization: Bearer {{API_KEY}}" 
  -H "X-Organization-ID: org_a1b2c3d4e5" 
  -H "Content-Type: application/json" 
  -d '{
    "slug": "web_720p_fast",
    "name": "Web Optimized 720p",
    "description": "Fast encoding for web delivery",
    "content_type": "film",
    "container": "mp4",
    "faststart": true,
    "delivery_format": "progressive",
    "video": {
      "codec": "h264",
      "resolution": "720p",
      "bitrate_mode": "crf",
      "crf": 23,
      "profile": "high",
      "encoder_preset": "fast"
    },
    "audio": {
      "codec": "aac",
      "bitrate_kbps": 128,
      "sample_rate": 48000,
      "channels": 2,
      "normalize": true
    },
    "quality_tier": "standard"
  }'

const preset = await client.presets.create({
  slug: "web_720p_fast",
  name: "Web Optimized 720p",
  description: "Fast encoding for web delivery",
  contentType: ContentType.FILM,
  container: Container.MP4,
  faststart: true,
  deliveryFormat: DeliveryFormat.PROGRESSIVE,
  video: {
    codec: VideoCodec.H264,
    resolution: Resolution.RESOLUTION_720P,
    bitrateMode: BitrateMode.CRF,
    crf: 23,
    profile: "high",
    encoderPreset: "fast",
  },
  audio: {
    codec: AudioCodec.AAC,
    bitrateKbps: 128,
    sampleRate: 48000,
    channels: 2,
    normalize: true,
  },
  qualityTier: QualityTier.STANDARD,
});

preset = client.presets.create(
    slug="web_720p_fast",
    name="Web Optimized 720p",
    description="Fast encoding for web delivery",
    content_type="film",
    container="mp4",
    faststart=True,
    delivery_format="progressive",
    video={
        "codec": "h264",
        "resolution": "720p",
        "bitrate_mode": "crf",
        "crf": 23,
        "profile": "high",
        "encoder_preset": "fast",
    },
    audio={
        "codec": "aac",
        "bitrate_kbps": 128,
        "sample_rate": 48000,
        "channels": 2,
        "normalize": True,
    },
    quality_tier="standard",
)

preset, err := client.Presets.Create(ctx, &transcodely.PresetCreateParams{
	Slug:           "web_720p_fast",
	Name:           "Web Optimized 720p",
	Description:    proto.String("Fast encoding for web delivery"),
	ContentType:    transcodely.ContentTypeFilm,
	Container:      transcodely.ContainerMP4,
	Faststart:      proto.Bool(true),
	DeliveryFormat: transcodely.DeliveryFormatProgressive,
	Video: &transcodely.VideoSettings{
		Codec:         transcodely.VideoCodecH264,
		Resolution:    transcodely.Resolution720P,
		BitrateMode:   transcodely.BitrateModeCRF,
		Crf:           proto.Int32(23),
		Profile:       proto.String("high"),
		EncoderPreset: proto.String("fast"),
	},
	Audio: &transcodely.AudioSettings{
		Codec:       transcodely.AudioCodecAAC,
		BitrateKbps: 128,
		SampleRate:  proto.Int32(48000),
		Channels:    proto.Int32(2),
		Normalize:   proto.Bool(true),
	},
	QualityTier: transcodely.QualityTierStandard,
})

{
  "preset": {
    "id": "pst_x9y8z7w6v5",
    "slug": "web_720p_fast",
    "name": "Web Optimized 720p",
    "content_type": "film",
    "container": "mp4",
    "faststart": true,
    "video": { "codec": "h264", "resolution": "720p", "..." : "..." },
    "audio": { "codec": "aac", "bitrate_kbps": 128, "..." : "..." },
    "quality_tier": "standard",
    "estimated_cost_per_minute": 0.023,
    "system_preset": false,
    "created_at": "2026-01-15T10:30:00Z",
    "updated_at": "2026-01-15T10:30:00Z"
  }
}

Slugs

Every preset has a unique slug — a URL-safe identifier using lowercase letters, numbers, and underscores. Slugs must be unique within your app and are used to reference presets in job creation:

{
  "outputs": [
    { "preset": "web_720p_fast" },
    { "preset": "pst_x9y8z7w6v5" }
  ]
}

Both the slug and ID can be used in the preset field when creating jobs.

You can look up a preset by slug:

curl -X POST https://api.transcodely.com/transcodely.v1.PresetService/GetBySlug 
  -H "Authorization: Bearer {{API_KEY}}" 
  -H "X-Organization-ID: org_a1b2c3d4e5" 
  -H "Content-Type: application/json" 
  -d '{ "slug": "web_720p_fast" }'

const preset = await client.presets.getBySlug("web_720p_fast");

preset = client.presets.get_by_slug("web_720p_fast")

preset, err := client.Presets.GetBySlug(ctx, "web_720p_fast")

Video Settings

The video object defines all video encoding parameters:

Field	Description	Example
`codec`	Video codec	`h264`, `h265`, `vp9`, `av1`
`resolution`	Target resolution (use this or `width` + `height`)	`480p`, `720p`, `1080p`, `1440p`, `2160p`, `4320p`
`width`	Custom output width in pixels (128-7680)	`1280`
`height`	Custom output height in pixels (128-4320)	`720`
`framerate`	Target FPS (0 = keep original, max 240)	`30`, `60`
`bitrate_mode`	Rate control	`crf`, `cbr`, `vbr`
`crf`	Quality factor (lower = higher quality)	`23` (H.264 range: 15-35)
`bitrate_kbps`	Target bitrate in kbps for `cbr`/`vbr` modes (100-100000)	`4000`
`max_bitrate_kbps`	Maximum bitrate for VBV in kbps (100-240000)	`6000`
`buffer_size_kbps`	VBV buffer size in kbps (100-480000)	`8000`
`profile`	Codec profile	`baseline`, `main`, `high`
`level`	Codec level	`3.0`, `4.0`, `5.1`
`encoder_preset`	Speed/quality tradeoff	`ultrafast` to `slower`
`tune`	Content-aware tuning	`film`, `animation`, `grain`
`keyint`	GOP size / keyframe interval in frames (1-600)	`48`
`min_keyint`	Minimum keyframe interval (1-60)	`24`
`bframes`	Number of B-frames (0-16)	`3`
`refs`	Number of reference frames (1-16)	`4`
`rc_lookahead`	Rate control lookahead frames (0-250)	`40`
`aq_mode`	Adaptive quantization mode (0-3)	`1`
`aq_strength`	Adaptive quantization strength (0.0-3.0)	`1.0`
`psy_rd`	Psychovisual rate-distortion (`strength:trellis`)	`1.0:0.0`
`deblock`	Deblocking filter strength (`alpha:beta`)	`0:0`, `-1:-1`

Audio Settings

Field	Description	Example
`codec`	Audio codec	`aac`, `opus`, `mp3`
`bitrate_kbps`	Target bitrate	`128`, `192`, `256`
`sample_rate`	Sample rate in Hz	`44100`, `48000`
`channels`	Channel count (0 = keep original)	`2` (stereo)
`normalize`	Apply EBU R128 loudness normalization	`true`

To produce audio-free outputs from a preset, set disable_audio: true at the top level of the request. Outputs derived from the preset then drop audio entirely, unless an individual output overrides disable_audio. Defaults to false.

Content Types

The content_type field optimizes encoder settings for specific content:

Content Type	Best For
`film`	Movies, TV shows — natural motion, fine detail
`animation`	Anime, cartoons — flat colors, sharp edges
`grain`	Vintage, noir — preserve film grain texture
`gaming`	Game recordings — fast motion, screen content
`sports`	Live sports — high motion, high framerate
`stillimage`	Slideshows — mostly static frames

Multi-Variant Presets

A preset can define a complete adaptive bitrate (ABR) ladder by attaching a list of variants (up to 20). Each variant inherits the preset’s shared settings — codec, quality tier, audio, and streaming — and overrides only the per-rendition values below. Variants are only valid when delivery_format is hls, dash, or cmaf.

Field	Description	Example
`resolution`	Target resolution for this variant	`720p`
`width`	Custom output width in pixels (128-7680)	`1280`
`height`	Custom output height in pixels (128-4320)	`720`
`bitrate_kbps`	Target bitrate in kbps for `vbr`/`cbr` modes (100-240000)	`2500`
`max_bitrate_kbps`	Maximum bitrate for VBV in kbps (100-240000)	`3000`
`buffer_size_kbps`	VBV buffer size in kbps (100-480000)	`4000`
`crf`	CRF override for this variant	`23`
`quality`	Quality tier override for this variant	`standard`
`framerate`	Frame rate override (0 = keep original)	`30`

{
  "delivery_format": "hls",
  "video": { "codec": "h264", "bitrate_mode": "vbr" },
  "variants": [
    { "resolution": "1080p", "bitrate_kbps": 5000 },
    { "resolution": "720p", "bitrate_kbps": 2500 },
    { "resolution": "480p", "bitrate_kbps": 1000 }
  ]
}

For HLS/DASH/CMAF presets you can also attach a streaming configuration carrying segment duration, GOP alignment, and format options. See the adaptive streaming guide and Streaming for details.

Duplicating Presets

Clone any preset (system or custom) as a starting point for a new custom preset:

curl -X POST https://api.transcodely.com/transcodely.v1.PresetService/Duplicate 
  -H "Authorization: Bearer {{API_KEY}}" 
  -H "X-Organization-ID: org_a1b2c3d4e5" 
  -H "Content-Type: application/json" 
  -d '{
    "source_id": "pst_x9y8z7w6v5",
    "slug": "web_720p_fast_v2",
    "name": "Web Optimized 720p (v2)"
  }'

const preset = await client.presets.duplicate({
  sourceId: "pst_x9y8z7w6v5",
  slug: "web_720p_fast_v2",
  name: "Web Optimized 720p (v2)",
});

preset = client.presets.duplicate(
    source_id="pst_x9y8z7w6v5",
    slug="web_720p_fast_v2",
    name="Web Optimized 720p (v2)",
)

preset, err := client.Presets.Duplicate(ctx, "pst_x9y8z7w6v5", "web_720p_fast_v2", "Web Optimized 720p (v2)")

This is particularly useful for creating variations of system presets — duplicate a system preset, then modify the copy to suit your needs.

Listing Presets

Listing returns both the built-in system presets and your custom presets, filterable by content type, quality tier, and video codec. Results are paginated, and the SDKs expose auto-paging iterators that walk every page for you.

curl -X POST https://api.transcodely.com/transcodely.v1.PresetService/List 
  -H "Authorization: Bearer {{API_KEY}}" 
  -H "X-Organization-ID: org_a1b2c3d4e5" 
  -H "Content-Type: application/json" 
  -d '{
    "include_system": true,
    "video_codec": "h264",
    "quality_tier": "standard",
    "pagination": { "limit": 50 }
  }'

for await (const preset of client.presets.list({
  includeSystem: true,
  videoCodec: VideoCodec.H264,
  qualityTier: QualityTier.STANDARD,
  pagination: { limit: 50 },
}).autoPage()) {
  console.log(preset.id, preset.slug);
}

for preset in client.presets.list(limit=50).auto_paging_iter():
    print(preset.id, preset.slug)

iter := client.Presets.List(ctx, &transcodely.PresetListParams{
	IncludeSystem: proto.Bool(true),
	VideoCodec:    transcodely.VideoCodecH264.Enum(),
	QualityTier:   transcodely.QualityTierStandard.Enum(),
	Pagination:    &transcodely.PaginationRequest{Limit: 50},
})
for iter.Next() {
	preset := iter.Current()
	fmt.Println(preset.GetId(), preset.GetSlug())
}
if err := iter.Err(); err != nil {
	log.Fatal(err)
}

Cost Estimation

Each preset includes an estimated_cost_per_minute field that shows the per-minute encoding cost based on the preset’s codec, resolution, framerate, and quality tier. This lets you estimate costs before submitting jobs. See Pricing for the full cost calculation.

#Presets

#System vs Custom Presets

#Creating a Custom Preset

#Slugs

#Video Settings

#Audio Settings

#Content Types

#Multi-Variant Presets

#Duplicating Presets

#Listing Presets

#Cost Estimation

Run this against your own file