# JKVideo: a React Native Bilibili client that stopped at v1.0.19 > JKVideo packages DASH playback, danmaku, WBI signing and live streaming into one Expo app for Bilibili. Its README opens with a legal notice saying maintenance has ended, which changes what the code is good for. **tiajinsha/JKVideo** — B React Native. High-looking third-party B station React Native client - Repository: https://github.com/tiajinsha/JKVideo - Stars: 4,993 · Forks: 2,849 - Language: TypeScript - License: MIT - Published: 2026-08-08 · Updated: 2026-08-18 · Language: en - Canonical page: https://hysenlabs.com/projects/tiajinsha-jkvideo ## What JKVideo is, and why the README starts with a legal notice JKVideo describes itself as a high-looking third-party B station React Native client, and the repository is a TypeScript Expo app that talks to Bilibili's API. It is not a player wrapper around an official SDK. It reimplements the parts a client needs: video stream negotiation, danmaku timelines, login by QR code, live room sockets, and download management with a local HTTP server for LAN sharing. The audience is narrow and specific. This is for React Native developers who want to see how a real client handles signed API requests, DASH manifests and danmaku synchronization in one codebase. It is also for people who want to read a working example of WBI signing written in plain TypeScript. The first block of the README is a notice, not a feature list. According to the README, the project received a lawyer's letter from Bilibili demanding that it stop calling Bilibili's API and stop the imitation work, and the repository stopped maintenance and updates, stopped accepting new issues and pull requests, and kept the existing code only for study reference. The disclaimer repeats that the project is for personal study and research and must not be used commercially. The last push to the repository was on 2026-05-12, which is the same day as the v1.0.19 release. Treat the code as frozen, because the project says it is. ## How the playback pipeline works: DASH to MPD to ExoPlayer The core mechanism is documented in the feature list. Bilibili serves DASH streams, and a DASH stream needs a manifest before a native player can consume it. JKVideo calls buildDashMpdUri() to generate a local MPD file, then hands that to ExoPlayer for native decoding. The README claims support for 1080P and 4K HDR Dolby Vision through this path, with the caveat that the higher tiers need a paid account. That design is the reason the app has two playback modes. With a Dev Build, the native path runs. With Expo Go, the README says video playback degrades to a WebView solution, which injects an HTML5 video element. The fallback exists because Expo Go cannot load the native modules the DASH path needs. The same split explains why the quick-start section labels Expo Go as limited and Dev Build as recommended. Danmaku follows two separate pipelines because video and live are different problems. For video, the app fetches a danmaku XML and syncs it against the timeline, then draws it across five lanes as an overlay. For live rooms, danmaku arrives over a WebSocket in real time, and the client additionally tracks captain badges and gift counts. The README does not describe reconnection behaviour for that socket, which is the kind of gap you would want to read the hooks and services directories to close. State is held in Zustand stores. The README names VideoStore as the mechanism that keeps a mini player running across page changes, and lists separate stores for login, downloads, playback and settings. Networking goes through Axios with a Cookie interceptor in the services layer. ## Installing JKVideo and getting a first video to play The README gives three ways to run the project plus a prebuilt APK. The fastest is Expo Go, which needs no compilation but downgrades playback. Clone the repository, install dependencies, and start the Expo dev server: ```bash git clone https://github.com/tiajinsha/JKVideo.git cd JKVideo npm install npx expo start ``` The terminal prints a QR code. Scanning it with the Expo Go app on Android or iOS opens the project. The README warns that some quality tiers are restricted in this mode and that video playback falls back to the WebView path, so expect a working app with a weaker player. For the full pipeline, build a dev client instead. The README gives these commands, and package.json exposes the same ones as scripts: ```bash npm install npx expo run:android # Android npx expo run:ios # iOS（需 macOS + Xcode） ``` The iOS command requires macOS with Xcode. This build path is what enables native DASH playback at 1080P and above and the full danmaku system, according to the README. If you only want to look at the app, the releases page has an APK; the README notes that Android must allow installing apps from unknown sources. There is a fourth target. Web runs through the same Expo CLI, but Bilibili's image hotlink protection blocks images unless a local proxy is running: ```bash npm install npx expo start --web ``` The README states that on the Web target images need the local proxy server to bypass the hotlink protection, run as node scripts/proxy.js on port 3001. The package.json also defines a proxy script that points at dev-proxy.js at the repository root, so the two files are not the same thing; check which one the README means for your setup. Once the app is open, the login screen generates a QR code and polls every two seconds, extracting SESSDATA from the response headers. The README notes the code expires after ten minutes and that closing and reopening the dialog refreshes it. ## The limitations table is the most honest part of the repository JKVideo ships a known-limitations table, and it is worth more than the feature list. The first row says 4K and 1080P+ require a paid account, because Bilibili's API policy restricts those tiers. That means the headline playback capability is conditional on the user's own subscription, not on anything the app does. The second row rules out FLV live streams entirely. Neither HTML5 nor ExoPlayer supports FLV, so the client automatically selects HLS instead. If a room only offers FLV, this client cannot play it. The third row is a Web-specific tax: Bilibili blocks images by Referer, so the browser build needs the local proxy on port 3001. The fourth row is the one that matters most for anyone judging completeness. Dynamic feeds, posting, and liking are not implemented, because they require the bili_jct CSRF token. In other words, the app is read-mostly. It can log in and watch, and it can download, but it does not act on the account in the ways a first-party client does. The fifth row is small but real: the login QR code expires after ten minutes. None of these are bugs. They are boundaries of the API surface the project chose to cover, and the README states them plainly. A reader deciding whether to reuse this code should start from this table, not from the screenshots. ## WBI signing without a crypto dependency, and what that buys you The feature list calls out WBI signing as pure TypeScript with a hand-written MD5 and no external encryption dependency. That is a deliberate choice, and it is the part of the codebase most likely to be useful outside this app. Bilibili's WBI scheme requires signing requests with a key derived from the account, and the README says the nav interface result is cached for 12 hours to avoid re-fetching the keys. Implementing MD5 by hand avoids pulling a crypto library into a React Native bundle, where native crypto modules add build complexity. The trade-off is that the implementation is yours to audit. If you lift this code, read the MD5 and the signing routine rather than trusting the feature bullet. This is also where the project's legal position becomes concrete. WBI signing exists to authenticate requests to Bilibili's API, and the README's notice says the project was asked to stop calling that API. The signing code is a clean example of a protocol, and it is also the exact mechanism the notice is about. How you treat that depends on your own situation, and the repository's LICENSE file and disclaimer are the primary sources, not this summary. ## Downloads, LAN sharing, and the mini player Two features distinguish JKVideo from a thin client. The first is background downloading at multiple quality levels, paired with a built-in HTTP server that generates a QR code so other devices on the same Wi-Fi network can scan it and play the file directly. The dependency list includes @dr.pogodin/react-native-static-server, which is consistent with that description. This is a genuinely useful pattern for anyone building offline media features in React Native, and the README says nothing about access control on that server. If you reuse it, assume the LAN is trusted until you read the code. The second is the global mini player. The README says that after switching pages, a floating layer at the bottom continues playback, with VideoStore synchronizing state across components. The home screen builds on this with inline DASH autoplay muted inside a BigVideoCard, horizontal gestures for seeking, and live cards mixed into a two-column layout. The pager is react-native-pager-view, and routing is expo-router v4 with file-system routes. The project structure reflects all of this: app/ holds route files including video/[bvid].tsx and live/[roomId].tsx, components/ holds the player and danmaku UI, hooks/ holds the data hooks, services/ wraps the Bilibili API with Axios and a Cookie interceptor, store/ holds the Zustand stores, and utils/ holds formatting, image proxying and MPD construction. ## How JKVideo compares with a WebView wrapper The obvious alternative to a project like this is a thin wrapper: point a WebView at the mobile site and let Bilibili's own player handle everything. That approach has real advantages. It never touches the API directly, so there is no signing to implement, no danmaku parser to maintain, and no per-quality negotiation to reverse. When Bilibili changes something, the wrapper usually keeps working. JKVideo goes the other way. It implements the protocol surface itself: buildDashMpdUri() for manifests, a danmaku XML timeline plus a five-lane overlay for video, a WebSocket client for live rooms, WBI signing, and a QR login flow that reads SESSDATA from response headers. That is more code and more to break, and the known-limitations table shows the cost: no FLV, no dynamic feeds, no posting or liking, and quality tiers gated by account status. The payoff is control. A wrapper cannot render danmaku in its own lanes, cannot build a local MPD for ExoPlayer, and cannot run a mini player that survives navigation through its own state store. If your goal is a native-feeling client with custom overlays, the wrapper approach cannot get there. If your goal is to display Bilibili content with minimum maintenance, the wrapper is the smaller bet, and it sidesteps the API-calling question that the README's notice is about. ## Licence, maintenance and the cost of upgrading The repository is MIT licensed, and the README repeats the MIT label with a 2026 copyright line. MIT permits reuse with attribution and without warranty, but it does not grant rights to Bilibili's content or API, and the README's disclaimer states that all video content belongs to the original creators and Bilibili, and that the project has no affiliation with Bilibili. Those are separate questions, and this article is not legal advice; read the LICENSE file and the disclaimer in the repository. On maintenance, the picture is unambiguous. The README states that maintenance and updates stopped, and that new issues and pull requests are not accepted. The last push was on 2026-05-12, matching the v1.0.19 release, with v1.0.18 a week earlier on 2026-05-05. There is no later activity to point to. The upgrade cost follows from that. The dependency set is pinned to Expo SDK 55 and React Native 0.83, with React 19.2. Moving forward means doing the upgrade yourself, and any future Bilibili API change will not be absorbed here. For a study reference that is acceptable. For anything you intend to run for years, it is the deciding factor. ## Conclusion Read JKVideo as a reference implementation, not as something to ship. Its most useful parts are the pure-TypeScript WBI signing, the buildDashMpdUri() path that turns a Bilibili DASH stream into a local MPD for ExoPlayer, and the live danmaku WebSocket handling. Anyone building a commercial client against Bilibili's API should not start here: the README states the project received a lawyer's letter from Bilibili and stopped maintenance, and the disclaimer limits use to personal study. Before borrowing anything, check the bili_jct CSRF gap in the known-limitations table, confirm whether the 4K and 1080P+ tiers you need require a paid account, and read the LICENSE file in the repository rather than this article. ## FAQ ### What is the JKVideo app? JKVideo is a third-party Bilibili client written in TypeScript with React Native and Expo. The README describes DASH playback, a danmaku system, WBI signing, QR login, downloads with LAN sharing, and live streaming support. It is MIT licensed and the README says it is kept only for study reference. ### How do I install JKVideo? Clone the repository, run npm install, then npx expo start and scan the QR code with Expo Go, or use npx expo run:android or npx expo run:ios for a dev build with full DASH playback. A prebuilt Android APK is also available from the releases page. ### Why does JKVideo no longer receive updates? The README states the project received a lawyer's letter from Bilibili asking it to stop calling Bilibili's API and stop the imitation work. It says the repository stopped maintenance and updates and no longer accepts new issues or pull requests, keeping the code for study reference. ### Why can't JKVideo play 4K or 1080P+ video without logging in? The known-limitations table attributes this to Bilibili's API policy, which requires a paid account for those tiers. Logging in with a qualifying account is what unlocks them; the app itself does not bypass the restriction. ## Sources - [Official README](https://github.com/tiajinsha/JKVideo#readme) - [Project repository](https://github.com/tiajinsha/JKVideo) - [Release notes](https://github.com/tiajinsha/JKVideo/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/tiajinsha-jkvideo