GitHub - NickScherbakov/robot: Autonomous earning robot powered by AI orchestration and privacy-first financial

Autonomous AI-powered system for income generation through intelligent task automation

Features • Quick Start • Demo • Documentation • Contributing

📋 Table of Contents

✨ Features
🚀 Quick Start
📱 Telegram Bot Usage
🌐 REST API
💰 Payment Configuration
📊 Financial Reporting
📸 Screenshots
🏗️ Architecture
🔧 Configuration
🚀 Deployment
🧪 Testing
🔒 Security
📚 Documentation
🤝 Contributing
📄 License
🌐 Live Demo Website

🌟 About

Earning Robot is an autonomous AI-powered earning system that operates through a laptop, phone, and internet connection. The robot accepts user requests, executes tasks using external AI APIs (OpenAI, Mistral), automatically handles payments via Stripe, and generates comprehensive financial reports.

✨ Features

🤖 AI Integration

Multiple AI Providers: OpenAI GPT and Mistral AI support
Smart Routing: Automatic provider selection based on task
Token Tracking: Real-time usage and cost monitoring
Response Caching: Optimize costs with intelligent caching
Model Optimizer: AI cost optimization like Google Vertex AI

🎯 SelfEarnBot - NEW!

Autonomous Earning: AI content arbitrage bot
Smart Opportunity Detection: Finds content opportunities
Auto Content Generation: Creates articles, code, SEO content
Auto Publishing: Submits to platforms automatically
Self-Learning: Improves from successes and failures
Auto Reinvestment: Grows budget automatically

💬 Control Interfaces

Telegram Bot: Full mobile control from anywhere
REST API: Programmatic access for integrations
CLI Tool: Command-line interface for advanced users
Owner Authentication: Secure access control

💰 Payment & Billing

Stripe Integration: Professional payment processing
Subscription Model: Recurring monthly payments
Micro-payments: Pay-per-operation pricing
Automated Invoicing: Professional invoice generation

📊 Analytics & Reporting

Daily Reports: Automated financial summaries
Weekly Analysis: Trend tracking and insights
Monthly Overview: Comprehensive profit/loss statements
Real-time Dashboard: Live task and revenue monitoring

🔒 Security & Privacy

Local Database: SQLite for complete data control
Environment Variables: Secure credential management
No Data Sharing: Everything stays on your infrastructure
Webhook Verification: Stripe signature validation

🚀 Deployment

Laptop Ready: Run directly on any laptop
Docker Support: Containerized deployment option
VPS Compatible: Easy cloud server deployment
Auto-scaling: Handle varying loads efficiently

🏗️ Architecture

graph TB
    subgraph "User Interface Layer"
        A[📱 Telegram Bot]
        B[🌐 REST API]
        C[💻 CLI Tool]
    end
    
    subgraph "Processing Layer"
        D[🤖 AI Manager]
        E[💳 Payment Processor]
        F[📊 Report Generator]
        G[⏰ Task Scheduler]
    end
    
    subgraph "External Services"
        H[🧠 OpenAI / Mistral]
        I[💰 Stripe]
    end
    
    subgraph "Data Layer"
        J[(🗄️ SQLite Database)]
    end
    
    A --> D
    B --> D
    C --> D
    
    D --> H
    D --> J
    E --> I
    E --> J
    F --> J
    G --> D
    G --> F
    
    style A fill:#667eea,stroke:#764ba2,color:#fff
    style B fill:#667eea,stroke:#764ba2,color:#fff
    style C fill:#667eea,stroke:#764ba2,color:#fff
    style D fill:#764ba2,stroke:#667eea,color:#fff
    style E fill:#764ba2,stroke:#667eea,color:#fff
    style F fill:#764ba2,stroke:#667eea,color:#fff
    style G fill:#764ba2,stroke:#667eea,color:#fff
    style H fill:#4CAF50,stroke:#2e7d32,color:#fff
    style I fill:#4CAF50,stroke:#2e7d32,color:#fff
    style J fill:#2196F3,stroke:#1565c0,color:#fff

Project Structure

robot/
├── backend/              # Core backend logic
│   ├── app.py           # Flask REST API server
│   ├── config.py        # Configuration management
│   ├── database.py      # Database models and ORM
│   ├── ai_providers.py  # AI API integrations
│   ├── scheduler.py     # Automated task scheduler
│   ├── model_optimizer.py      # 🆕 AI cost optimization engine
│   ├── optimizer_api.py        # 🆕 Optimizer REST API
│   └── optimizer_middleware.py # 🆕 Auto-tracking middleware
├── frontend/            # User interfaces
│   └── telegram_bot.py  # Telegram bot interface
├── billing/             # Payment and financial logic
│   ├── payment_processor.py  # Stripe payment integration
│   └── reporting.py     # Financial report generation
├── selfbot/             # 🆕 SelfEarnBot - Autonomous AI Content Arbitrage
│   ├── scanner/         # Opportunity detection
│   ├── generator/       # AI content generation
│   ├── publisher/       # Content publishing
│   ├── brain/           # Decision engine
│   ├── finance/         # Financial management
│   ├── evolution/       # Self-learning & optimization
│   ├── database/        # SelfBot data models
│   └── main.py          # SelfBot main loop
├── docs/                # Documentation
├── tests/               # Test files
├── .env.example         # Example environment variables
├── .gitignore          # Git ignore rules
├── requirements.txt     # Python dependencies
├── main.py             # Main entry point
└── README.md           # This file

🚀 Quick Start

Prerequisites

🐍
Python 3.8+

💬
Telegram Account

💳
Stripe Account

🤖
AI API Keys

Installation

1. Clone the repository

git clone https://github.com/NickScherbakov/robot.git
cd robot

2. Install dependencies

pip install -r requirements.txt

3. Configure environment variables

cp .env.example .env
# Edit .env with your API keys and credentials

4. Set up your Telegram bot

Talk to @BotFather on Telegram
Create a new bot and get your bot token
Add the token to .env as TELEGRAM_BOT_TOKEN
Get your Telegram user ID (use @userinfobot)
Add your user ID to .env as TELEGRAM_OWNER_ID

5. Configure API keys

Service	Link	Environment Variable
OpenAI	platform.openai.com	`OPENAI_API_KEY`
Mistral AI	mistral.ai	`MISTRAL_API_KEY`
Stripe	dashboard.stripe.com	`STRIPE_SECRET_KEY`

Running the Robot

All components together:

python main.py

Or run components separately:

# Run Flask API server
python backend/app.py

# Run Telegram bot (in another terminal)
python frontend/telegram_bot.py

# Run scheduler (in another terminal)
python backend/scheduler.py

💡 Tip: Use tmux or screen for running multiple components in the background on a VPS.

📸 Screenshots

💬 Telegram Bot Interface

_{Chat Interface}

_{Financial Reports}

_{Settings & Configuration}

🌐 Web Dashboard

_{Real-time Analytics Dashboard}

📷 Note: Screenshots shown are placeholders. See the live demo website for interactive examples.

📱 Telegram Bot Usage

Once the bot is running, you can control it via Telegram:

Available Commands

Command	Description	Access Level
`/start`	Initialize the bot and show welcome message	👤 User
`/help`	Display help information and command list	👤 User
`/ask <question>`	Ask AI a question and get response	👤 User
`/status`	Check robot operational status	👤 User
`/selfbot`	SelfEarnBot control and help	👑 Owner
`/selfbot_status`	Check SelfBot status and earnings	👑 Owner
`/selfbot_stats`	Get SelfBot performance statistics	👑 Owner
`/selfbot_report`	Get detailed SelfBot report	👑 Owner
`/report [daily\|weekly\|monthly]`	Get financial report (default: daily)	👑 Owner
`/settings`	Configure robot settings	👑 Owner

Usage Examples

💬 User: /ask What is the capital of France?
🤖 Robot: The capital of France is Paris, a beautiful city known for its art, culture, and history.

💬 User: /ask Explain quantum computing in simple terms
🤖 Robot: Quantum computing is a type of computation that harnesses quantum mechanics...

💬 User: /status
🤖 Robot: ✅ All systems operational
         📊 Tasks today: 42
         💰 Revenue: $21.00
         📉 Expenses: $0.84
         💵 Profit: $20.16

💬 Owner: /report daily
🤖 Robot: 📊 Daily Financial Report
         [Detailed report follows...]

💡 Pro Tip: You can send regular messages without commands - they will be treated as AI questions automatically!

🤖 SelfEarnBot - Autonomous AI Content Arbitrage

Overview

SelfEarnBot is an autonomous AI-powered content arbitrage bot that operates 24/7 to find opportunities, generate content, and earn money automatically.

How It Works

┌─────────────────────────────────────────────┐
│  1. SCAN → 2. EVALUATE → 3. GENERATE       │
│  ↓                                           │
│  7. REINVEST ← 6. LEARN ← 5. TRACK ← 4. PUBLISH │
└─────────────────────────────────────────────┘

Scan: Finds content opportunities from RSS feeds, freelance platforms, content marketplaces
Evaluate: AI "brain" scores opportunities by profitability and feasibility
Generate: Creates content using AI (articles, code, SEO) for $0.01-$0.20
Publish: Submits to platforms (Medium, Dev.to, freelance sites)
Track: Records revenue, costs, ROI
Learn: Improves from successes and failures
Reinvest: Auto-reinvests profits to grow the operation

Economics

Content Type	Revenue	AI Cost	Margin
Article	$5-$50	$0.01-$0.10	~95%
Code	$10-$100	$0.02-$0.20	~95%
SEO Content	$3-$30	$0.01-$0.08	~95%

Quick Start

# Configure in .env
SELFBOT_INITIAL_BUDGET=10.00
SELFBOT_AUTO_REINVEST=true
SELFBOT_REINVEST_PERCENTAGE=50

# Run SelfBot
python selfbot/main.py

# Or control via Telegram
/selfbot_status
/selfbot_stats
/selfbot_report

Features

✅ Fully Autonomous: Operates without human intervention
🧠 Smart Decision Making: AI-powered opportunity scoring
💰 Auto Reinvestment: Grows budget automatically
📊 Self-Learning: Improves strategies from experience
📈 High ROI: 95%+ profit margins
🔒 Safe Demo Mode: Test without real publishing

Results (Expected)

Week 1 (Conservative):

Initial budget: $10
Operations/day: ~10
Avg profit/op: $5
Week profit: ~$350

Month 1 (With reinvestment):

Budget grows to: ~$200
Operations/day: ~50
Month profit: ~$7,500

Results depend on market conditions and configuration

Documentation

📚 Full documentation: selfbot/README.md

💡 Pro Tip: You can send regular messages without commands - they will be treated as AI questions automatically!

🌐 REST API

The Flask server provides a comprehensive REST API on http://localhost:5000

API Endpoints

📊 Health & Status

Health Check

GET /health

Response:

{
  "status": "healthy",
  "uptime": "2 days, 3 hours"
}

Get Statistics

GET /api/stats

Response:

{
  "tasks_today": 42,
  "tasks_total": 1337,
  "revenue": 21.00,
  "expenses": 0.84,
  "profit": 20.16
}

🤖 AI Task Management

Execute AI Task

POST /api/task
Content-Type: application/json

Request:

{
  "prompt": "Your question here",
  "provider": "openai",
  "user_id": "user@example.com"
}

Response:

{
  "task_id": "task_abc123",
  "response": "AI generated response...",
  "tokens_used": 150,
  "cost": 0.002,
  "provider": "openai"
}

Get Task Status

GET /api/task/{task_id}

List Tasks

GET /api/tasks?status=completed&limit=10

💰 Payment Management

Create Subscription

POST /api/payment/subscription
Content-Type: application/json

Request:

{
  "email": "customer@example.com",
  "plan": "monthly"
}

Response:

{
  "checkout_url": "https://checkout.stripe.com/...",
  "subscription_id": "sub_abc123"
}

📊 Financial Reports

Get Financial Report

GET /api/report/{period}

Periods: daily, weekly, monthly

Response:

{
  "period": "daily",
  "date": "2024-12-17",
  "revenue": 21.00,
  "expenses": 0.84,
  "profit": 20.16,
  "tasks": 42,
  "breakdown": {
    "subscriptions": 15.00,
    "micro_payments": 6.00,
    "api_costs": 0.84
  }
}

Usage Examples

🐚 cURL Examples

# Ask AI a question
curl -X POST http://localhost:5000/api/task \
  -H "Content-Type: application/json" \
  -d '{"prompt": "What is AI?", "provider": "openai"}'

# Get daily report
curl http://localhost:5000/api/report/daily

# Check statistics
curl http://localhost:5000/api/stats

🐍 Python Examples

import requests

# Execute AI task
response = requests.post('http://localhost:5000/api/task', json={
    'prompt': 'Explain machine learning',
    'provider': 'openai'
})
result = response.json()
print(result['response'])

# Get report
report = requests.get('http://localhost:5000/api/report/daily').json()
print(f"Profit: ${report['profit']:.2f}")

# Subscribe a customer
subscription = requests.post('http://localhost:5000/api/payment/subscription', json={
    'email': 'customer@example.com'
})
print(f"Checkout URL: {subscription.json()['checkout_url']}")

📜 JavaScript Examples

// Execute AI task
const response = await fetch('http://localhost:5000/api/task', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    prompt: 'What is blockchain?',
    provider: 'mistral'
  })
});
const result = await response.json();
console.log(result.response);

// Get statistics
const stats = await fetch('http://localhost:5000/api/stats').then(r => r.json());
console.log(`Tasks today: ${stats.tasks_today}`);

💰 Payment Configuration

Payment Models

🔄 Monthly Subscription	💵 Micro-payments
Recurring monthly billing Unlimited tasks included Default: $29.99/month Configured via `SUBSCRIPTION_MONTHLY_PRICE` Automatic renewal Managed through Stripe	Pay per task/operation No commitment required Default: $0.50/operation Configured via `MICRO_PAYMENT_PRICE` Instant charging Ideal for occasional users

Stripe Setup Guide

Step 1: Create Stripe Account

Sign up at stripe.com
Complete account verification
Navigate to Dashboard → Developers

Step 2: Get API Keys

# Add to .env file
STRIPE_SECRET_KEY=sk_test_... # or sk_live_...
STRIPE_PUBLISHABLE_KEY=pk_test_... # or pk_live_...

Step 3: Configure Webhooks (for production)

Go to Dashboard → Developers → Webhooks
Add endpoint: https://yourdomain.com/api/webhook/stripe
Select events:
- ✅ checkout.session.completed
- ✅ invoice.paid
- ✅ invoice.payment_failed
- ✅ customer.subscription.deleted
Copy webhook signing secret:
```
STRIPE_WEBHOOK_SECRET=whsec_...
```

Pricing Configuration

Edit your .env file:

# Monthly subscription price in USD
SUBSCRIPTION_MONTHLY_PRICE=29.99

# Per-operation price in USD
MICRO_PAYMENT_PRICE=0.50

# Stripe API keys
STRIPE_SECRET_KEY=your_secret_key
STRIPE_PUBLISHABLE_KEY=your_publishable_key
STRIPE_WEBHOOK_SECRET=your_webhook_secret

📊 Financial Reporting

Automated Reports

The robot automatically generates and sends comprehensive financial reports via Telegram:

Report Type	Schedule	Contents
📅 Daily Report	Every day at 09:00 UTC (configurable)	• Total income & expenses • Net profit/loss • Task count & completion rate • Top performing hours • Cost per task breakdown
📆 Weekly Report	Every Monday at 09:00 UTC	• 7-day summary • Week-over-week comparison • Trend analysis • Revenue growth percentage • Average daily profit
📊 Monthly Report	On-demand via `/report monthly`	• Complete month overview • Category-wise breakdown • Profitability metrics • Customer analytics • Expense optimization suggestions

Report Example

📊 Daily Financial Report - Dec 17, 2025
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📈 REVENUE
├─ Subscriptions:      $15.00 (3 active)
├─ Micro-payments:      $6.00 (12 tasks)
└─ Total Revenue:      $21.00

📉 EXPENSES
├─ OpenAI API:          $0.52 (26 tasks)
├─ Mistral API:         $0.32 (16 tasks)
└─ Total Expenses:      $0.84

💰 NET PROFIT:         $20.16
📊 Profit Margin:      96.0%

🎯 PERFORMANCE
├─ Tasks Completed:     42
├─ Success Rate:       100%
├─ Avg Response Time:   2.3s
└─ Customer Satisfaction: ⭐⭐⭐⭐⭐

📌 TOP INSIGHTS
• Peak hour: 14:00-15:00 (8 tasks)
• Most used provider: OpenAI (62%)
• Average revenue per task: $0.50

Manual Report Commands

Request reports anytime via Telegram:

/report daily    # Get today's report
/report weekly   # Get this week's report
/report monthly  # Get this month's report

Export Options

Reports can be exported in multiple formats:

📱 Telegram Message (default)
📧 Email (configure SMTP settings)
📄 PDF (generated on-demand)
📊 CSV (for spreadsheet analysis)
🔗 Google Sheets (auto-sync option)

🔧 Configuration

All configuration is managed through environment variables in .env:

Required Settings

# Telegram Bot (REQUIRED)
TELEGRAM_BOT_TOKEN=1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
TELEGRAM_OWNER_ID=123456789

AI Provider Settings

# OpenAI (Optional but recommended)
OPENAI_API_KEY=sk-...
OPENAI_MODEL=gpt-4o-mini  # or gpt-4o

# Mistral AI (Optional)
MISTRAL_API_KEY=...
MISTRAL_MODEL=mistral-small  # or mistral-medium

Payment Gateway

# Stripe (Optional - required for payments)
STRIPE_SECRET_KEY=sk_test_...
STRIPE_PUBLISHABLE_KEY=pk_test_...
STRIPE_WEBHOOK_SECRET=whsec_...

Application Settings

# Database
DATABASE_PATH=data/robot.db

# Security
SECRET_KEY=your-random-secret-key-here

# Pricing
SUBSCRIPTION_MONTHLY_PRICE=29.99
MICRO_PAYMENT_PRICE=0.50

# Reporting
REPORT_TIME=09:00
TIMEZONE=UTC

# Server
HOST=0.0.0.0
PORT=5000
DEBUG=False

Advanced Options

# Rate Limiting
MAX_REQUESTS_PER_HOUR=100
MAX_TOKENS_PER_REQUEST=2000

# Caching
ENABLE_CACHE=True
CACHE_TTL=3600

# Logging
LOG_LEVEL=INFO
LOG_FILE=logs/robot.log

# Email Notifications (Optional)
SMTP_HOST=smtp.gmail.com
SMTP_PORT=587
SMTP_USER=your-email@gmail.com
SMTP_PASSWORD=your-app-password
NOTIFICATION_EMAIL=owner@example.com

📈 Monitoring & Logs

System Status

Check system status:

Via Telegram: /status
Via API: GET /api/stats

Health Checks

The scheduler automatically checks system health every hour and sends alerts if:

More than 5 tasks fail within an hour
System resources are low
API errors increase

Logging

All components log to console. To save logs to file:

python main.py >> logs/robot.log 2>&1

🧪 Testing

Running Tests

# Run all tests
pytest tests/

# Run with coverage
pytest --cov=backend --cov=frontend --cov=billing tests/

# Run specific test file
pytest tests/test_ai_providers.py

# Run with verbose output
pytest -v tests/

Test Structure

tests/
├── test_ai_providers.py      # AI integration tests
├── test_payment_processor.py # Payment system tests
├── test_telegram_bot.py      # Bot functionality tests
├── test_api.py               # REST API tests
└── test_reporting.py         # Report generation tests

Writing Tests

import pytest
from backend.ai_providers import OpenAIProvider

def test_ai_provider():
    provider = OpenAIProvider()
    response = provider.generate_response("Hello")
    assert response['response'] is not None
    assert response['tokens_used'] > 0

🔒 Security

Security Features

Feature	Implementation	Status
🔐 API Key Protection	Environment variables, never in code	✅ Implemented
👤 Owner Authentication	Telegram ID verification	✅ Implemented
🔏 Webhook Verification	Stripe signature validation	✅ Implemented
💉 SQL Injection Protection	SQLAlchemy ORM	✅ Implemented
🔄 Rate Limiting	Per-user request throttling	✅ Implemented
📝 Audit Logging	All operations logged	✅ Implemented

Security Best Practices

✅ DO:

Store .env file securely, never commit it
Use strong SECRET_KEY (generate with python -c "import secrets; print(secrets.token_hex(32))")
Enable HTTPS in production
Regularly rotate API keys
Monitor logs for suspicious activity
Use Stripe's test mode for development
Keep dependencies updated (pip install --upgrade -r requirements.txt)

❌ DON'T:

Commit .env or any credentials to git
Use the same API keys for dev and production
Expose admin endpoints without authentication
Ignore security warnings from dependencies
Run as root user in production

Vulnerability Reporting

Found a security issue? Please report it privately to:

📧 Email: security@example.com
🔒 GitHub Security Advisory: Create Advisory

Do not create public issues for security vulnerabilities.

🚀 Deployment

💻 Local Deployment (Laptop/Desktop)

Simple one-command start:

python main.py

The robot will run on your laptop. Keep the terminal open or use a process manager.

Run in background (Linux/Mac):

nohup python main.py > logs/robot.log 2>&1 &

Using screen/tmux:

# Using screen
screen -S earning-robot
python main.py
# Press Ctrl+A, D to detach

# Using tmux
tmux new -s earning-robot
python main.py
# Press Ctrl+B, D to detach

🐳 Docker Deployment

Build and run with Docker:

# Build the image
docker build -t earning-robot .

# Run the container
docker run -d \
  --name earning-robot \
  --env-file .env \
  -p 5000:5000 \
  -v $(pwd)/data:/app/data \
  earning-robot

Using Docker Compose:

docker-compose up -d

☁️ Cloud Deployment

Heroku

# Create Procfile
echo "web: python main.py" > Procfile

# Deploy
heroku create your-robot-name
heroku config:set TELEGRAM_BOT_TOKEN=your_token
heroku config:set TELEGRAM_OWNER_ID=your_id
heroku config:set OPENAI_API_KEY=your_key
# ... set other config vars
git push heroku main

VPS (Ubuntu/Debian)

# Install Python 3.8+
sudo apt update
sudo apt install python3 python3-pip git

# Clone and setup
git clone https://github.com/NickScherbakov/robot.git
cd robot
pip3 install -r requirements.txt

# Configure environment
cp .env.example .env
nano .env  # Edit with your credentials

# Run as systemd service (see below)

AWS EC2

Launch EC2 instance (Ubuntu 22.04 LTS)
Configure security group (allow port 5000)
SSH into instance
Follow VPS deployment steps above
Configure Elastic IP for static address
Set up CloudWatch for monitoring

Google Cloud Run

# Build and deploy
gcloud builds submit --tag gcr.io/PROJECT_ID/earning-robot
gcloud run deploy earning-robot \
  --image gcr.io/PROJECT_ID/earning-robot \
  --platform managed \
  --region us-central1 \
  --allow-unauthenticated

🔄 Running as a System Service (Linux)

Create /etc/systemd/system/earning-robot.service:

[Unit]
Description=Earning Robot - Autonomous AI Income System
After=network.target

[Service]
Type=simple
User=youruser
WorkingDirectory=/home/youruser/robot
Environment="PATH=/home/youruser/.local/bin:/usr/bin"
ExecStart=/usr/bin/python3 /home/youruser/robot/main.py
Restart=always
RestartSec=10
StandardOutput=append:/home/youruser/robot/logs/robot.log
StandardError=append:/home/youruser/robot/logs/error.log

[Install]
WantedBy=multi-user.target

Enable and start the service:

# Reload systemd
sudo systemctl daemon-reload

# Enable on boot
sudo systemctl enable earning-robot

# Start the service
sudo systemctl start earning-robot

# Check status
sudo systemctl status earning-robot

# View logs
sudo journalctl -u earning-robot -f

📊 Monitoring & Health Checks

Setup monitoring:

# Install monitoring tools
pip install prometheus-client

# Health check endpoint
curl http://localhost:5000/health

# Monitor with cron
crontab -e
# Add: */5 * * * * curl -f http://localhost:5000/health || systemctl restart earning-robot

📚 Documentation

Available Documentation

Document	Description	Link
📖 API Documentation	Complete REST API reference	API_DOCUMENTATION.md
🔧 Installation Guide	Detailed setup instructions	INSTALLATION.md
🐳 Docker Guide	Containerization and deployment	DOCKER.md
💡 Examples	Code examples and use cases	EXAMPLES.md
❓ FAQ	Frequently asked questions	FAQ.md
🏗️ Architecture	System design and structure	ARCHITECTURE.md
🚀 Quick Start	Get started in 5 minutes	QUICKSTART.md

Additional Resources

📺 Video Tutorials (coming soon)
💬 Community Discord (coming soon)
📝 Blog Posts (coming soon)

🤝 Contributing

We love contributions! The Earning Robot is open source and welcomes improvements from the community.

How to Contribute

Bug Reports
_{Found a bug?
Let us know!}
Report Bug

Feature Requests
_{Have an idea?
Share it!}
Request Feature

Documentation
_{Improve docs
Help others!}
Contribute Docs

Code
_{Submit PRs
Build features!}
Contribute Code

Quick Contribution Guide

Fork the repository

# Click the Fork button on GitHub, then:
git clone https://github.com/YOUR_USERNAME/robot.git
cd robot

Create a feature branch
```
git checkout -b feature/amazing-feature
```
Make your changes
```
# Edit files, add tests
pytest tests/
```

Commit your changes

git add .
git commit -m "Add amazing feature"

Push and create PR

git push origin feature/amazing-feature
# Then open a Pull Request on GitHub

Development Setup

# Install development dependencies
pip install -r requirements-dev.txt

# Install pre-commit hooks
pre-commit install

# Run linters
black .
flake8 .
mypy backend/ frontend/ billing/

# Run tests
pytest --cov

Contribution Guidelines

📝 Follow PEP 8 style guide for Python code
✅ Write tests for new features
📖 Update documentation for changes
🔒 Never commit sensitive data or API keys
💬 Use clear, descriptive commit messages
🎯 Keep PRs focused on a single feature/fix

Contributors

Made with contrib.rocks

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

TL;DR: You can use, modify, and distribute this software freely, even for commercial purposes.

🌐 Live Demo Website

Visit our interactive demonstration website to learn more about the Earning Robot:

🚀 https://nickscherbakov.github.io/robot/

🎯
Interactive Demo
_{Try the bot simulation}

📊
Live Analytics
_{See real-time metrics}

🏗️
Architecture
_{Visual system design}

📚
Documentation
_{Complete guides}

The website features:

✨ Modern, responsive design with dark mode support
🎮 Interactive demo panel with simulated AI interactions
📊 Real-time financial flow visualization
🚀 Quick start guides and comprehensive documentation
📱 Mobile-optimized interface

🎯 Roadmap

See our development roadmap

Version 2.0 (Planned)

Add support for Claude AI and Google Gemini
Web-based dashboard UI with React
Multi-user support with role-based access
Advanced analytics and business intelligence
Webhook support for external integrations
Plugin system for custom extensions

Version 2.5 (Future)

Multi-language support (i18n)
Mobile apps (iOS/Android)
Voice interface integration
Advanced ML-based cost optimization
Marketplace for custom plugins
White-label solution for businesses

Version 3.0 (Vision)

Distributed deployment across multiple regions
Auto-scaling based on demand
Advanced fraud detection
Blockchain-based transaction logging
AI-powered financial forecasting
Enterprise features (SSO, audit logs, compliance)

Want to contribute to the roadmap? Open a feature request!

💬 Community & Support

Get Help & Stay Connected

Issues

Discussions

Pull Requests

Support Options

🐛 Bug Reports: Create an issue
💡 Feature Requests: Suggest a feature
💬 Questions: Start a discussion
📧 Email: contact@earningrobot.com
🌐 Website: nickscherbakov.github.io/robot

🙏 Acknowledgments

OpenAI for GPT API
Mistral AI for Mistral API
Stripe for payment processing
Python Telegram Bot for Telegram integration
Flask for web framework
All our amazing contributors!

⭐ Star History

Built with ❤️ for Autonomous Earning

If you found this project helpful, please consider:

Share the project:

Made with 🤖 and ☕

Name		Name	Last commit message	Last commit date
Latest commit History 31 Commits
.github		.github
backend		backend
billing		billing
docs		docs
examples		examples
frontend		frontend
selfbot		selfbot
tests		tests
website		website
.env.example		.env.example
.gitignore		.gitignore
ARCHITECTURE.md		ARCHITECTURE.md
CHANGELOG.md		CHANGELOG.md
COMPLETION_REPORT.md		COMPLETION_REPORT.md
CONTRIBUTING.md		CONTRIBUTING.md
Dockerfile		Dockerfile
GETTING_STARTED_NEW_DOCS.md		GETTING_STARTED_NEW_DOCS.md
LICENSE		LICENSE
MODEL_OPTIMIZER_REPORT.md		MODEL_OPTIMIZER_REPORT.md
MODEL_OPTIMIZER_SUMMARY.md		MODEL_OPTIMIZER_SUMMARY.md
OPTIMIZER_QUICKSTART.md		OPTIMIZER_QUICKSTART.md
PROJECT_SUMMARY.txt		PROJECT_SUMMARY.txt
QUICKSTART.md		QUICKSTART.md
QUICK_START.md		QUICK_START.md
README.md		README.md
ROADMAP.md		ROADMAP.md
cli.py		cli.py
docker-compose.yml		docker-compose.yml
main.py		main.py
requirements.txt		requirements.txt
start.bat		start.bat
start.sh		start.sh

Folders and files

Latest commit

History

Repository files navigation

📋 Table of Contents

🌟 About

✨ Features

🤖 AI Integration

🎯 SelfEarnBot - NEW!

💬 Control Interfaces

💰 Payment & Billing

📊 Analytics & Reporting

🔒 Security & Privacy

🚀 Deployment

🏗️ Architecture

Project Structure

🚀 Quick Start

Prerequisites

Installation

Running the Robot

📸 Screenshots

💬 Telegram Bot Interface

🌐 Web Dashboard

📱 Telegram Bot Usage

Available Commands

Usage Examples

🤖 SelfEarnBot - Autonomous AI Content Arbitrage

Overview

How It Works

Economics

Quick Start

Features

Results (Expected)

Documentation

🌐 REST API

API Endpoints

Health Check

Get Statistics

Execute AI Task

Get Task Status

List Tasks

Create Subscription

Get Financial Report

Usage Examples

💰 Payment Configuration

Payment Models

Stripe Setup Guide

Pricing Configuration

📊 Financial Reporting

Automated Reports

Report Example

Manual Report Commands

Export Options

🔧 Configuration

Required Settings

AI Provider Settings

Payment Gateway

Application Settings

Advanced Options

📈 Monitoring & Logs

System Status

Health Checks

Logging

🧪 Testing

Running Tests

Test Structure

Writing Tests

🔒 Security

Security Features

Security Best Practices

Vulnerability Reporting

🚀 Deployment

💻 Local Deployment (Laptop/Desktop)

🐳 Docker Deployment

☁️ Cloud Deployment

🔄 Running as a System Service (Linux)

📊 Monitoring & Health Checks

📚 Documentation

Available Documentation

Additional Resources

Packages