# OctoBot vs Passivbot

Two free perp bots funded by exchange rebates — and on the one number that decides a perpetual position, one charges a constant and the other charges nothing at all.

*https://cryptomarkets.tools/compare/octobot-vs-passivbot*

- https://cryptomarkets.tools/tools/octobot.md
- https://cryptomarkets.tools/tools/passivbot.md

## Two free bots, one honest difference

Both are free, both are open, both are funded by exchange rebates rather than by you, and both
will run a perpetual-futures strategy on your own machine for months. They are also built for two
different people, and the gap that matters is not the interface.

**[OctoBot](https://cryptomarkets.tools/tools/octobot)** is GPL-3.0 Python with a web interface. Sixteen trading modes ship —
grid, DCA, crypto basket, TradingView signals, arbitrage, staggered orders, two market-making
modes — and you configure rather than write. It installs as an executable, a Docker image or a
marketplace app.

**[Passivbot](https://cryptomarkets.tools/tools/passivbot)** is public domain, Python around a Rust core, and has no
interface at all. You describe a contrarian perp market maker in JSON — price bands, an EMA
context, exposure limits, a profit margin, a trailing retrace — and leave it running. The same
Rust orchestrator computes order placement for the backtest and for live trading, which is a
stronger guarantee of parity than most frameworks in this catalogue can make.

## The funding gap, which is the whole page

A perpetual position pays or receives funding every few hours. Over a strategy that holds
positions for weeks, funding is not a rounding error — it is frequently the largest single cash
flow after the entry and the exit.

**OctoBot charges it, at one constant rate forever.** The fee is debited from the simulated
wallet, liquidation is modelled, and the rate is a single configured value — default 0.00005,
always positive — applied to every interval of the run. Real funding flips sign and spikes;
this one does neither. The cause is structural rather than careless: the history collector only
implements candle download, so there is no funding series to charge against.

**Passivbot does not charge it at all.** Nothing in the shared Rust engine credits or debits a
funding payment, in backtest or in live accounting. A long-biased grid backtested through a period
of positive funding will show money the account would never have had — and the sign of the error
depends on which side the strategy was on, which is worse than a constant bias because it is not
correctable by eye.

So: one of them is wrong in a known direction by a known amount, and the other is silent. Neither
is a reason to reject the software; both are reasons to check funding separately before believing
a curve. That is a general problem in this category, not a defect unique to these two.

## The rest of the trade

**Interface against control.** Sixteen modes in a browser, or a JSON file and a command line.
OctoBot's modes cover more strategies than Passivbot will ever have; Passivbot does one thing and
exposes every parameter of it.

**Paper trading.** OctoBot has it. Passivbot's `fake` exchange is a regression fixture, not a
simulator, so the distance from backtest to live money is one config change.

**Slippage.** Neither models it. OctoBot's limit orders fill in full the moment price touches
them, and simulated fees default to zero unless you set them. Read both cards' Limitations before
sizing anything.

**The hosted escape hatch.** OctoBot has one — [OctoBot Cloud](https://cryptomarkets.tools/tools/octobot-cloud) is a separate
product, not a tier, and it runs the same engine on the vendor's infrastructure. Passivbot has
nothing of the kind, by design.

## Which one, and when

**Take OctoBot** if you want to try several strategies without writing code, if you want a paper
run before real money, or if a graphical interface is the difference between doing this and not
doing it. Its funding model is wrong in a bounded, predictable way, which is the better kind of
wrong.

**Take Passivbot** if you know exactly the strategy you want — a contrarian grid on perps, held
for months — and you would rather have one engine shared between backtest and live than a
configurable suite. Then measure funding on your own pairs and your own period, and adjust the
backtest by hand, because the software will not do it for you.

**Take neither** if the backtest is the point rather than the bot.
[Freqtrade](https://cryptomarkets.tools/tools/freqtrade) reads maker and taker fees from the exchange and downloads funding
per venue; [NautilusTrader](https://cryptomarkets.tools/tools/nautilus-trader) will settle funding if you bring the data;
[hftbacktest](https://cryptomarkets.tools/tools/hftbacktest) models queue position and latency. The engines built for
research are on the [backtesting shelf](https://cryptomarkets.tools/categories/backtesting-libraries), and this page is about
two bots.

## FAQ

### Which one models funding in a backtest?

OctoBot, partially. It does debit funding from the simulated wallet and it models liquidation, but the simulated exchange returns one configured value for every interval — 0.00005 by default and always positive. Passivbot does not model funding at all; grepping the whole tree for "funding" returns one file, and there it is a note about stock prices. For a bot that holds perpetual positions for months, that is the most consequential difference on this page.

### Why does OctoBot use a constant rate instead of real history?

Because it has no funding history to use. Its history collector implements candle download and nothing else — the ticker, order-book, recent-trades and kline collectors are empty stubs — so there is no historical funding series to charge against, even though the backtesting database has a table waiting for one. The constant is a consequence of the data layer, not a modelling choice.

### Which is easier to run?

OctoBot, clearly. It installs as an executable on Windows, macOS, Linux or a Raspberry Pi, or as a Docker image, and you configure it in a web interface by picking one of sixteen trading modes. Passivbot is a JSON configuration file and a command line, with a Rust core underneath. If you would not enjoy editing JSON for an afternoon, that settles it.

### Who pays for them, given both are free?

Exchanges, in both cases, and both document it. OctoBot states on its own exchanges page that it relies on exchange partnerships and that trading on partner venues supports the project, with nineteen partners and referral links in the README. Passivbot ships `broker_codes.hjson` with codes for Binance, Bybit, Bitget, OKX, KuCoin, GateIO and WEEX, and lists Hyperliquid, Bitunix, defx and paradex with null to say explicitly that those carry no broker payload.

### Can I paper-trade before going live?

OctoBot yes, Passivbot no. Passivbot's `fake` exchange harness is a deterministic regression fixture rather than a paper-trading mode, so the step between a backtest and real money is shorter than most people expect.