# Superalgos: A Visual Crypto Trading Bot Platform You Install Yourself

> Superalgos is an Apache-2.0 JavaScript platform where you draw trading strategies on a visual hierarchy, mine exchange data, backtest, paper trade and deploy live sessions. It is heavy, self-hosted and still in beta snapshots, and the README is honest about the learning curve.

**Superalgos/Superalgos** — Free, open-source crypto trading bot, automated bitcoin / cryptocurrency trading software, algorithmic trading bots. Visually design your crypto trading bot, leveraging an integrated charting system, data-mining, backtesting, paper trading, and multi-server crypto bot deployments.

- Repository: https://github.com/Superalgos/Superalgos
- Website: https://www.superalgos.org
- Stars: 5,670 · Forks: 6,017
- Language: JavaScript
- License: Apache-2.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/superalgos-superalgos

## What Superalgos actually solves for a retail trader

Most retail trading tools hand you a black box: you pick parameters, press run, and hope. Superalgos takes the opposite position. The README describes it as a "community-owned open-source project" and the platform as an ecosystem of tools, and the repository layout backs that up: separate top-level directories for the Platform, Network, Social-Trading, TaskServer, Projects, Dashboards and Plugins. The problem it addresses is that a retail trader who wants to test an idea usually has to assemble a data pipeline, a backtester, a charting interface and an execution layer from four different vendors. Here those pieces live in one application, under one licence, on your machine.

The audience is narrower than the topic list suggests. The README points developers and contributors at the default installation and tells non-developers who want to improve docs or translations to use the same path. It also offers Docker, Raspberry Pi and public cloud routes, and warns that remote and minimalist hardware setups are "better suited for production deployments, where the use of the GUI is minimal". So the project is aimed at people who are willing to run infrastructure, not at people who want a hosted dashboard.

## The visual hierarchy is the strategy definition

The distinctive design choice is that a trading system is not a Python file. It is a hierarchy of nodes you edit in the app: the README points to an integrated charting system, data mining, backtesting and paper trading as parts of the same environment, and the in-app documentation "interacts with the app itself". That coupling matters. When you change a node, the docs and the charts are in the same session as the change.

The data flow implied by the repository is a pipeline rather than a single program. Exchange data is fetched and stored locally, strategies consume it, backtests run against the stored history, and live sessions execute through exchange APIs. The package.json scripts show the pieces are launched separately: node platform, node network, node socialTrading. There is also a TaskServer directory and a Network directory, which is consistent with the README's mention of multi-server deployments and a Social Trading Network.

The trade-off is real. A visual hierarchy is inspectable and shareable in a way a script is not, but it is also harder to diff, review and unit test. The repository does carry .tests/ and a jest unitTest script, so the codebase is tested, but your own strategy logic lives in the app's data structures rather than in files you can put through code review.

## Installing Superalgos and running the first session

The README lists four installation routes: the developer installation in the main README, a Docker deployment in README_Docker.md, Raspberry Pi in README_RaspberryPi.md, and public cloud in README_PublicCloud.md. It also mentions an online demo for a feel of the platform without installing anything.

The repository ships install.sh and install.ps1 at the top level, plus an installer/ directory and a Brewfile. The npm scripts are the documented entry points. setup runs the platform setup, and start launches the platform with two flags, minMemo and noBrowser, which is worth noticing: the default start does not open a browser for you.

```bash
npm run setup
```

The setup script is defined as node setup noShortcuts, and its postsetup hook is npm start, so a successful setup ends by launching the platform. If you prefer to control that separately, start it yourself:

```bash
npm start
```

That resolves to node platform minMemo noBrowser. The README says that once the app is launched, interactive tutorials walk you through the interface, data mining, backtesting and a live trading session. It explicitly recommends doing all of them before exploring on your own.

The tutorials use Binance or Binance US as the exchange. The README states you can follow the whole tutorial without an account, and that if both exchanges are blocked in your region you will need to set up a different exchange from the start. There is a separate README_Binance_RSA_Keys.md for API key handling.

For a headless deployment, the README's appendix documents running Superalgos on a headless Linux server as a daemon, and the Docker README covers isolated environments. The README notes the standard Docker installation is not optimized for development.

## Where Superalgos gets in your way

The learning curve is the first limitation, and the project says so itself: the README calls the tutorials "the absolute best way to tackle the learning curve" and recommends finishing all of them. That is not marketing hedging. A platform with a node hierarchy, a charting system, a data-mining stage and a deployment stage has a lot of surface area before your first backtest.

Memory is the second. The default start script passes minMemo, which implies that without that flag the platform expects more memory than a small machine offers. The README points to a separate system requirements page rather than stating numbers, so check that page for your intended setup instead of assuming a laptop is enough.

Third, the release channel. The recent releases are named Superalgos-Beta-v1.7.0 snapshots, dated daily, while package.json still declares version 1.6.1 and the README header says Superalgos 1.6.1. If you need a stable, versioned artefact with a long support window, this project does not present one; it presents a fast-moving beta line.

Fourth, it is the wrong tool if you want a managed service. Nothing in the README suggests the project operates your trading session for you. You supply the machine, the exchange account and the API keys. The README also does not document rollback for a bad deployment, so plan your own backups of profiles and data.

## Superalgos, Freqtrade and Hummingbot: three different bets

The related searches around this project include Freqtrade, Hummingbot and OctoBot, which is a fair grouping: all four are open source trading tools, and they disagree about where the complexity should live.

Freqtrade is the code-first option. Strategies are Python classes, backtesting is a CLI command, and the whole thing is designed to be scripted and version-controlled. If your team reviews strategy changes in pull requests, that model fits better than a node hierarchy.

Hummingbot is built around market making and liquidity provision across many venues, with a configuration-driven approach to connectors and a community that shares strategy configs. Its centre of gravity is order-book behaviour rather than chart-driven signal design.

OctoBot leans toward a packaged, modular bot with a web interface and a marketplace of strategies, which lowers the entry cost compared with assembling a pipeline yourself.

Superalgos sits at the other end: it is the most visually oriented of the group and the most committed to keeping data, design, testing and deployment inside one application. That is the actual difference in approach. You are not choosing between feature lists; you are choosing whether your trading logic should be a program you own or a design you edit.

## Licence, maintenance and what an upgrade costs you

Superalgos is Apache-2.0, which permits commercial use, modification and redistribution provided you keep the licence and notices, and it includes a patent grant. That is a permissive licence, and it means you can run modified copies on your own infrastructure without publishing your changes. It does not mean the project endorses your trading results, and it says nothing about the terms of the exchanges you connect to. Read those separately, and treat licence questions as legal questions for a lawyer rather than something a README settles.

The repository is not archived, and the last push was on 2026-09-22, with a beta snapshot released the same day and further snapshots on 2026-09-21 and 2026-09-20. Daily snapshots mean upgrades arrive constantly, and that is the cost: there is no long-term support branch described in the README, so every upgrade is a small migration you perform yourself. The repository does include a migrations/ directory and knex migration scripts (migration-init, migration-make) in package.json, which suggests database schema changes are handled with tooling rather than by hand. Profiles, data and strategy definitions are yours to back up; the README does not document a rollback path, so snapshot your working setup before pulling.

## Conclusion

Superalgos suits retail traders who want to own the whole stack (data, strategy design, backtesting, paper trading and live sessions) on their own hardware, and who will actually sit through the interactive tutorials. It is the wrong choice if you want a strategy running in ten minutes, if you cannot leave a machine on to keep data current, or if you expect the platform to tell you which strategies make money. Before committing, check the system requirements page, confirm your exchange is supported, and read the Docker and Raspberry Pi READMEs if you plan to run live sessions without a GUI.

## FAQ

### How do I use Superalgos after installing it?

The README states that once the app launches, a series of interactive tutorials walk you through the interface, data mining, backtesting and a live trading session. It recommends completing all of the tutorials before exploring on your own.

### Is Superalgos legit?

It is an Apache-2.0 open source project whose code and releases are public in the Superalgos/Superalgos repository, and the README describes a community-owned project with a native SA token used to reward contributors. Whether that is trustworthy for your money is a separate judgement; the README does not make performance claims about strategies.

### Is there a free AI trading bot?

Superalgos is free and open source under Apache-2.0, and its package.json describes it as a free, open-source crypto trading bot. The README does not describe the platform as an AI system, so treat any expectation of built-in machine learning as unverified.

## Sources

- [License: Apache-2.0](https://github.com/Superalgos/Superalgos/blob/master/LICENSE)
- [Project website](https://www.superalgos.org)
- [README](https://github.com/Superalgos/Superalgos/blob/master/README.md)
- [Releases](https://github.com/Superalgos/Superalgos/releases)
- [Superalgos/Superalgos on GitHub](https://github.com/Superalgos/Superalgos)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/superalgos-superalgos