Quick Start Guide

Get up and running with PoIPoE in under 5 minutes. This guide walks you through account setup, wallet integration, and deploying your first MEV trading bot.

5 minutes Beginner No funds required
1

Create Your Account

Start by creating your PoIPoE account to access the platform and generate API credentials.

Account Requirements

  • Valid email address
  • Strong password (8+ characters, mixed case, numbers, symbols)
  • Acceptable use policy agreement
  • Minimum age of 18
Security Best Practice: Use a unique, strong password and enable two-factor authentication for enhanced security.
2

Get Your API Key

After account creation, generate your API key from the dashboard. This key will be used to authenticate your requests to the PoIPoE API.

API Keys Dashboard Screenshot

Navigate to Settings > API Keys to generate your key
Environment Variable Setup
# Add to your .env file
POIPOE_API_KEY=pk_live_your_api_key_here
POIPOE_ENVIRONMENT=production

# Or export in your shell
export POIPOE_API_KEY=pk_live_your_api_key_here
export POIPOE_ENVIRONMENT=production
Important: Never share your API key or commit it to version control. Use environment variables or secure key management services.
3

Connect Your Wallet

Connect your Web3 wallet to enable automated trading and fund management. PoIPoE supports MetaMask, WalletConnect, and hardware wallets.

MetaMask

Most popular Web3 wallet

WalletConnect

Connect mobile wallets

Hardware Wallet

Maximum security

Supported Networks

Ethereum Mainnet Recommended
Polygon Low Fees
Arbitrum High Speed
Optimism Ethereum L2
4

Install the SDK

Install the official PoIPoE JavaScript SDK to integrate MEV trading into your application.

NPM

npm install @poipoe/sdk

Yarn

yarn add @poipoe/sdk

CDN

Latest Version: 2.1.0 | Node.js: 14+ | Browser: ES2020+

5

Test Connection

Verify that your setup is working correctly by testing the API connection and getting platform status.

Test Connection (JavaScript)
import { PoIPoE } from '@poipoe/sdk';

// Initialize client
const poipoe = new PoIPoE({
    apiKey: process.env.POIPOE_API_KEY,
    environment: 'production' // or 'sandbox' for testing
});

// Test connection
async function testConnection() {
    try {
        const status = await poipoe.getStatus();
        console.log('Platform Status:', status);
        
        if (status.status === 'operational') {
            console.log('✅ Connection successful!');
            return true;
        }
    } catch (error) {
        console.error('❌ Connection failed:', error.message);
        return false;
    }
}

// Run test
testConnection();

Expected Output

{
    "status": "operational",
    "uptime": 99.99,
    "active_bots": 3247,
    "total_volume_24h": 25000000,
    "supported_networks": ["ethereum", "polygon", "arbitrum"],
    "supported_strategies": ["arbitrage", "liquidation", "crosschain"]
}
6

Configure Your First Strategy

Create your first trading strategy. We'll start with a simple arbitrage strategy to minimize risk while learning.

Arbitrage Strategy Configuration

// Strategy configuration
const arbitrageStrategy = {
    type: 'arbitrage',
    name: 'My First Bot',
    description: 'Simple ETH/USDC arbitrage across major DEXs',
    
    // Trading pairs to monitor
    pairs: [
        'ETH/USDC',
        'ETH/USDT',
        'WETH/DAI'
    ],
    
    // Exchange targets (optional, leave empty for all)
    exchanges: [
        'uniswap-v3',
        'sushiswap',
        'curve',
        'balancer'
    ],
    
    // Risk management
    riskManagement: {
        minProfit: 100,           // Minimum profit in USD
        maxSlippage: 0.5,         // Maximum slippage percentage
        maxGasPrice: 200,         // Maximum gas price in gwei
        maxTradeSize: 50000       // Maximum trade size in USD
    },
    
    // Execution settings
    execution: {
        priority: 'medium',       // low, medium, high
        slippageTolerance: 0.3,   // Slippage tolerance percentage
        timeout: 30000,           // Timeout in milliseconds
        retryAttempts: 3          // Number of retry attempts
    }
};

Strategy Explanation

Trading Pairs

We focus on high-liquidity ETH pairs to ensure better execution and lower slippage.

Minimum Profit

Set at $100 to ensure profitable trades after accounting for gas costs and potential slippage.

Max Gas Price

200 gwei limit prevents expensive transactions during network congestion.

Trade Size Limit

$50K limit manages risk exposure for your first strategy.

7

Deploy Your Bot

Deploy your configured strategy to start live trading. PoIPoE will immediately begin monitoring for profitable opportunities.

Deploy Trading Bot
// Deploy the bot
async function deployBot() {
    try {
        const bot = await poipoe.deployBot(arbitrageStrategy);
        
        console.log('Bot deployed successfully!');
        console.log('Bot ID:', bot.id);
        console.log('Status:', bot.status);
        console.log('Estimated start time:', bot.estimatedStartTime);
        
        // Store bot ID for later use
        return bot.id;
    } catch (error) {
        console.error('Deployment failed:', error.message);
        throw error;
    }
}

// Event listeners for monitoring
function setupEventListeners(botId) {
    // Listen for profitable opportunities
    poipoe.on('opportunity_detected', (opportunity) => {
        console.log('New opportunity:', {
            pair: opportunity.pair,
            profit: opportunity.profitUSD,
            exchanges: opportunity.exchanges
        });
    });
    
    // Listen for executed trades
    poipoe.on('trade_executed', (trade) => {
        console.log('Trade executed:', {
            type: trade.type,
            pair: trade.pair,
            profit: trade.profitUSD,
            timestamp: trade.timestamp
        });
    });
    
    // Listen for bot status updates
    poipoe.on('bot_status', (status) => {
        console.log('Bot status:', status);
    });
}

// Deploy and monitor
const botId = await deployBot();
setupEventListeners(botId);

Bot Deployment States

1
Pending

Bot configuration being validated

2
Deploying

Smart contracts being deployed

3
Active

Monitoring and ready to trade

8

Monitor Performance

Track your bot's performance through the dashboard or API. Monitor profits, success rates, and gas efficiency.

Get Bot Performance
// Get performance metrics
async function getPerformance(botId) {
    const metrics = await poipoe.getBotMetrics(botId, {
        period: '24h',     // 1h, 24h, 7d, 30d
        granularity: 'hour' // minute, hour, day
    });
    
    console.log('Bot Performance:', {
        totalTrades: metrics.totalTrades,
        successfulTrades: metrics.successfulTrades,
        successRate: metrics.successRate,
        totalProfit: metrics.totalProfitUSD,
        avgProfit: metrics.avgProfitUSD,
        avgExecutionTime: metrics.avgExecutionTime,
        totalGasUsed: metrics.totalGasUsed
    });
    
    return metrics;
}

// Performance monitoring example
const metrics = await getPerformance(botId);

Using the Dashboard

Real-time Charts

View profit/loss over time with interactive charts

Trade History

Complete log of all executed trades with details

Configuration

Adjust parameters and settings in real-time

Alerts

Get notified about important events and opportunities

9

Next Steps

Congratulations! You've successfully set up and deployed your first MEV trading bot. Here are the next steps to maximize your success: