# FreeProxies turns scraped public nodes into a Clash subscription, refreshed every ten minutes

> FreeProxies is a GitHub project that collects public proxy nodes from across the web, converts them to Clash format, speed tests them and serves the survivors as a subscription link. It is a zero cost answer for occasional use, and a poor answer for anything that needs a stable address, since the nodes are shared by thousands of users.

**bq2015/FreeProxies** — Free proxies for Clash/V2ray/Xray/Trojan. 永久免费科学上网，节点每10分钟自动测速更新，仅保留可用节点。订阅链接可一键导入，无需频繁更换。如果觉得有帮助，请点个星星支持一下。为了防止链接丢失，建议fork到自己的仓库。

- Repository: https://github.com/bq2015/FreeProxies
- Website:  https://blue2sea.com
- Stars: 928 · Forks: 220
- Language: Unknown
- License: not declared
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/bq2015-freeproxies

## Getting the first subscription and importing it

There is nothing to compile and no package to install, so the first use is a link, a browser and a client. The public subscription link is the only thing you need to start.

```
https://blue2sea.com/clash/2376643a6861776f56a4b0f10fab0b2a
```

Open that address in a browser. The page it serves is where the personal subscription option lives, and that is the link you import into your client rather than the public one. The steps the project gives are: download a client such as Clash, generate your own subscription link from that page, paste it into the client, and then use the daily extension code to keep it alive.

Two practical warnings from the project apply at this exact step. The public link is regenerated daily, so a link you saved weeks ago is dead. And if the page shows no link for the current day, the documented fallback is a query page on the same site, which exists because user growth has made the automatic refresh unreliable.

After importing, pick a node from the client and test it. If nothing connects, the usual causes are given in the project notes: the node is dead, the client needs a different protocol setting, or the exit address has been blocked.

## The GitHub repository is a pointer, not the service

The first thing to understand about this project is where the code is not. The repository contains exactly three files: README.md, README.templet and a backup of that template named README.templet.bak. There is no scraper, no speed test harness and no subscription server in the tree.

The pipeline itself is described in prose, in three steps. Nodes of any public protocol, the project lists trojan, ssh, vless and vmess, are fetched from the network and converted into Clash style proxy data before being stored in a database. A scheduled job then pulls entries out of that database and runs them through a speed test tool called clashspeedtest, discarding the ones that fail. A subscription service runs on top and hands out the surviving nodes.

So the GitHub side is a signpost and a set of instructions, while the machinery sits on infrastructure the project does not publish. The homepage points at a commercial site, blue2sea.com, and the public subscription link is served from there. The last push was on 2026-10-22, so the README is being updated regularly even though the repository publishes no releases and declares no license.

## Ten minute refresh and a daily link rotation

The update cadence is unusually aggressive for a free resource. The project states that nodes are tested and updated every ten minutes, and that only working nodes are kept. That claim depends on the speed test step catching failures before a user hits them, which is the whole point of removing dead entries from the database rather than serving a static list.

Separately, the subscription link itself rotates. The public link is described as updated at 21:30 each day to serve the next day. A second mechanism handles expiry: a short extension code that is refreshed every thirty minutes, and which the instructions say is used three times a day to keep a personal subscription alive.

The workflow the project describes is therefore not just paste and go. You open the public subscription link in a browser, find the personal subscription option on that page, and generate a subscription link of your own. That personal link is what you import into the client. Each day you claim the extension code and apply it, and if a personal link ever stops working you extend again.

The project also warns that the public link sometimes fails to refresh because user numbers grew and service stability suffered, and it gives a fallback web page to visit in that case. This is the honest weak point of the design, and it is stated by the project itself rather than inferred.

## Why shared public nodes wear out

The project is unusually candid about what free shared nodes feel like in practice. The notes mention evenings where everything crawls, and IPs that get blocked by services such as ChatGPT and OpenAI, and the daily chore of having to refresh the subscription by hand.

Those are not hypothetical edge cases. They follow from the architecture. The nodes are gathered from public listings, so the same endpoint is likely to be offered by several lists, and every subscriber of the service shares the same small pool of exit addresses. When a node dies, the speed test removes it and the next one takes its place, which is why the ten minute loop exists at all.

The consequence for an engineer is that the free tier and the paid tier of the same operation differ in kind, not in degree. The README itself steers readers toward a paid channel for cross border work, citing stable latency and unblocked access to AI models as the reasons, and it includes a discount code for that service inside the README. That is worth knowing when you read the page, because a large part of the README is an advertisement rather than documentation.

The practical takeaway is that FreeProxies works as a fallback rather than a dependency. A node that works today may be blocked tomorrow, and the identity behind it is not yours.

## One subscription, many clients

Because the output is Clash format, the same subscription can feed a wide range of clients, and the project lists them by platform. On Windows the table points at V2rayN, V2rayW, Clash for Windows, V2rayS, Mellow and Qv2ray. On Android the entries are V2rayNG, Shadowrocket for Android, BifrostV, Clash for Android and Kitsunebi. On macOS there are V2rayU, V2rayX and ClashX. On Linux the list has Qv2ray, Mellow and v2rayL, with an installation document rather than a download for the last one.

The client the project actually recommends is Clash-verge, described as open source and frequently updated. That recommendation is about the client, not about the node list, and it is worth separating the two when you judge the setup.

ShadowsocksR clients get their own table covering Windows, Android and macOS, with the Windows and Android builds pointing at the shadowsocksr-csharp and shadowsocksr-android repositories and the macOS entry pointing at ShadowsocksX-NG-R.

The iOS story is the one gap. The project states that the App Store has no free V2ray client and lists the paid options, naming Shadowrocket, pepi, i2Ray, Kitsunebi and Quantumult. For iOS the SSR section suggests searching the App Store for Mume, Potatso Lite, FastSocks or Shadowrocket. Budget accordingly: a free node list does not mean a free client on Apple hardware.

## Public list versus a server you control

The genuine alternative to this project is not another free list, it is running the exit yourself. With a proxy client and one rented or local server you get a fixed address, a known owner of the traffic, and no shared load. What you give up is the zero cost and the zero maintenance: someone else patches the server, updates the software and absorbs the abuse reports that come with running an open relay.

A third option sits between the two and is what most people end up with. You keep the client and the subscription workflow, and you pay a provider for the nodes, which is what the paid channel in the README offers. The difference from the free list is a stable pool, a private subscription link and support when the node breaks.

FreeProxies is best understood as a lead generator for that third option. The subscription format and the client list transfer directly, so the workflow you learn here is the same workflow you keep if you later pay for nodes.

## Licence, fork and the legal notice

Two administrative details deserve attention before you depend on the project. The repository declares no license, and there is no license file in the tree, so the terms for reusing the README text or automating against the service are not set out. The metadata also lists the primary language as unknown, which is consistent with a repository holding nothing but Markdown.

The project does advise forking the repository to your own account, with the stated reason of preventing the loss of the link. That is sensible advice for a resource whose delivery depends on a single host, and it also explains why the project keeps a template file for its README.

The closing note in the project documentation asks users to comply with the law, suggests using the resource only for learning and research, and states that users bear the risk themselves. Read that as the project's own framing of the legal exposure. Proxy use and the circumstances in which it is lawful vary by country, and whether a shared free node is lawful to use or to redistribute is not a question this repository settles. Anyone who wants to rely on it beyond casual browsing should decide that question separately rather than treat the README notice as covering it.

## Conclusion

Use FreeProxies if you need a working proxy in the next five minutes at no cost and you are willing to accept that the node will be slow, shared and possibly blocked by the services you try to reach. Do not build anything on it that needs a fixed exit address, a predictable speed or a logging position you control. Before you rely on it, check the source of the nodes yourself, since the project states that it gathers them from public listings across the web, and read the licence position carefully, because the repository declares no licence file and its own notice asks users to comply with local law and to bear the risk themselves.

## FAQ

### How often are the nodes in FreeProxies updated?

The project states that nodes are speed tested and updated every ten minutes, with dead entries removed, and that the public subscription link itself is refreshed at 21:30 each day for the next day. A separate extension code is refreshed every thirty minutes and is used to keep a personal subscription active.

### Which proxy protocols does FreeProxies collect?

The described implementation fetches public nodes of any protocol and converts them into Clash format proxy data. The protocols named are trojan, ssh, vless and vmess, and the result is filtered with a speed test tool called clashspeedtest before being served through a subscription link.

### Which client should I use with a FreeProxies subscription?

The project recommends Clash-verge, and it also lists V2rayN, Clash for Windows, Qv2ray, V2rayX, ClashX, V2rayNG, Clash for Android and others by platform. On iOS it notes that the App Store has no free V2ray client and lists paid options such as Shadowrocket.

### Does FreeProxies contain the scraper and subscription server code?

No. The repository holds only README.md, a template file and a backup of that template. The collection, speed testing and subscription steps are described in the documentation, and the homepage and subscription links point at a separate site.

## Sources

- [bq2015/FreeProxies on GitHub](https://github.com/bq2015/FreeProxies)
- [Issues](https://github.com/bq2015/FreeProxies/issues)
- [README](https://github.com/bq2015/FreeProxies/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/bq2015-freeproxies