# jiotv_go serves JioTV live channels to a browser and to IPTV clients > JioTV Go is a Go server that wraps the JioTV Android app API, so live channels can be watched in a web interface or through an M3U playlist, with OTP login, EPG data and configurable quality. It ships as a release binary or a container, and the default container command binds the server publicly on port 5001. **JioTV-Go/jiotv_go** — Unlock the magic of JioTV across all your devices, without the need for the JioTV App. Crafted with love in Golang for a delightful blend of speed and efficiency! 🌟✨ - Repository: https://github.com/JioTV-Go/jiotv_go - Website: https://jiotv_go.rabil.me/ - Stars: 747 · Forks: 203 - Language: Go - License: NOASSERTION - Published: 2026-10-21 · Updated: 2026-10-21 · Language: en - Canonical page: https://hysenlabs.com/projects/jiotv-go-jiotv-go ## It is a wrapper around the JioTV Android app API JioTV Go is described as a project that allows you to stream live TV channels on the web and as IPTV, and the mechanism is stated plainly in the README. It is a web wrapper around the JioTV Android app, utilizing the same API to fetch and stream channels. That single sentence defines both the value and the constraint. There is no transcoding pipeline and no separate content source. The server speaks the same protocol the official app does, fetches the channel list from it, and relays the streams. The features list spells out the surface. Channels stream live in the same way as in the Android app, an M3U playlist is supported for IPTV clients, there is a web interface for watching live TV, and EPG data is available in compressed GZipped XML or in JSON. Quality selection offers Low, Medium and High. The port and host are configurable, authentication uses a Jio number with an OTP, and multiple clients are supported at the same time. Two entries in that list are about the server rather than the video. There is a command-line interface for server management and self-update, and a background start and stop feature. The project describes itself as written in Go for speed, lightness and portability, and the module path in go.mod confirms a v3 major version with a Go 1.26 requirement. ```go module github.com/jiotv-go/jiotv_go/v3 go 1.26 ``` The web server itself is built on Fiber, with gofiber/fiber/v2 v2.52.15 in the dependency list, alongside the HTML template engine and the fasthttp stack underneath it. ## The container image starts the server publicly on port 5001 The repository ships a two-stage Dockerfile, and its final stage is where the runtime defaults live. ```dockerfile FROM alpine:latest ``` ```dockerfile ENV JIOTV_PATH_PREFIX="/app/.jiotv_go" # Volume for credentials VOLUME /app/.jiotv_go # Expose port 5001 to the outside world EXPOSE 5001 ``` Three things in that stage matter operationally. The data directory is a volume, because it holds the credentials. The path prefix is set through an environment variable, so the same image can be pointed at a different location. And the port is exposed as 5001. The default command is the part to read carefully. ```dockerfile CMD ["--skip-update-check", "serve", "--public"] ``` The Dockerfile comment notes that the CMD instruction has been replaced with an ENTRYPOINT to allow arguments. Three flags are implied by default. The update check is skipped, the serve subcommand starts the server, and the --public flag makes it listen beyond the local interface. On a shared host or a home network, that default is more exposure than a first-time user expects, and it is the reason the image is not safe to publish as-is behind a public address. The build stage compiles the binary with size optimisations, using the Go 1.26 Alpine image as the builder and running go build with -ldflags="-s -w" and -trimpath, producing a single static executable that is copied into the final Alpine image. ## The Compose file is a development setup, not a production one Alongside the Dockerfile there is a dev.Dockerfile, a docker-compose.yml, a .devcontainer/ directory and a .dockerignore, which is the usual shape of a project that supports containerised development as well as releases. ```yaml environment: - JIOTV_DEBUG=true - JIOTV_PATH_PREFIX=/app/.jiotv_go ports: - 5001:5001 volumes: - ./:/app env_file: - ./.env ``` The differences from the production image are visible. The compose service builds from the dev.Dockerfile rather than the release Dockerfile, it binds the source tree into the container so edits take effect without a rebuild, it turns on JIOTV_DEBUG, and it reads additional settings from a local .env file. The port mapping is 5001 to 5001, which is also what the release image exposes. For someone who just wants to watch channels, the Compose path is unnecessary. The README points to the latest release for a binary for your operating system, and to a get started guide, and it links video tutorials for Windows and for Android users who are unsure about the installation process. The repository also has a .deepsource.toml, an AGENTS.md file, a CODE_OF_CONDUCT.md, a CONTRIBUTING.md and a SECURITY.md, so the project has the process scaffolding of a project expecting outside contributions. ## OTP login and multiple simultaneous clients Authentication is by Jio number with an OTP, which is the mechanism that ties the server to one subscriber account. The credentials are written into the data directory, which is the directory mounted as a volume in the container and pointed at by JIOTV_PATH_PREFIX. That arrangement explains the volume declaration in the Dockerfile. The credentials survive a container restart, and they are also the most sensitive thing in the deployment, sitting in a plaintext file inside a mounted volume. The multi-client support means several people can watch at the same time from the same login, which is the point of the web wrapper for a household with more than one device. The web interface and the M3U playlist are two ways into the same server, and the quality selection of Low, Medium and High is a server-side choice for the stream. The EPG support is the piece with the most engineering behind it, because a playlist without programme data is awkward to use. The README specifies the formats, compressed GZipped XML or JSON, which are the formats IPTV clients expect. What the documentation does not describe is the session behaviour: how long a login lasts, how often the OTP is required, whether concurrent streams are limited by the upstream service, and what happens when the account is used from several networks at once. The Get Started guide at the documentation site is where those answers would live, and the README itself does not cover them. ## The CLI handles configuration, self-update and background control The command-line interface is built on urfave/cli/v2, version 2.27.7 in the dependency list, which is what produces the serve subcommand seen in the container's default arguments. The CLI covers three jobs according to the feature list. It manages the server, it self-updates, and it can start and stop the service in the background. The configuration side is handled by two libraries, BurntSushi/toml v1.6.0 and gopkg.in/yaml.v3 v3.0.1, so configuration files can be written in TOML or YAML, and ilyakaznacheev/cleanenv v1.5.0 reads settings from environment variables, which is how the JIOTV_DEBUG and JIOTV_PATH_PREFIX values in the container files are consumed. The self-update feature is worth thinking about before enabling it in an environment you care about. A binary that can replace itself is convenient on a home server and questionable on a locked-down host, and the project gives you a way to turn the check off: the --skip-update-check flag in the default container command. Other dependencies suggest the shape of the codebase. madflojo/tasks v1.3.0 is a task runner, which is consistent with the background start and stop feature and with a scripts/ directory in the repository. schollz/progressbar/v3 is for progress reporting, and lumberjack handles log rotation, with the log output written under the data directory. ## Releases, the develop branch, and an attribution licence The default branch is develop, and the release history shows both. A development build was published on 2026-10-05 as develop.2026.10.05.14.04, and the last push was on 2026-10-13, so the two are in step. Versioned releases are tagged separately, with v3.21.0 on 2026-08-12 and v3.22.0 on 2026-08-29, roughly two weeks apart. That branch layout has a practical consequence. Anyone tracking the develop branch is tracking unreleased work, and anyone pinning a v3.x tag is pinning a build that predates the last push by some weeks. The binaries linked from the releases page are the tagged ones. The licence needs reading carefully, because the summary line and the heading disagree slightly. The README heading states the licence is Attribution 4.0 International, CC BY 4.0, and the project is described as open-source and free to use. The repository listing records a custom licence that the hosting platform could not classify, with the terms in the LICENSE file, so the LICENSE file is the document to read. The README adds a specific request: if you come across any unauthorized attempts to sell this project, report them to the maintainer. That is a signal about the intended use. The code is meant to be free, and the content it relays is not the project's to license. Anyone deploying this is relying on their own Jio subscription and their own compliance with the broadcaster's terms, and the repository does not and cannot grant rights over the channels. ## Conclusion Use jiotv_go if you want JioTV live channels in a browser or in an IPTV client on devices that have no JioTV app, and you are comfortable authenticating with your own Jio number over OTP. Do not use it to redistribute the streams beyond your own household, since the content rights sit with the broadcasters and the project only licenses the code. Before running it, read the default container command, because it starts the server with the --public flag on port 5001, and change JIOTV_PATH_PREFIX or your reverse proxy settings so the service is not exposed unauthenticated on a shared network. ## FAQ ### How does jiotv_go get the live TV channels? It is a web wrapper around the JioTV Android app and uses the same API to fetch and stream the channels. There is no separate content source, and the server relays what that API returns. ### How do I install and run jiotv_go? Download the latest binary for your operating system from the repository releases page, or build the container image. The container image exposes port 5001, stores credentials in a volume at JIOTV_PATH_PREFIX, and starts with the command --skip-update-check serve --public. ### Does jiotv_go support IPTV clients and programme guides? Yes. It supports M3U playlist output for IPTV, and EPG data in compressed GZipped XML or in JSON format, with quality selection between Low, Medium and High. ### What authentication does jiotv_go use? Authentication uses a Jio number with an OTP. The credentials are stored in the data directory, which in the container is the volume mounted at /app/.jiotv_go and selected through the JIOTV_PATH_PREFIX environment variable. ### What licence is jiotv_go published under? The README states the licence is Attribution 4.0 International, CC BY 4.0, and describes the project as open source and free to use, while the repository listing records a custom licence with the terms in the LICENSE file. The README also asks that unauthorized attempts to sell the project be reported to the maintainer. ## Sources - [Issues](https://github.com/JioTV-Go/jiotv_go/issues) - [JioTV-Go/jiotv_go on GitHub](https://github.com/JioTV-Go/jiotv_go) - [Project website](https://jiotv_go.rabil.me/) - [README](https://github.com/JioTV-Go/jiotv_go/blob/develop/README.md) - [Releases](https://github.com/JioTV-Go/jiotv_go/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jiotv-go-jiotv-go