# V2ray for Doprax: a fork-and-import V2Ray node on Doprax's free tier > V2ray-for-Doprax packages nginx, WebSocket and VMess/VLess behind TLS into one Docker image you fork and import into Doprax. The README is a deployment recipe, not a product manual, and that shapes what you get. **hiifeng/V2ray-for-Doprax** — The tool can install v2ray on the Doprax, including VMess and VLess protocols, it will automatically switch IP, you need to fork this projects, read readme.md and run it. Create By ifeng. - Repository: https://github.com/hiifeng/V2ray-for-Doprax - Website: https://t.me/HiaiFeng - Stars: 8,324 · Forks: 21,527 - Language: Dockerfile - License: not declared - Published: 2026-09-22 · Updated: 2026-09-22 · Language: en - Canonical page: https://hysenlabs.com/projects/hiifeng-v2ray-for-doprax ## What V2ray-for-Doprax actually deploys The project is a single Docker image that turns a Doprax service into a V2Ray endpoint speaking VMess and VLess over WebSocket, with nginx terminating the front end and TLS in front of it. The README states the scheme directly: Nginx + WebSocket + VMess/VLess + TLS. Doprax is the host, not the protocol. The repository is the packaging. The intended user is someone who already has a Doprax account and does not want to assemble nginx configuration, supervisor process management and a v2ray-core binary by hand. The README's own comparison is to Replit: it says the speed is slower than Replit, but that Doprax advertises unmetered traffic and that the service does not stop once started. Treat that as the author's claim about the platform, not a measured result. The README also warns that you should not abuse the service and that account bans are your own risk, and that if you cannot reach the internet after deployment you should check whether the domain is blocked and consider Cloudflare CDN. Those two lines tell you more about the intended operating context than any feature list does. ## How the image is assembled: nginx, supervisor and entrypoint.sh The Dockerfile starts from nginx:mainline-alpine-slim, exposes port 80, and installs supervisor, wget, unzip and curl with apk. It then copies three files into place: supervisord.conf into /etc/supervisor/conf.d/, nginx.conf over /etc/nginx/nginx.conf, and config.json into /etc/v2ray/. entrypoint.sh goes to /usr/local/v2ray/ and is the container's ENTRYPOINT. Three ENV values drive the configuration: UUID, VMESS_WSPATH and VLESS_WSPATH. They are set in the Dockerfile with a default UUID of de04add9-5c68-8bab-950c-08cd5320df18 and default paths of /vmess and /vless. Because entrypoint.sh is the entrypoint and supervisor runs the processes, the ENV values are what the runtime substitutes into the v2ray and nginx configuration at start. The binary is not built. The Dockerfile downloads v2ray-linux-64.zip from the v2fly/v2ray-core releases at tag v4.45.0, unzips only the v2ray file into /usr/local/v2ray, and separately fetches geosite.dat and geoip.dat from Loyalsoldier/v2ray-rules-dat at the latest release. It then removes wget and unzip, deletes the zip and clears the apk cache. That last step is a size decision with a cost: if the download fails at build time, you debug it without wget inside the image. ## Installing it: fork, import, edit the UUID There is no package to install. The README's deployment path is two steps: fork the project with your GitHub account, then register at Doprax.com and use Import to bring the fork in. The README points to an external page at hicairo.com for the detailed procedure, so the repository itself is not a complete walkthrough. The server-side configuration happens in the Doprax UI. The README says to open Main, then Edit source code, choose the Dockerfile, edit the UUID and the camouflage address, save, and restart the service. Generate a new UUID first with a third-party tool; the README links to the v2fly tools page rather than shipping a generator. ```dockerfile ENV UUID de04add9-5c68-8bab-950c-08cd5320df18 ENV VMESS_WSPATH /vmess ENV VLESS_WSPATH /vless ``` Replace the UUID value with the one you generated. The two path variables define the camouflage paths for VMess and VLess respectively; the README instructs you to change the vmess or vless part of each. It adds two constraints: the path must start with a / character, and you should avoid special characters to prevent unnecessary trouble. After saving, restart the service. The compose.yml in the repository is not the Doprax deployment path. It carries an x-uffizzi ingress block pointing at a service named v2ray-for-uffizzi.com on port 80, and the comments credit the uffizzi.com container to another author and warn that uffizzi.com speeds vary and that Cloudflare CDN is recommended. If you are deploying to Doprax, follow the README, not this file. ## Client setup is manual, and that is the real friction The README is explicit that node client configuration must be done by hand. It uses V2rayN as the example and provides two screenshots, one for VMess and one for VLess, instructing you to change the marked fields and leave everything else as shown. Those screenshots live on hicairo.com, so the repository on its own does not tell you which fields to fill. This is the part that decides whether the project suits you. A server image that boots correctly still leaves you matching UUID, path, host and TLS settings in a client by hand, and any mismatch produces a connection that simply fails with no diagnostic from the server side. The README's troubleshooting note is correspondingly blunt: if you cannot get online after deployment, check whether the domain is blocked and consider Cloudflare CDN. There is no logging section, no health endpoint, and no stated way to confirm from the server that a client's handshake reached nginx. If you want a client that imports a subscription link and configures itself, this repository does not provide one. It provides the server half and a picture of the client half. ## Limitations: a pinned binary, no licence, no rollback The v2ray-core download is pinned to release v4.45.0. Nothing in the Dockerfile or README describes how that pin is updated, and there is no release history in the repository to consult. Upgrading the core means editing the URL in the Dockerfile yourself and rebuilding, then re-verifying that config.json still parses under the new version. The geosite.dat and geoip.dat files are the opposite: they pull from the latest release of v2ray-rules-dat, so two builds of the same commit can embed different rule data. That asymmetry is worth knowing before you treat a build as reproducible. The repository has no licence file at its top level. The README credits the Dockerfile layer optimisation to another author and the uffizzi.com container to a third, but credit is not a licence grant. If you plan to redistribute the image or run it commercially, the terms are simply not stated here. Rollback is undocumented. The README covers editing the Dockerfile and restarting, and does not describe reverting a bad UUID or path change, nor what happens to existing clients when you do. The default UUID is committed in plain text in the Dockerfile, so a fork that is imported without editing it is running a publicly known credential. That is the mistake the README's first configuration step exists to prevent, and it is easy to skip. Wrong tool cases: if you need a documented upgrade path, per-user accounting, or anything resembling an SLA, this is a personal deployment recipe rather than a maintained service. ## Where it sits next to xray-for-uffizzi The compose.yml names the closest sibling directly. It carries an ingress block for a service called v2ray-for-uffizzi.com and a comment crediting the uffizzi.com container to Misaka, linking to Misaka-blog/xray-for-uffizzi. The comment also states that uffizzi.com is fast at some times and slow at others, that it is unstable, and that Cloudflare CDN is recommended. The difference in approach is the platform, not the protocol stack. Both wrap a proxy core behind a web server in a container. This project targets Doprax and pins v2ray-core v4.45.0; the uffizzi variant targets Uffizzi and, by name, runs Xray. The author's own note frames Uffizzi as variable in speed, which is the reason the Doprax variant exists in this repository at all. If you are already on Uffizzi, the compose file here is a pointer to that other project, not an alternative implementation you can switch to without changing hosts. A second alternative is the v2fly tools page the README links for UUID generation. That is a tool, not a deployment, but it is the only other piece of the stack the README expects you to source elsewhere. ## Maintenance, licence and what a fork inherits The repository is not archived, and the last push was on 2026-03-02. That is the only maintenance signal available here; there are no retrieved releases, so there is no changelog to read and no version to pin your deployment to beyond the commit you forked. Upgrade cost falls on the fork owner. The Dockerfile downloads v2ray-core at build time, so a rebuild re-fetches the pinned v4.45.0 archive and the latest rule data. If the upstream release asset moves or the build host loses network access mid-build, the build fails, and wget has already been removed by the time the image is finished. Your recovery path is editing the Dockerfile, not inspecting the running container. On licensing: no licence identifier is present in the repository metadata and no licence file appears at the top level. The components pulled in at build time (v2ray-core, the rule data, nginx, supervisor) each carry their own terms, which the README does not enumerate. If you need to know what you may redistribute, that question has to be answered by reading each upstream project, not this one. ## Conclusion Adopt it if you already have a Doprax account, are comfortable editing ENV values in a Dockerfile, and want a VMess/VLess endpoint without writing the nginx and supervisor plumbing yourself. Do not adopt it if you need a documented upgrade path, a stated licence, or a client that configures itself: the README gives no rollback procedure, the repository carries no licence file, and client setup is manual. Before committing, verify three things in the repository: the UUID value still sitting in the Dockerfile, whether the pinned v2ray-core v4.45.0 download URL still resolves, and whether your Doprax plan still allows the fork-and-import flow the README describes. ## FAQ ### What is V2Ray used for? In this project V2Ray is the proxy core that serves the VMess and VLess protocols; the image ships v2ray-core v4.45.0 and runs it behind nginx and WebSocket with TLS. The README frames the whole deployment as a way to reach the internet through a Doprax-hosted node. ### Can V2Ray be detected? The README does not discuss detection. It does say that if you cannot get online after deployment you should check whether the domain is blocked and consider Cloudflare CDN, and it defines camouflage paths through VMESS_WSPATH and VLESS_WSPATH, which the README describes as the disguise paths for each protocol. ### Is V2Ray better than a VPN? The repository makes no comparison to VPNs. Its only stated comparison is to Replit: the README says the speed is slower than Replit, while Doprax advertises unmetered traffic and a service that does not stop once started. ### Is V2Ray safe? The README's safety notes are operational rather than security claims: do not abuse the service, account bans are your own risk, and check whether the domain is blocked if you cannot get online. It also sets a default UUID of de04add9-5c68-8bab-950c-08cd5320df18 in the Dockerfile and tells you to replace it with a newly generated one. ## Sources - [hiifeng/V2ray-for-Doprax on GitHub](https://github.com/hiifeng/V2ray-for-Doprax) - [Issues](https://github.com/hiifeng/V2ray-for-Doprax/issues) - [Project website](https://t.me/HiaiFeng) - [README](https://github.com/hiifeng/V2ray-for-Doprax/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/hiifeng-v2ray-for-doprax