Hummingbot on VPS: Step-by-Step Installation for Market Making

What is Hummingbot and why does it need a VPS?

Installing Hummingbot on a VPS for market making requires choosing a suitable Ubuntu VPS with a minimum of 2 vCPU and 4 GB RAM, installing dependencies, cloning the repository or using Docker, and running the bot, which allows automating trading strategies on exchanges like Binance or OKX.

Hummingbot is a powerful open-source framework for creating high-frequency trading bots focused on market making and arbitrage on cryptocurrency exchanges. It allows traders to automate strategies such as Pure Market Making (PMM), Cross-Exchange Market Making, and Arbitrage on various centralized (CEX) and decentralized (DEX) platforms. Using Hummingbot makes it possible to constantly place buy and sell orders, profiting from the spread and providing market liquidity.

Running Hummingbot on a reliable VPS (Virtual Private Server) is critically important for achieving maximum efficiency and security. Unlike a local computer, a VPS provides:

• 24/7 Operation: The bot runs 24/7 without interruptions, independent of your home internet or power supply.
• Low Latency: Valebyte servers, located in modern data centers with high-speed channels, minimize latency when sending orders to exchanges, which is especially important for market making strategies. We wrote in detail about how this affects trading in the article VPS for Binance: Setting up a Trading Bot with Minimal Latency.
• Stability and Reliability: Professional VPS providers guarantee high uptime and stable operation without sudden disconnections.
• Security: An isolated VPS environment with firewall configuration and SSH access provides better protection for your API keys and trading operations.
• Scalability: You can easily increase VPS resources as your trading capital grows or you launch additional bots.

Essentially, a VPS becomes your dedicated "workplace" for Python development and uninterrupted trading bot hosting, providing ideal conditions for effective market making bot hosting.

Which VPS to choose for Hummingbot: resource requirements?

Choosing the optimal VPS for Hummingbot is a key step to ensure stable and efficient operation of your trading bot. Minimum requirements for a single Hummingbot instance running one or two strategies include:

• CPU: 2 vCPU. Hummingbot actively uses the processor for calculations, data processing, and order management.
• RAM: 4 GB. This amount is sufficient to run the bot itself, the operating system (Ubuntu), and several strategies. If you plan to run multiple instances or use more complex strategies, 8 GB RAM is recommended.
• Disk: 40-80 GB NVMe SSD. Disk speed is important for fast loading and log writing, and NVMe ensures minimal latency.
• Operating System: Ubuntu Server 20.04 LTS or 22.04 LTS. This is the most common and well-supported OS for such tasks.
• Bandwidth: Minimum 100 Mbps, but 1 Gbps is preferred. For market making, not only low latency but also stable bandwidth is important. A dedicated server with unmetered bandwidth can be especially useful for intensive data exchange.

Recommended Valebyte VPS configurations for Hummingbot

For reliable and scalable grid bot vps or other strategies, we recommend the following plans:

The choice of a specific plan depends on your ambitions. For starting with one strategy on Hummingbot Binance, VPS-S will be sufficient. If you plan to scale or use multiple strategies, it's better to consider VPS-M right away.

Step-by-step Hummingbot installation on Ubuntu VPS

The Hummingbot setup process on an Ubuntu VPS involves several key steps. We recommend using Docker to simplify installation and dependency management.

Step 1: Connect to VPS and update the system

After receiving your VPS access details, connect to it via SSH:

ssh root@YOUR_IP_ADDRESS

Update the package list and installed packages:

sudo apt update
sudo apt upgrade -y

Step 2: Install Docker

Docker significantly simplifies Hummingbot deployment by isolating it from the main system and managing all dependencies. Install Docker Engine:

sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

Verify that Docker is installed correctly:

sudo docker run hello-world

For convenience, add your user to the docker group so you don't have to use sudo every time:

sudo usermod -aG docker $USER
newgrp docker

Step 3: Run the Hummingbot container

Now you can run Hummingbot in a Docker container. This is done with a single command that will download the image, create the container, and forward the necessary ports and volumes to save data.

docker pull coinalpha/hummingbot:latest
docker run -it --name hummingbot_instance \
  -v $(pwd)/hummingbot_files:/home/hummingbot/conf/ \
  -v $(pwd)/hummingbot_logs:/home/hummingbot/logs/ \
  -v $(pwd)/hummingbot_data:/home/hummingbot/data/ \
  -v $(pwd)/hummingbot_scripts:/home/hummingbot/scripts/ \
  -p 8080:8080 \
  coinalpha/hummingbot:latest

Command explanations:

• -it: Interactive mode with pseudo-TTY.
• --name hummingbot_instance: Assigns a name to the container for easy management.
• -v $(pwd)/hummingbot_files:/home/hummingbot/conf/ and other -v: Mount local folders on your VPS (in the current directory where you run the command) inside the container. This allows you to save configurations, logs, and data even after deleting or updating the container.
• -p 8080:8080: Forwards port 8080 from the container to your VPS. This port can be used to access the Hummingbot web interface (if you configure it).
• coinalpha/hummingbot:latest: Specifies the Hummingbot Docker image.

After executing this command, Hummingbot will start, and you will see its console.

Hummingbot configuration: connecting to exchanges and creating a strategy

After successfully launching Hummingbot in the console, you will need to configure it to work with selected exchanges and strategies.

Step 1: Create a password and wallet

When you first launch Hummingbot, it will ask you to create a password. This is important for encrypting your API keys and other sensitive data. Enter a strong password and store it in a safe place.

>>> Enter new password:
>>> Confirm new password:

Then, if you plan to use DEX, Hummingbot will offer to create or import a wallet. This is not required for CEX.

Step 2: Connect to exchanges (e.g., Binance)

To connect to centralized exchanges such as Hummingbot Binance or OKX, you will need API keys and secret keys, which you must generate on the respective exchange. Make sure these keys are allowed access to trading, but not to withdrawals, for maximum security.

In the Hummingbot console, execute the command:

connect binance

The bot will ask for your API key and secret key. Enter them carefully.

>>> Enter your binance API key:
>>> Enter your binance secret key:

Repeat this procedure for all exchanges you plan to work with.

Step 3: Create a strategy

Hummingbot supports many strategies. To create a new strategy, use the create command:

create

The bot will prompt you to choose a strategy type (e.g., pure_market_making, cross_exchange_market_making, arbitrage). Then it will guide you through a series of questions to configure parameters: selecting the exchange, trading pair, spread, order size, etc. Answer the questions carefully, considering your trading goals and risks.

Example of pure_market_making setup:

>>> What is your market making strategy? (pure_market_making, cross_exchange_market_making, arbitrage, etc.): pure_market_making
>>> Enter the exchange name you would like to use (e.g. binance, kucoin, etc.): binance
>>> Enter the trading pair you would like to trade on binance (e.g. ETH-USDT): BTC-USDT
>>> What is the amount of BTC per order? (e.g. 0.001): 0.001
>>> What is the spread % from the mid price? (e.g. 0.1): 0.1
... and so on ...

After completing the setup, the strategy will be saved in a configuration file in the hummingbot_files/conf/strategies/ folder on your VPS. You can edit this file manually or using the config command in Hummingbot.

Step 4: Start the strategy

To start the created strategy, use the start command:

start

If you have multiple strategies, you can start a specific one by name:

start <strategy_name>

The bot will begin placing orders according to your configuration. You can monitor its operation using the status and history commands.

Popular Hummingbot strategies: PMM, Cross-Exchange, Arb

Hummingbot offers a flexible set of strategies that allow automating various trading approaches. Let's look at the most popular ones:

Pure Market Making (PMM)

The Pure Market Making (PMM) strategy is fundamental for Hummingbot. Its essence lies in simultaneously placing limit buy (bid) and sell (ask) orders around the current market price. The goal is to profit from the difference between buy and sell prices (the spread) by providing liquidity to the market. The bot constantly adjusts orders, following price movements, to keep them relevant.

How it works:

1. The bot places a buy order below the current market price and a sell order above the current market price.
2. When one of the orders is executed, the bot automatically places a new order on the opposite side of the spread.
3. If the market price changes significantly, the bot cancels old orders and places new ones to maintain the specified spread relative to the new mid-price.

PMM is the foundation for many traders aiming to earn a small but stable income from providing liquidity. It can also be the basis for a grid bot vps, as PMM inherently constantly places orders in a "grid" around the price.

Cross-Exchange Market Making

This strategy extends the PMM concept by applying it to two different exchanges. The goal is to exploit small price discrepancies between exchanges for profit. The bot places buy orders on one exchange and sell orders on another exchange for the same trading pair.

How it works:

1. The bot monitors prices on two exchanges (e.g., Binance and OKX) for the same trading pair (e.g., BTC-USDT).
2. If the price on one exchange is low enough to buy, and high enough on the other to sell, taking into account fees, the bot executes both trades.
3. This requires capital on both exchanges and very low latency, which makes a VPS critically important.

Cross-Exchange Market Making requires more complex setup and risk management but can yield higher returns under favorable market conditions.

Arbitrage

The arbitrage strategy focuses on instantly exploiting price discrepancies between different exchanges for the same trading pair. Unlike Cross-Exchange Market Making, where the bot places limit orders, an arbitrage bot typically executes market orders to lock in the difference as quickly as possible.

How it works:

1. The bot constantly scans prices on multiple exchanges.
2. As soon as a sufficiently large price difference is detected (exceeding fees), the bot simultaneously buys the asset on the low-price exchange and sells it on the high-price exchange.
3. This is a high-speed strategy that requires minimal latency and high execution reliability, making the choice of a powerful VPS with a fast internet connection (e.g., 1 Gbps) mandatory.

Arbitrage can be very profitable but comes with risks such as slippage, high fees, and competition from other arbitrage bots.

P&L Example: How much can you earn with Hummingbot on $5k capital?

Estimating the potential profit and loss (P&L) from running Hummingbot with $5,000 capital is a task that requires considering many variables. It's important to understand that these are only approximate calculations, and actual results can vary greatly depending on market conditions, the chosen strategy, trading pair, volatility, and liquidity.

Initial data for the example:

• Capital: $5,000 (assume 50% in stablecoins, 50% in a trading asset, e.g., $2,500 USDT and $2,500 in BTC).
• Exchange: Binance (average fees).
• Strategy: Pure Market Making (PMM).
• Trading pair: BTC-USDT (or another liquid pair).
• Spread: 0.1% - 0.2% from the mid-price.
• Order size: $25 - $50 (for active execution).
• Fees: 0.075% for maker, 0.075% for taker (when using BNB, otherwise 0.1%).
• Order execution: Assume 100-200 trades per day (50-100 buy/sell cycles).

Calculation of potential profit:

1. Profit from one cycle (buy + sell):
   • If the spread is 0.1% and your order is $50, then profit before fees from one cycle: $50 * 0.1% = $0.05.
   • Fees per cycle: $50 (buy) * 0.075% + $50 (sell) * 0.075% = $0.0375 + $0.0375 = $0.075.
   • Net profit per cycle: $0.05 (profit from spread) - $0.075 (fees) = -$0.025.

   This means that with a 0.1% spread and 0.075% fees, you will lose money.

2. Adjusting the spread for profitability:
   • To be profitable, your spread must cover the fees. In this case, the spread should be at least 2 * 0.075% = 0.15%.
   • Let's assume we set the spread to 0.2%.
   • Profit before fees from one cycle: $50 * 0.2% = $0.10.
   • Net profit per cycle: $0.10 (profit from spread) - $0.075 (fees) = $0.025.
3. Daily profit:
   • If the bot completes 150 cycles per day: 150 * $0.025 = $3.75.
4. Monthly profit:
   • $3.75 * 30 days = $112.5.
5. Annual profit:
   • $112.5 * 12 months = $1,350.

Important caveats and factors affecting P&L:

• Market volatility: The higher the volatility, the more opportunities for order execution and profit. In a calm market, the bot may sit idle.
• Liquidity: Highly liquid pairs ensure fast order execution and minimize slippage.
• Competition: On popular pairs, there are many other market makers, which reduces the available spread.
• Strategy settings: An aggressive spread (smaller) can increase volumes but reduce net profit per trade. A wide spread (larger) will increase profit per trade but decrease the number of trades.
• Exchange fees: Using exchange tokens (e.g., BNB on Binance) to reduce fees is critically important.
• Slippage: In conditions of high volatility, orders may be executed at a worse price than expected.
• Impermanent Loss: If you hold part of your capital in a volatile asset, its price may fall, which negates the profit from market making.
• VPS costs: Don't forget to deduct the cost of the VPS (e.g., $10-$20 per month) from your total profit.

With a capital of $5,000 and an optimized PMM strategy, a realistic monthly return can range from 1% to 5% of the capital, meaning $50 - $250. This is not a fixed figure, but merely a guideline that can fluctuate depending on all the factors mentioned above.

Optimization and security of Hummingbot operation on VPS

After installing and configuring Hummingbot on your VPS, it's important to focus on optimizing its operation and ensuring security. This guarantees stable profits and protection of your assets.

Optimization recommendations:

1. VPS resource monitoring:
   • Regularly check CPU load, RAM usage, and disk space. Use commands like htop, free -h, df -h.
   • If resources are nearing their limit, consider upgrading your VPS to a more powerful Valebyte plan.
2. Using Screen or Tmux:
   • Run Hummingbot inside a screen or tmux session. This will allow the bot to continue running even after your SSH session disconnects.
   • For screen: screen -S hummingbot_session, then run the Docker command. To detach: Ctrl+A, D. To reattach: screen -r hummingbot_session.
3. Automatic restart:
   • Configure the Docker container to automatically restart in case of failure using the --restart unless-stopped option when starting the container:

     docker run -it --name hummingbot_instance --restart unless-stopped ...

   • This will ensure continuous bot operation after a VPS reboot or unexpected errors.
4. Hummingbot updates:
   • Regularly update the Docker image to the latest version to receive bug fixes and new features.
   • Stop the container: docker stop hummingbot_instance
   • Remove the old container: docker rm hummingbot_instance
   • Download the new image: docker pull coinalpha/hummingbot:latest
   • Start the new container with the same parameters.
5. Log optimization:
   • Hummingbot generates many logs. Configure log rotation so they don't fill up the entire disk. By default, Docker handles this, but you can configure it more finely.

Security recommendations:

1. Firewall (UFW):
   • Configure Uncomplicated Firewall (UFW) on your VPS to allow access only to necessary ports (SSH, possibly Hummingbot's web interface port if you use it).
   • Example:

     sudo ufw allow ssh
     sudo ufw enable

2. SSH keys:
   • Use SSH keys instead of a password to connect to the VPS. This is much more secure. Disable password login after setting up keys.
   • You can read more about this in our server setup guides.
3. API key permissions:
   • On exchanges, grant API keys only the permissions necessary for trading (reading balance, placing/canceling orders). Never grant withdrawal rights.
4. Backup:
   • Regularly back up the hummingbot_files, hummingbot_logs, hummingbot_data folders. This will allow you to quickly restore your configuration and history in case of VPS issues.
   • Valebyte provides the ability to create VPS snapshots, which is also an excellent backup method.
5. OS updates:
   • Regularly update the VPS operating system to receive the latest security patches.
   • sudo apt update && sudo apt upgrade -y

Conclusion

Installing and configuring Hummingbot on an Ubuntu VPS from Valebyte is an effective way to automate your trading strategies, ensuring high stability, low latency, and security. Choosing a suitable VPS plan with sufficient resources (2-4 vCPU, 4-8 GB RAM, NVMe SSD) and following the step-by-step instructions for Docker installation and bot configuration will allow you to quickly start market making or arbitrage on exchanges like Binance. For maximum efficiency and protection of your assets, always pay attention to optimization and security measures, such as firewall configuration and regular system updates.