I built a free crypto arbitrage detector with intelligent scoring - here's the tech stack

Building Detectick: Free Crypto Arbitrage Detection

I just launched Detectick, a free platform that detects crypto arbitrage opportunities and scores them 0-100 based on
profitability and risk.

The Problem

Crypto traders manually check multiple exchanges for price differences (arbitrage). Premium tools exist but cost $50-100/month

and most just show raw data without context.

The Solution: Intelligent Scoring

Instead of just showing "BTC is 2% cheaper on Exchange A", Detectick calculates:

• Trading fees (both exchanges)
• Network transfer fees (blockchain costs)
• Transfer speed (SOL = 5min, BTC = 30min)
• Liquidity (can you execute this trade?)

Result: 0-100 score showing real profitability.

Tech Stack

Frontend

• React 18 - Fast, component-based UI
• Tailwind CSS - Rapid styling without custom CSS
• Recharts - Beautiful charts for opportunities
• i18next - Multi-language support (5 languages)
• Cloudflare Pages - Free hosting, global CDN

Backend

• Flask (Python) - Lightweight API framework
• PostgreSQL - Robust relational database
• CCXT - Unified API for 8+ crypto exchanges
• Fernet encryption - AES-128 for API key security
• Gunicorn - Production WSGI server
• Render.com - Free tier hosting

Integrations

• 8+ Exchanges - Binance, Coinbase, Kraken, Bitvavo, OKX, KuCoin, Bitstamp, Bitfinex
• Telegram Bot - Instant notifications
• SendGrid - Email notifications
• Sentry - Error monitoring
• Plausible - Privacy-friendly analytics

Architecture

Frontend (React)
↓ HTTPS
Backend API (Flask)
↓ CCXT
Exchange APIs (Binance, Coinbase, etc.)

Key Technical Challenges

1. Exchange API Differences
Each exchange has different rate limits, authentication, and quirks. CCXT unified them but still needed custom handling for:

• OKX region detection
• Coinbase platform variants (Advanced vs Pro)
• Private key formatting

2. API Key Security
User API keys are encrypted at rest using Fernet (AES-128):

python
  from cryptography.fernet import Fernet

  encrypted = Fernet(key).encrypt(api_secret)
  # Store encrypted, decrypt only when needed

  **_3. Scoring Algorithm_**

  Balancing multiple factors into one score:
  score = (
      spread_size * 0.4 +
      liquidity * 0.25 +
      transfer_speed * 0.15 +
      fee_impact * 0.10 +
      historical_success * 0.10
  )

  **_4. Multi-Language Support_**

  Supporting 5 languages (EN, FR, DE, ES, NL) required:
  - i18next for React
  - Separate JSON files per language
  - ~800 translation keys
  - Language switcher persisting to localStorage

  What's Next

  - Automated trade execution (premium tier)
  - Historical analytics
  - API access for developers
  - Mobile app (PWA first)

  Try It

  🔗 Live: https://detectick.com
  📊 Status: https://status.detectick.com
  🚀 Launching on Product Hunt tomorrow!

  Currently 100% free. Would love feedback from the community!

  Questions I'd Love Answers To

  1. Is the scoring useful or should I just show raw spreads?
  2. What features would you pay for?
  3. Any security concerns with the approach?
  4. What other exchanges should I prioritize?

  Thanks for reading! Open to questions about the architecture or crypto arbitrage in general.