The Bitaxe Benchmark Tool: The Ultimate Guide from Beginner to Pro (2026)
- AxeForge Tech
- Feb 4
- 4 min read
Want more hashrate without guessing or risking your hardware? The Bitaxe Benchmark tool is a Python script that automatically tests voltage and frequency settings to find the most stable and efficient setup for your miner.
Whether you’re completely new or ready to optimize like a pro, this guide walks you through everything step-by-step in plain language.
What Is the Bitaxe Benchmark Tool?
The Bitaxe Hashrate Benchmark is a Python-based tool that helps you tune your miner safely. It tests different voltage and frequency settings while keeping track of:
✅ Hashrate performance✅ Temperature and power✅ Stability and efficiency (J/TH)
It then saves the results and applies the best stable configuration automatically — like autopilot for your Bitaxe.
👉 Find the Bitaxe Benchmark Tool in the Downloads section of the AxeForge Technologies website.
Who Should Use It?
With this guide, anyone — regardless of skill level — can use this powerful tool.
What You’ll Need
Python 3.11 or newer
Your Bitaxe miner on the same network
Optional: Docker for easier deployment
Optional: Git for downloading the script
Installation by Operating System
Good news: this script works on Windows, macOS, and Linux. After installation, you’ll also know where to find the folder and edit configuration settings.
🪟 Windows Setup
Install Python: https://www.python.org/downloads/
IMPORTANT: Check the box “Add Python to PATH”.
Open Command Prompt.
Clone the repository:
git clone https://github.com/mrv777/Bitaxe-Hashrate-Benchmark.git
cd Bitaxe-Hashrate-Benchmark
Create a virtual environment:
python -m venv venv
Activate it:
venv\Scripts\activate
Install dependencies:
pip install -r requirements.txt
Finding the Folder and Editing Configuration
After cloning, the folder will be here by default:
C:\Users\<YourUsername>\Bitaxe-Hashrate-Benchmark\
Inside, you’ll find the file:
bitaxe_hashrate_benchmark.py
This is where you can adjust benchmark settings like voltage, frequency, benchmark time, and temperature limits.
You’re ready to benchmark 👍
🍎 macOS Setup
Install Python (if needed):
brew install python
Clone the repo:
git clone https://github.com/mrv777/Bitaxe-Hashrate-Benchmark.git
cd Bitaxe-Hashrate-Benchmark
Create and activate a virtual environment:
python3 -m venv venv
source venv/bin/activate
Install requirements:
pip install -r requirements.txt
Finding the Folder and Editing Configuration
After cloning, the folder will be in your home directory:
~/Bitaxe-Hashrate-Benchmark/
Open bitaxe_hashrate_benchmark.py to edit any benchmark settings.
🐧 Linux Setup (Ubuntu/Debian Example)
sudo apt update
sudo apt install python3 python3-venv git -y
Clone and install:
git clone https://github.com/mrv777/Bitaxe-Hashrate-Benchmark.git
cd Bitaxe-Hashrate-Benchmark
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
The folder location will be:
~/Bitaxe-Hashrate-Benchmark/
Edit bitaxe_hashrate_benchmark.py here to change configuration settings.
🐳 Optional: Docker (Easiest for Advanced Users)
If you already use Docker, you can avoid installing Python and dependencies on your machine. Here’s how:
Open a terminal or command prompt.
Navigate to the Bitaxe benchmark folder:
cd <path_to_Bitaxe-Hashrate-Benchmark>
Build the Docker image:
docker build -t bitaxe-benchmark .
-t bitaxe-benchmark names the image so you can reference it easily.
Run the container, replacing <bitaxe_ip> with your miner’s IP:
docker run --rm bitaxe-benchmark <bitaxe_ip>
--rm removes the container automatically after the run.
Benefits of Docker:
No need to install Python or dependencies on your host system.
Keeps everything isolated in a container.
Easier cleanup — just delete the container and rebuild if needed.
Tip: You can also mount a folder for output files if you want JSON results accessible outside the container:
docker run --rm -v ~/bitaxe_results:/results bitaxe-benchmark <bitaxe_ip>
This will save the results to ~/bitaxe_results on your host machine.
How to Run the Benchmark
Basic command:
python bitaxe_hashrate_benchmark.py <bitaxe_ip>
Example run:
python bitaxe_hashrate_benchmark.py 192.168.2.29
Example Config (Safe Start)
python bitaxe_hashrate_benchmark.py 192.168.2.29 -v 1150 -f 500
1150mV voltage → safe and stable
500MHz frequency → good baseline
This lets the script scale upward safely.
Understanding the Configuration Options
Here’s a user-friendly explanation of what each configuration does and how it affects the benchmark:
# Configuration
voltage_increment = 20
frequency_increment = 25
sleep_time = 90
benchmark_time = 600
sample_interval = 15
max_temp = 66
max_allowed_voltage = 1400
max_allowed_frequency = 1200
max_vr_temp = 86
min_input_voltage = 4800
max_input_voltage = 5500
max_power = 40
⚡ voltage_increment
Step size for increasing voltage during tests.
Example: 20 mV means the script tests 1150 → 1170 → 1190 mV.
⚡ frequency_increment
Step size for increasing mining frequency.
Example: 25 MHz means 500 → 525 → 550 MHz.
⏱ sleep_time
Time to wait before starting the benchmark to let the miner stabilize.
Example: 90 seconds.
⏱ benchmark_time
How long each configuration is tested.
Example: 600 seconds = 10 minutes per setting.
⏱ sample_interval
How often the script logs hashrate, temperature, and power.
Example: every 15 seconds.
🌡 max_temp
Maximum chip temperature before stopping the benchmark.
Example: 66°C default for beginners.
🌡 max_allowed_voltage / max_allowed_frequency
Maximum voltage or frequency the script can apply.
Example: 1400 mV / 1200 MHz.
🌡 max_vr_temp
Maximum temperature for the voltage regulator.
Example: 86°C.
⚡ min_input_voltage / max_input_voltage
Ensures miner input power stays safe.
Example: 4800–5500 mV.
🔋 max_power
Maximum allowed power usage.
Example: 40 W to protect your DC plug.
💡 Beginner Tip: Start with default values and changes in small increments. All of these can be safely adjusted in bitaxe_hashrate_benchmark.py to fine-tune performance once you’re comfortable.
Changing Any Configuration Setting
All benchmark settings, including voltage, frequency, benchmark time, and temperature cutoffs, are in the file:
bitaxe_hashrate_benchmark.py
Open this file in a text editor and adjust the numbers as desired. Always start with small changes and monitor your miner closely.
How Long Should Each Benchmark Run?
Quick Run : 10–20 minutes per setting — fast baseline results.
Intermediate Run: 30–60 minutes per setting — catches slow heat buildup and power fluctuations.
Final Stability Test: 4–12 hours (overnight) — confirms long-term stability.
Extreme (Optional): 24+ hours — advanced users logging full data.
Short tests show performance. Long tests prove stability.
Understanding Your Results
Results are saved as:
bitaxe_benchmark_results_<ip>.json
Includes:
Top-performing configurations
Efficiency rankings
Average hashrate
Temperature data
Tested voltage/frequency combos
Save these results — they’re invaluable for future comparisons.
Beginner Tips for Better Results
⭐ Run your Bitaxe in the coolest ambient temps available in your location (i.e., apartment, home), usually found in your basement.⭐ Avoid aggressive overclocking on your first test⭐ Upgrade cooling before chasing higher hashrates⭐ Re-run benchmarks after firmware updates
Optimization is a process — repeat occasionally.
Why This Tool Is Worth Using
Instead of guessing, benchmarking helps you:
✅ Maximize hashrate✅ Improve efficiency✅ Reduce overheating risk✅ Find your miner’s unique sweet spot
One of the highest-impact upgrades you can make — and it’s free.
Final Thoughts
Run the Bitaxe Benchmark tool once, learn your miner, and enjoy smarter hashing. It removes guesswork and replaces it with real data — exactly how mining should be.
Happy mining ⚡
Comments