PASTA

A focused self-hosted utility for Plex users who are tired of changing audio and subtitle tracks one episode at a time. No marketing fluff, just what you actually get.

---

TL;DR

• What it is: A lightweight, client-side web app that connects to your Plex server and lets you switch audio tracks and subtitle tracks across entire TV shows in one action [README].
• Who it’s for: Plex users who watch content in multiple languages, who have mixed subtitle files, or who are simply exhausted by Plex’s per-episode track selection [README].
• Cost: Free. Runs on GitHub Pages (zero infrastructure) or self-hosted via a single Docker container [README].
• Key strength: Solves a real and specific Plex annoyance — bulk audio/subtitle management — cleanly and without requiring you to touch a command line [README].
• Key weakness: Very narrow scope, modest community (420 GitHub stars), no stated license, and maintained by a solo developer with no commercial backing. No third-party reviews exist at time of writing — only the README and GitHub data are available to assess it.

---

What is PASTA

PASTA stands for Audio and Subtitle Track Changer for Plex. The name itself tells you what it does and nothing more. Before PASTA existed, if you wanted to switch your 24-episode Korean drama from the forced English dub to the original Korean audio track, you opened Plex, clicked into every single episode, and changed the track. Twenty-four times. PASTA solves that [README].

The tool connects to your Plex server using your Plex authentication token, browses your libraries, and presents the full track metadata for every item — including details that Plex’s own UI obscures. That last point is quietly useful: if your media has two subtitle tracks both labeled “English (SRT)” and you can’t tell which one is the SDH version and which is the theatrical version, PASTA shows you the underlying track details to disambiguate them [README].

The developer (GitHub user cglatot) built it originally for personal use after encountering this exact problem, saw that others wanted the same thing, and released it publicly. The name was born from the original working title — “Audio Track Automation for Plex” — when subtitles were added and the letters got reshuffled [README].

One architectural note worth understanding up front: PASTA runs entirely client-side. Your Plex credentials and server data pass directly between your browser and your Plex server — not through any intermediary server run by the developer. The hosted version on GitHub Pages is just static files. This is a meaningful privacy property for a tool that requires your Plex token [README].

As of this review: 420 GitHub stars, available on Unraid Community Applications, and maintained via issues on GitHub. The developer accepts Ko-fi donations, which suggests this is a one-person side project rather than a funded product.

---

Why People Choose It

No third-party reviews of PASTA were found during research. The tool occupies a niche so specific that dedicated reviews don’t appear to exist — the GitHub README and issues tracker are the primary signals of real-world usage.

What can be inferred from the README and the tool’s stated purpose: PASTA fills a gap that Plex has never officially addressed. Plex’s track selection is per-item, always has been, and the company has shown no urgency to add bulk operations. The community workarounds before PASTA were either command-line scripts (Python/Bash against the Plex API) or simply manual clicking. PASTA sits in the middle: a UI with the convenience of a web app and the power of direct API access.

The tool is available on Unraid Community Applications, which is the primary discovery channel for this category of self-hosted Plex utilities. Unraid’s NAS community is exactly the audience — technically comfortable users who run local media servers and want quality-of-life tooling around them [README].

Performance is explicitly noted as dependent on network proximity: PASTA works “MUCH faster” when your browser is on the same LAN as the Plex server [README]. This is expected for any tool that’s making sequential API calls against a media library — over the internet, setting tracks across a 50-episode show with a round-trip to a remote server will be noticeably slower than doing it from a machine on the same subnet.

---

Features

Based on the README:

Core track management:

• Connect to any Plex server using your Plex authentication token [README]
• Browse libraries and view audio and subtitle track details per item [README]
• Set audio tracks and subtitle tracks for an entire TV series in one operation [README]
• Set tracks for individual episodes when you want episode-level control [README]
• View granular track metadata — useful when multiple tracks share identical display names [README]

Deployment options:

• Hosted on GitHub Pages — no infrastructure required, open your browser and use it [README]
• Docker image (cglatot/pasta) available on DockerHub [README]
• Local download from GitHub for fully offline use [README]
• ARM builds supported (Raspberry Pi and similar devices) via docker buildx [README]
• Available in Unraid Community Applications for NAS users [README]

Architecture:

• Entirely client-side — no server component, no data passing through developer infrastructure [README]
• No database, no accounts, no persistent state beyond what’s in your Plex server [README]

What it does not do:

• It does not download or manage subtitle files (that’s Sub-Zero / OpenSubtitles / Bazarr territory)
• It does not manage metadata, posters, or ratings (that’s Kometa / Plex Meta Manager territory)
• It does not encode or transcode media
• It does not modify files on disk — it only tells Plex which existing track to default to

The feature set is deliberately minimal. This is a sharp tool for one job.

---

Pricing: SaaS vs Self-Hosted Math

PASTA is free. There is no SaaS version, no paid tier, no enterprise plan, and no usage limits. The hosted GitHub Pages version costs you nothing to use. Self-hosting via Docker adds the cost of a container on whatever server you’re already running Plex on — which in most cases is zero incremental cost because you’re adding one more container to a machine that’s already running.

Concrete breakdown:

Option	Cost	Setup time
GitHub Pages hosted	$0	5 minutes (enter Plex token)
Docker on existing server	$0 incremental	15 minutes
Docker on dedicated VPS	$4–6/mo (Hetzner/Contabo)	30 minutes
Unraid Community Applications	$0 incremental	10 minutes

There is no comparison to a commercial SaaS because no commercial equivalent exists. Plex itself does not sell a bulk track management feature. The comparison is PASTA versus doing it manually, and the math on that is obvious at scale: a 12-season TV show with 200+ episodes means 200+ individual track selections without it.

No pricing data exists beyond this because there is nothing to price.

---

Deployment Reality Check

PASTA has three deployment paths. In order of effort:

GitHub Pages (zero deployment): Go to the hosted URL, enter your Plex server address and token. You’re done. The tool runs in your browser. The caveat: your browser must be able to reach your Plex server, so if Plex is purely local (no remote access enabled), you need to use PASTA from a device on the same network. External access requires Plex remote access or a VPN into your home network [README].

Docker (standard path): A minimal compose file from the README:

services:
  pasta:
    image: cglatot/pasta
    container_name: pasta
    ports:
      - 8087:80
    restart: unless-stopped

No volumes, no environment variables, no database, no Redis. The container serves static files. For anyone already running Docker for Plex and related tools, this adds about 15 minutes including pulling the image and verifying it starts [README].

ARM / Raspberry Pi: The README includes a specific guide for ARM builds. You clone the repo, run docker buildx build -t "cglatot/pasta:latest" --platform linux/arm64 ., create a compose file, and bring it up. More involved than pulling a pre-built image, but documented and reported working [README].

What can go wrong:

• If your Plex server is behind a reverse proxy or requires specific CORS headers, the client-side architecture might hit cross-origin request issues. The README doesn’t address this explicitly.
• The “much faster on same network” note is a real constraint — if you’re running this remotely over a slow connection against a large library, setting tracks across hundreds of items can take a while.
• No license is specified in the GitHub repository or the merged profile data. This isn’t a barrier to personal use, but it matters if you’re embedding PASTA in a commercial product or redistributing it. If license clarity is important to you, check the current repository or open an issue to ask.
• Solo developer maintenance model. There’s no company, no roadmap, no SLA. If the developer goes quiet, the issue tracker is your only recourse. The Ko-fi donation link suggests the project runs on goodwill and spare time.

Realistic time to a working setup for a technical user: 15–30 minutes for the Docker path. For using the hosted GitHub Pages version: 5 minutes if you know where to find your Plex token.

---

Pros and Cons

Pros

• Solves a real problem Plex ignores. Bulk audio and subtitle track selection for TV shows is a genuine gap in Plex’s UI. PASTA fills it directly [README].
• Zero cost. No tiers, no usage limits, no API key costs [README].
• Client-side architecture. Your Plex token and server data never touch an external server [README]. This is more privacy-respecting than tools that proxy your media server requests.
• Multiple deployment options. GitHub Pages for immediate use, Docker for self-hosting, local download for fully offline setups, Unraid for NAS users [README].
• ARM support. Raspberry Pi and similar devices are explicitly supported with documented build instructions [README].
• Low resource footprint. Static files served by a minimal web server. One container, no database, no background jobs.
• Name disambiguation. The ability to see detailed track metadata distinguishes between identically-named tracks — a specific annoyance with multi-source media collections [README].

Cons

• No stated license. The repository does not appear to specify a license. For personal use this is fine; for anything else, legal status is unclear.
• Solo developer, no commercial backing. PASTA runs on one person’s time. Bug fixes and new features happen when the developer has availability. No roadmap, no support channel beyond GitHub Issues [README].
• 420 stars is a small community. This is a niche tool. Expect limited community knowledge, fewer tutorials, and slower issue resolution than mature self-hosted projects [GitHub].
• No mobile-optimized UI mentioned. The README doesn’t describe a responsive layout. For most use cases (NAS management, library maintenance), this is used from a desktop anyway.
• Performance depends on network. The README explicitly flags this. Remote use over slow connections or large libraries will be slow [README].
• No third-party reviews exist. There is no independent assessment of PASTA’s reliability, edge cases, or long-term stability beyond GitHub Issues and the README. You’re relying on the developer’s self-description.
• Plex-only. If you switch to Jellyfin or Emby, PASTA is not useful. This is by design, but worth noting.
• No HTTPS out of the box. The Docker compose example binds to port 8087 with no TLS. You need to add your own reverse proxy (Caddy, nginx, Traefik) if you want HTTPS for remote access.

---

Who Should Use This / Who Shouldn’t

Use PASTA if:

• You run Plex and regularly watch multilingual content or content with multiple subtitle options.
• You’ve ever had to manually set the same audio or subtitle track across a full TV series and found it tedious.
• You want to understand what’s in your media’s track metadata, not just the display name.
• You’re comfortable entering a Plex token into a web app (or running Docker).
• You run Unraid and want a community-apps-available solution without manual setup.

Skip it if:

• You don’t use Plex. This tool has no other use case.
• You need subtitle file management, not just track selection. Look at Bazarr or Sub-Zero instead.
• You need a fully supported, commercially backed tool with an SLA. PASTA is a side project.
• You can’t reach your Plex server from where you’d want to run PASTA (no remote access, restrictive network), and you’re not willing to set that up separately.
• License ambiguity is a concern for your deployment (corporate IT, redistribution).

---

Alternatives Worth Considering

For the problem PASTA solves — bulk Plex track management — the realistic alternatives are limited:

• Plex itself (native). Per-episode track selection exists in the native Plex UI. It’s what PASTA replaces. Not an alternative, but the baseline state.
• Plex API scripting. Python or Bash scripts using the Plex API can bulk-set tracks with more flexibility than PASTA, but require writing code. For non-technical users, not realistic.
• Sub-Zero / OpenSubtitles / Bazarr. These tools download and manage subtitle files, not which existing track is selected. Adjacent problem, different solution.
• Kometa (formerly Plex Meta Manager). Manages metadata, collections, posters, and overlays. Does not manage audio/subtitle track defaults.
• Jellyfin / Emby. If you’re considering switching media servers, both have their own track management — but that’s a larger decision than a utility swap.

No direct PASTA competitor was found during research. The combination of “Plex-specific”, “bulk track selection”, and “web UI” appears to have only one implementation with meaningful community adoption.

---

Bottom Line

PASTA is a single-purpose tool that does exactly what its name says and nothing else. If you run Plex and you’ve ever had the experience of opening twenty episodes in sequence to switch the audio track, PASTA removes that friction permanently. It’s free, it’s client-side (your data stays between you and your Plex server), it deploys in under 30 minutes via Docker, and it works on ARM hardware. The caveats are real: solo developer, no license, no commercial backing, and no third-party validation beyond 420 GitHub stars and a documented real-world problem solved. For a personal Plex setup, those trade-offs are easy to accept. For anything requiring stability guarantees or commercial licensing clarity, they’re not.

If you’re already running a self-hosted media stack with Plex, PASTA is worth the 15 minutes to stand up a Docker container. The worst outcome is it doesn’t fit your workflow and you remove one container. The best outcome is you never click through episodes one by one again.

---

Sources

1. cglatot/pasta — GitHub README. Primary documentation for PASTA: deployment, architecture, features, and use cases. https://github.com/cglatot/pasta
2. PASTA on DockerHub — Official container image. https://hub.docker.com/r/cglatot/pasta
3. PASTA official website — https://www.pastatool.com
4. Unraid Community Applications — PASTA listing reference. https://github.com/selfhosters/unRAID-CA-templates

Note: No independent third-party reviews of PASTA were found during research. All substantive claims in this article are sourced from the project’s own README and GitHub repository. This is noted explicitly so readers can weight the assessment accordingly.