Streamyfin: an Expo-built Jellyfin client for phones, tablets and TV

What Streamyfin is and who it is for

Streamyfin is a Jellyfin client, not a media server. It does not index or store anything itself. It talks to a Jellyfin server you already run, and the README describes it as "a user-friendly Jellyfin video streaming client built with Expo", positioned as an alternative to other Jellyfin clients. The repository is TypeScript, licensed MPL-2.0, with the default branch set to develop.

The audience is Jellyfin operators and their household members. The prerequisites section is explicit: the device has to be on the same network as the server for local connections, remote access has to be enabled on the server if you connect from outside, and the server version should be current because "older versions may cause compatibility issues". If you are a solo user with one phone and one server on the same LAN, the setup is short. If you administer a server with several users, the plugin is the part that matters, because it pushes settings to everyone rather than making each person configure the app by hand.

There is also a beta channel, and it is not free. The README states that beta access requires the Member tier or higher on Patreon, which grants the beta-releases channel on Discord where APKs and IPAs are shared. It does not provide automatic TestFlight access; the README says to DM the maintainer with the Apple email so it can be added manually. Contributors to the source get automatic access. That is a real constraint on anyone who wants early builds without paying or writing code.

How the client reaches your server, and what the plugin changes

The client is an Expo app, so the same codebase is built for iOS and Android, with TV variants handled by an EXPO_TV environment flag in the build scripts rather than by a separate app. Playback is not the platform player. The README says Streamyfin uses MPV "as its primary video player on all platforms", powered by MPVKit, with credit to a contributor for building the native MPV module. That choice is why format support is broad, and it is also why the app carries native code and cannot be shipped as a pure JavaScript bundle.

The second half of the architecture lives on the server. The Streamyfin plugin for Jellyfin holds the client's settings so they can be synchronized across all users. The README lists what that covers: automatic Seerr login with no user input, preferred default languages, download method and search provider, and home screen personalization. This is the most consequential design decision in the project. Settings stop being per-device and become per-server, which is convenient for a family server and awkward if two users want genuinely different defaults and the operator has to arbitrate.

Downloads are the other mechanism worth understanding before you rely on them. The README states that downloading works by using FFmpeg to convert an HLS stream into a video file on the device, with the conversion handled in real time by Jellyfin on the server. The consequence is stated plainly: it may take longer, but it ensures compatibility with whatever the server can transcode. So a download is not a copy of the original file. It is a transcode that runs while you wait, which means server CPU is busy during every download and the result is only as good as the transcode settings.

Installing Streamyfin and logging in for the first time

Most people will not build the app. The README points at the App Store, Google Play, GitHub releases, and Obtainium for Android users who want to track releases directly. Pick the store listing for your platform, or the latest GitHub release if you want the APK. There is no separate desktop build described, so a Windows or macOS user is looking at the mobile app or nothing.

On first launch you need the server address and an account. The prerequisites require a valid Jellyfin user account with access to the libraries you want to view, and a server that is reachable: same network for local, remote access enabled for outside. Enter the URL in the form your server actually serves, including the scheme and port, then sign in with the Jellyfin credentials.

If you are connecting through an access gateway, the README points to a dedicated document for custom auth headers, naming Cloudflare Zero Trust and Pangolin as examples. That is the path for a server that is not directly exposed.

Building from source is a different job, and the scripts make the shape of it clear. The repository uses Bun, and the start script pulls submodules before launching Expo:

bun install
bun run start

The submodule step matters because the native MPV module lives in a submodule; skipping it produces a build that cannot play video. For a device build, the platform scripts set the TV flag explicitly:

bun run android
bun run ios

TV targets use the same commands with the TV suffix, for example bun run android:tv. The iOS build has an extra prerequisite script, ios:install-metal-toolchain, which the README's script list exposes but does not explain; expect to run it before an iOS build succeeds. There is also a verification path if you are contributing: bun run test chains typecheck, unit tests, lint, format, i18n checks and expo-doctor.

Where Streamyfin is the wrong client

The download model is the first place to be careful. Because FFmpeg transcodes the HLS stream on the server in real time, downloading a season is not a background file copy. It occupies the server, and on a low-power host it will compete with anyone streaming at the same time. If your goal is to fill a tablet before a flight without touching server capacity, a client that saves the original file is a better fit.

Chromecast is the second. The README labels it experimental and says video casting is available while subtitle support is still being worked on. If subtitles are non-negotiable in your household, casting is not the way to watch yet.

The third limit is version coupling. The prerequisites warn that older server versions may cause compatibility issues, and the plugin is a server-side component that has to be installed and configured for the settings features to work. If you run a Jellyfin server you cannot upgrade, or you deliberately stay a few releases behind, the client's feature set is not guaranteed. The README does not document a supported version floor, so the only way to know is to try it against your server.

Finally, there is no desktop client described. The README's download section lists Apple's App Store, Google Play, GitHub releases and Obtainium, all mobile distribution channels. Anyone searching for a Windows build is looking for something the project does not describe.

Streamyfin compared with Swiftfin and Findroid

The obvious comparison is with other Jellyfin clients, and the difference is not cosmetic. Swiftfin is the native Swift client maintained in the Jellyfin organisation; the practical distinction is that Swiftfin is an Apple-platform project, while Streamyfin is an Expo app compiled for both iOS and Android from one TypeScript codebase. If you only use Apple devices, Swiftfin's platform-native approach is the more conventional choice. If your household mixes iPhones and Android phones, Streamyfin's single codebase is the reason the two platforms behave the same.

Findroid is the Android-native option, and the split is similar in shape: a platform-specific client against a cross-platform one. The Streamyfin features that a platform-native client is less likely to match are the server-side plugin for synchronized settings and the Seerr request flow built into the app, since both depend on server components that Streamyfin ships as part of its own project.

There is also a category difference worth naming. Jellysearch is a full-text search proxy for Jellyfin that the README says works with Streamyfin. That is not a competing client; it is a search backend you can point the client at, which is why the plugin exposes a search provider setting. If your library is large enough that Jellyfin's own search is slow, that combination is the reason to care about the setting at all.

Licence, maintenance and the cost of upgrading

Streamyfin is MPL-2.0. In plain terms, that is a file-level copyleft licence: you can use and modify the code, and if you distribute modified files you have to make the source of those files available under the same licence. It is not the GPL, so it does not reach across the whole application the way a stronger copyleft would. This is a description of the licence text, not legal advice; if you plan to ship a fork commercially, read LICENSE.txt and talk to someone qualified.

The repository is not archived, and the last push was on 2026-09-21. The most recent tagged release in the repository is v0.54.1 from 2026-06-02, with v0.51.0 before it in January and v0.47.1 in November 2025. That gap between the last push and the last release is worth noticing: development activity on the develop branch is not the same thing as a new build you can install, and the beta channel is the route to builds that are ahead of the tagged releases.

Upgrade cost has two parts. The client side is ordinary app updating, unless you use Obtainium, in which case you are responsible for tracking GitHub releases yourself. The server side is the plugin, which has to be updated in step with the client for synchronized settings to keep working. The README does not document a rollback path for either, so if a release breaks something, there is no stated way back. Test on one device before pushing an update to a household.

Editorial conclusion

Adopt Streamyfin if you run a reasonably current Jellyfin server and want one client that covers phone, tablet and TV with MPV playback, offline downloads and Seerr requests in the same app. If your server is pinned to an old release, or you need a client that plays without transcoding on a weak host, look elsewhere first. Before you commit, install the Streamyfin plugin on your server and check whether your users' settings match what the app shows after login, because the plugin is what makes the client consistent across accounts.

Frequently asked questions

Official sources

1. License: MPL-2.0
2. Project website
3. README
4. Releases
5. streamyfin/streamyfin on GitHub