MyIP

A no-fluff review of the open-source network diagnostic dashboard. What you get, what it costs, and whether it’s worth deploying.

TL;DR

• What it is: A self-hosted web dashboard that shows your public IPs (IPv4 and IPv6), detects DNS leaks, checks WebRTC exposure, runs speed and latency tests, and bundles 15+ network diagnostic tools under one interface [README].
• Who it’s for: Privacy-conscious people who use VPNs or proxies and want to verify they’re not leaking, developers debugging network routing, and sysadmins who want a single-pane tool for network checks.
• Cost savings: Every commercial alternative (ipinfo.io, whatismyipaddress.com) runs ads, sells your lookup data, or gates bulk queries behind paid APIs. MyIP runs on a $5–10/month VPS, is MIT-licensed, and queries no third-party for your data beyond what you configure [README].
• Key strength: Covers an unusually broad set of tests — from DNS leak detection and WebRTC exposure to MTR hops, censorship checks, and a 258-item cybersecurity checklist — in a single deployable Docker container [README].
• Key weakness: No independent third-party reviews of meaningful depth exist for this project. You’re working from README documentation and the live demo at https://ipcheck.ing. Setup is minimal but the tool is fundamentally a personal/team utility, not a business-process replacement. Pricing comparison math is straightforward — there isn’t much to compare.

---

What is MyIP

MyIP is an open-source web application that functions as a personal IP and network diagnostics toolbox. The project lives at https://github.com/jason5ng32/MyIP, carries an MIT license, and has accumulated roughly 9,979 GitHub stars — enough to appear on Trendshift’s trending repositories list and get included in the Awesome Self-Hosted curated index [README].

The demo runs at https://ipcheck.ing and you can bookmark it without deploying anything. If you want it on your own domain, behind your own network, without sending any request data through a third-party’s servers, you deploy the Docker container or run the Node.js build yourself.

The pitch is simple: instead of opening five different browser tabs (whatismyip.com for your public IP, ipleak.net for DNS leaks, fast.com for speed, some other site for Whois), you have one interface that does all of it. The GitHub description calls it “The best IP Toolbox” — which is the kind of claim that’s easy to make when the field mostly consists of single-feature sites running Google Ads [README].

The project is bilingual-first — the README is available in English, Simplified Chinese, French, and Turkish, and the UI ships with those language options built in. This is a signal about the actual user base: the author (jason5ng32) is Chinese, and a meaningful portion of the star count is likely from users in regions where VPN usage and network censorship checks are a day-to-day concern rather than an occasional curiosity [README].

---

Why people choose it

Independent reviews specifically about this project are sparse. The sources attached to this review are about different products sharing the “MyIP” name — a commercial VPN service (myip.io), a separate MCP npm package, and a decade-old Windows desktop app. None of them review the jason5ng32/MyIP toolbox. What follows is drawn from the README, the live demo, and the general pattern of self-hosted network tool adoption visible in communities like r/selfhosted and r/privacy.

The VPN verification use case is the primary one. When you connect to a VPN, you want to verify three things: (1) your public IP changed to the VPN’s exit node, (2) DNS queries are routing through the VPN and not leaking to your ISP’s resolver, and (3) WebRTC isn’t bypassing the VPN and leaking your real IP to websites. These are three different attack surfaces, and they require three different tests. MyIP runs all three simultaneously and shows the results on a single page [README]. This is the reason the tool gets starred and shared — it’s not intellectually interesting, it’s practically useful.

The “tabs problem.” Most network diagnostic workflows involve five to eight different websites, each with a different interface, each running ads, each logging your queries. MyIP consolidates the common ones. The Availability Check feature — which tests whether Google, GitHub, YouTube, ChatGPT, and other specific services are reachable from your location — is particularly useful for users in regions with selective blocking [README].

Privacy of the diagnostic tool itself. There’s a mild irony in using a commercial IP-lookup site to check your VPN: you’re handing your query history to another third party. Self-hosting MyIP means the only entities that see your lookups are the upstream IP geolocation APIs you configure (or the defaults the project ships with), not an ad-supported website with its own analytics stack.

---

Features

Based on the README and the live demo:

IP detection:

• Detects local IPs and public IPs simultaneously from multiple IPv4 and IPv6 providers [README]
• Shows detailed geolocation, ASN, country, and region for each detected address [README]
• Supports querying any arbitrary IP address for the same information [README]

Privacy and leak detection:

• DNS leak test — shows the DNS endpoints your system is actually using, not what your VPN claims [README]
• WebRTC detection — reveals whether WebRTC is exposing a real IP address despite an active VPN [README]
• Proxy rule testing — verifies that proxy software routing rules are configured correctly [README]

Connectivity and routing:

• Website availability check — tests whether specific services (Google, GitHub, YouTube, ChatGPT, etc.) are reachable [README]
• Global latency test — pings servers in different geographic regions [README]
• MTR test — runs traceroute-style path analysis to servers in different regions [README]
• Speed test against edge networks [README]

Lookup and research tools:

• DNS resolver — resolves a domain from multiple sources simultaneously, useful for detecting DNS poisoning [README]
• Censorship check — tests whether a website is blocked in specific countries [README]
• Whois search — for both domain names and IP addresses [README]
• MAC address lookup [README]
• Browser fingerprinting — multiple methods to calculate browser fingerprint [README]
• Cybersecurity checklist — 258 items [README]

Interface:

• Dark mode, auto-toggled from system settings [README]
• Minimalist mode for mobile — shorter page, faster access to key info [README]
• PWA support — installable as a desktop or home screen app [README]
• Keyboard shortcuts for all functions (press ? to view the list) [README]
• Multi-language: English, Chinese, French, Turkish [README]

The breadth here is unusual for a single-container tool. Most comparable self-hosted projects are single-purpose (dnsleaktest alternatives, Whois wrappers, speed test servers). MyIP is closer to a network diagnostics Swiss Army knife.

---

Pricing: SaaS vs self-hosted math

This comparison is short because there isn’t much SaaS to compare to.

MyIP is MIT-licensed software — the license is $0. The hosted demo at https://ipcheck.ing is free to use with no account required. There’s no commercial cloud tier from this project [README].

Self-hosted cost:

• Software: $0 (MIT)
• VPS to run it: $5–10/month on Hetzner, Contabo, DigitalOcean, or Oracle Free Tier (which is $0 for the always-free tier)
• Docker image: jason5ng32/myip:latest, single-command deploy [README]

What you’re replacing: The commercial alternatives aren’t SaaS subscriptions you’re canceling — they’re free websites you’re replacing with something that doesn’t harvest your lookups. There’s no dramatic monthly bill to eliminate. The case for self-hosting is privacy and consolidation, not cost savings.

If you use an IP geolocation API for your own application and currently pay for ipinfo.io or ip-api.com API access, MyIP’s REST API (listed in the features) could substitute for some lookups — but that’s a secondary use case.

Bottom line on pricing: self-host on a $5 VPS, or use the free demo. There’s no subscription math to run here.

---

Deployment reality check

The README gives two paths: Docker and Node.js [README].

Docker (recommended):

docker run -d -p 18966:18966 --name myip --restart always jason5ng32/myip:latest

That’s a single command. The application runs on port 18966 by default. No database, no external dependencies required to start. If you want to put it behind a domain with HTTPS, add Caddy or nginx as a reverse proxy — this is standard Docker self-host procedure [README].

Node.js:

git clone https://github.com/jason5ng32/MyIP.git
npm install && npm run build
npm start

Also straightforward. Requires Node.js installed on the host [README].

Environment variables for advanced config: The README documents a configuration table. Key ones: BACKEND_PORT (default 11966), FRONTEND_PORT (default 18966), SECURITY_RATE_LIMIT (requests per IP per 60 minutes, default 0 = unlimited) [README]. This last one is worth setting if you’re exposing the instance publicly — without rate limiting, your instance is an open proxy-checking tool for anyone who finds it.

What you actually need:

• A Linux VPS with 512MB–1GB RAM (this isn’t a heavy application)
• Docker installed
• A reverse proxy if you want HTTPS (Caddy handles this with two config lines)
• Optionally: a domain name

What can go sideways:

• The upstream IP geolocation providers MyIP queries can be rate-limited if you’re using a shared IP range. This isn’t a configuration problem — it’s a limitation of free-tier geolocation APIs.
• Exposing the instance publicly without rate limiting means anyone can use your server for DNS leak checks. Fine for personal use, potentially a resource concern if the URL gets shared.
• The browser fingerprint and speed test features require the browser to make direct requests — these work fine from any deployment but require HTTPS for some browser APIs to function correctly.

Realistic time estimate: 15–30 minutes to a working HTTPS instance for someone comfortable with Docker and a reverse proxy. For a first-time self-hoster following a guide, budget 1–2 hours.

---

Pros and cons

Pros

• MIT license. Deploy it, fork it, embed it in your product, run it inside a corporate intranet — no commercial agreement needed [README].
• Comprehensive feature set in one container. DNS leak, WebRTC, MTR, censorship check, Whois, speed test, browser fingerprinting, MAC lookup — all in one Docker pull [README].
• Zero dependencies to start. Single Docker command, no database, no Redis, no SMTP required for basic operation [README].
• PWA support. Install it as a home screen app on mobile, which makes VPN-verification a one-tap operation [README].
• Almost 10K GitHub stars. Not proof of quality, but proof that enough people found it useful to star it — and it’s listed in Awesome Self-Hosted, which has a human curation bar [README].
• Active CI. The README shows CodeQL scanning and Docker build/push workflows on the main branch — signals the project isn’t completely abandoned [README].
• Rate limiting built in. The SECURITY_RATE_LIMIT environment variable lets you protect a public instance without adding a separate WAF [README].

Cons

• No independent reviews. There’s no Trustpilot, G2, or meaningful third-party analysis of this specific project. You’re flying on README and demo alone.
• Upstream API dependency. MyIP shows you IP geolocation data from external providers — which providers, and whether they get rate-limited, isn’t documented in detail in the README. If those providers throttle your instance’s IP, results degrade silently.
• Single maintainer risk. The project is owned by one GitHub user (jason5ng32). No company, no issue-tracker-indicated team, no contributor covenant. It has 270+ contributors on community pieces (wait, that’s Activepieces) — actually, contributor count isn’t specified in the MyIP README. This is a solo-maintainer project until proven otherwise.
• No authentication. The tool has no built-in login or user management. If you expose it publicly, anyone can use it. The rate-limiting env var helps, but access control is your responsibility (basic auth at the reverse proxy level).
• Limited customization. The feature set is fixed. You can’t add custom monitoring targets or integrate it with other tooling via webhooks or a rich API. It’s a dashboard, not a platform.
• “Cybersecurity checklist” is vague. 258 checklist items sounds impressive but the README doesn’t clarify what those items are or what “checking” means for each — manual verification prompts? automated tests? Data not available without running the tool.

---

Who should use this / who shouldn’t

Use MyIP if:

• You regularly use a VPN or proxy and want a reliable, self-hosted tool to verify DNS isn’t leaking and WebRTC isn’t exposing your real IP.
• You’re in a region where network censorship is a daily reality and you want to check service availability without using a public tool that logs queries.
• You want one URL you can open on any device to get a complete picture of your current network state.
• You’re comfortable with Docker and want a 15-minute deploy.
• You manage a small internal network and want a diagnostics tool accessible to non-technical teammates without installing anything.

Skip it if:

• You just want to check your IP occasionally — https://ipcheck.ing (the live demo) already gives you that for free without deploying anything.
• You need an API for programmatic IP geolocation in your application. Use ipinfo.io, ip-api.com, or MaxMind directly — they have documented SLAs and bulk pricing.
• You’re looking for network monitoring with alerting, dashboards over time, or historical data. MyIP is a point-in-time snapshot tool, not a monitoring system. Use Uptime Kuma, Netdata, or Prometheus for ongoing observability.
• You want user authentication and multi-user access. There’s no built-in auth — you’d need to wrap it with a reverse proxy that handles that.

---

Alternatives worth considering

For DNS leak testing specifically:

• https://dnsleaktest.com — purpose-built, widely cited, no self-hosting needed for one-off checks.
• https://ipleak.net — similar single-purpose tool, also free to use.

For IP geolocation lookup:

• ipinfo.io — the standard API for programmatic use, has a generous free tier. Commercial product, not self-hosted.
• ip-api.com — free for non-commercial use, JSON API.

For speed testing:

• LibreSpeed — self-hostable speed test server, MIT license, more configurable than MyIP’s speed test feature.
• Speedtest CLI (Ookla) — the standard benchmark, not self-hosted.

For network monitoring (different use case):

• Uptime Kuma — self-hosted uptime monitoring with alerting. Fills a different need but often deployed alongside MyIP.
• Netdata — full system and network metrics, heavier but richer.

For browser fingerprinting specifically:

• coveryourtracks.eff.org — the EFF’s browser fingerprint tool, single-purpose and well-maintained.

The honest summary: there’s no direct self-hosted competitor that matches MyIP’s feature breadth in a single container. Dedicated tools do individual tests better. MyIP wins on consolidation.

---

Bottom line

MyIP is a narrow-purpose tool that does its narrow purpose well. It won’t replace a SaaS subscription or save you a meaningful monthly fee — but it will replace a messy workflow of five different browser tabs with a single self-hosted URL, remove your VPN-check queries from ad-supported websites’ analytics, and give you a mobile-installable PWA you can open the moment your VPN connects. The MIT license, single-command Docker deploy, and near-zero resource requirements make the barrier to entry genuinely low. The lack of independent reviews and single-maintainer structure are real risks for anything you’d depend on critically — but for a personal diagnostics dashboard, the GitHub star count and Awesome Self-Hosted listing are reasonable proxies for “this thing works.” If you’re already self-hosting anything at all, this belongs in the stack. If the command line is unfamiliar territory, use the live demo at https://ipcheck.ing instead.

---

Sources

Primary source:

• GitHub repository and README — jason5ng32/MyIP (9,979 stars, MIT license). https://github.com/jason5ng32/MyIP

Live demo:

• IPCheck.ing — public demo instance of MyIP. https://ipcheck.ing

Curation reference:

• Awesome Self-Hosted — community-curated list of self-hostable software; MyIP is listed. https://github.com/awesome-selfhosted/awesome-selfhosted

Note: The third-party articles provided with this assignment (sources [1]–[6]) refer to unrelated products sharing the “MyIP” name — a commercial VPN service (myip.io), a separate MCP npm package by a different author, a Windows desktop app, and unrelated blog content. None review the jason5ng32/MyIP toolbox. They are not cited in this article to avoid misrepresentation.