Developer API Documentation

// Complete campaign lifecycle management
const API_KEY = process.env.BNB_VOLUME_BOT_API_KEY;
const BASE_URL = 'https://api.bnbvolumebot.net/v1';

async function launchVolumeCampaign() {
  try {
    const response = await fetch(`${BASE_URL}/campaigns`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${API_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        tokenAddress: '0x...',
        volumeTarget: 100.5,
        walletMakers: 500,
        duration: 60,
        dex: 'pancakeswap',
        features: {
          smartWalletDistribution: true,
          antiWhaleProtection: true,
          liquidityOptimization: true
        }
      })
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`API Error: ${error.error.message}`);
    }

    const { data } = await response.json();
    console.log('Campaign launched:', data.campaignId);
    
    // Monitor campaign progress
    return trackCampaignProgress(data.campaignId);
  } catch (error) {
    console.error('Campaign launch failed:', error);
    throw error;
  }
}

async function trackCampaignProgress(campaignId) {
  const pollStatus = async () => {
    const response = await fetch(`${BASE_URL}/campaigns/${campaignId}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    });
    
    const { data } = await response.json();
    console.log(`Progress: ${data.progress.percentComplete}%`);
    console.log(`Volume: ${data.progress.volumeGenerated}/${data.progress.volumeTarget} BNB`);
    console.log(`Transactions: ${data.progress.transactionsExecuted}`);
    
    if (data.status === 'completed') {
      console.log('Campaign completed successfully!');
      return data;
    } else if (data.status === 'failed') {
      throw new Error('Campaign failed');
    }
    
    // Poll every 30 seconds
    await new Promise(resolve => setTimeout(resolve, 30000));
    return pollStatus();
  };
  
  return pollStatus();
}

// Execute campaign
launchVolumeCampaign()
  .then(result => console.log('Final result:', result))
  .catch(error => console.error('Error:', error));

import os
import time
import requests
from typing import Dict, Any

API_KEY = os.getenv('BNB_VOLUME_BOT_API_KEY')
BASE_URL = 'https://api.bnbvolumebot.net/v1'

class BNBVolumeBotClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
    
    def launch_campaign(self, config: Dict[str, Any]) -> Dict[str, Any]:
        """Launch a new volume generation campaign"""
        response = requests.post(
            f'{BASE_URL}/campaigns',
            headers=self.headers,
            json=config
        )
        response.raise_for_status()
        return response.json()['data']
    
    def get_campaign_status(self, campaign_id: str) -> Dict[str, Any]:
        """Retrieve current campaign status"""
        response = requests.get(
            f'{BASE_URL}/campaigns/{campaign_id}',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()['data']
    
    def monitor_campaign(self, campaign_id: str, poll_interval: int = 30):
        """Monitor campaign until completion"""
        while True:
            campaign = self.get_campaign_status(campaign_id)
            status = campaign['status']
            progress = campaign['progress']
            
            print(f"Status: {status}")
            print(f"Progress: {progress['percentComplete']}%")
            print(f"Volume: {progress['volumeGenerated']}/{progress['volumeTarget']} BNB")
            print(f"Transactions: {progress['transactionsExecuted']}")
            print("-" * 60)
            
            if status == 'completed':
                print("Campaign completed successfully!")
                return campaign
            elif status == 'failed':
                raise Exception("Campaign execution failed")
            
            time.sleep(poll_interval)
    
    def get_campaign_analytics(self, campaign_id: str) -> Dict[str, Any]:
        """Retrieve detailed campaign analytics"""
        response = requests.get(
            f'{BASE_URL}/analytics/{campaign_id}',
            headers=self.headers
        )
        response.raise_for_status()
        return response.json()['data']

# Usage example
if __name__ == '__main__':
    client = BNBVolumeBotClient(API_KEY)
    
    # Configure campaign
    campaign_config = {
        'tokenAddress': '0x...',
        'volumeTarget': 100.5,
        'walletMakers': 500,
        'duration': 60,
        'dex': 'pancakeswap',
        'features': {
            'smartWalletDistribution': True,
            'antiWhaleProtection': True,
            'liquidityOptimization': True
        }
    }
    
    try:
        campaign = client.launch_campaign(campaign_config)
        print(f"Campaign launched: {campaign['campaignId']}")
        
        # Monitor execution
        result = client.monitor_campaign(campaign['campaignId'])
        
        # Retrieve analytics
        analytics = client.get_campaign_analytics(campaign['campaignId'])
        print(f"Success rate: {analytics['performance']['successRate'] * 100}%")
        
    except requests.exceptions.HTTPError as e:
        print(f"API Error: {e.response.json()}")

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "os"
    "time"
)

const BaseURL = "https://api.bnbvolumebot.net/v1"

type APIClient struct {
    APIKey     string
    HTTPClient *http.Client
}

type CampaignConfig struct {
    TokenAddress string   `json:"tokenAddress"`
    VolumeTarget float64  `json:"volumeTarget"`
    WalletMakers int      `json:"walletMakers"`
    Duration     int      `json:"duration"`
    Dex          string   `json:"dex"`
}

type Campaign struct {
    CampaignID    string `json:"campaignId"`
    Status        string `json:"status"`
    Progress      CampaignProgress `json:"progress"`
}

type CampaignProgress struct {
    VolumeGenerated      float64 `json:"volumeGenerated"`
    VolumeTarget         float64 `json:"volumeTarget"`
    PercentComplete      int     `json:"percentComplete"`
    TransactionsExecuted int     `json:"transactionsExecuted"`
}

func NewAPIClient(apiKey string) *APIClient {
    return &APIClient{
        APIKey:     apiKey,
        HTTPClient: &http.Client{Timeout: 30 * time.Second},
    }
}

func (c *APIClient) LaunchCampaign(config CampaignConfig) (*Campaign, error) {
    body, _ := json.Marshal(config)
    req, _ := http.NewRequest("POST", BaseURL+"/campaigns", bytes.NewBuffer(body))
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    req.Header.Set("Content-Type", "application/json")
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result struct {
        Data Campaign `json:"data"`
    }
    json.NewDecoder(resp.Body).Decode(&result)
    return &result.Data, nil
}

func (c *APIClient) GetCampaignStatus(campaignID string) (*Campaign, error) {
    req, _ := http.NewRequest("GET", BaseURL+"/campaigns/"+campaignID, nil)
    req.Header.Set("Authorization", "Bearer "+c.APIKey)
    
    resp, err := c.HTTPClient.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()
    
    var result struct {
        Data Campaign `json:"data"`
    }
    json.NewDecoder(resp.Body).Decode(&result)
    return &result.Data, nil
}

func main() {
    client := NewAPIClient(os.Getenv("BNB_VOLUME_BOT_API_KEY"))
    
    config := CampaignConfig{
        TokenAddress: "0x...",
        VolumeTarget: 100.5,
        WalletMakers: 500,
        Duration:     60,
        Dex:          "pancakeswap",
    }
    
    campaign, err := client.LaunchCampaign(config)
    if err != nil {
        panic(err)
    }
    
    fmt.Printf("Campaign launched: %s\n", campaign.CampaignID)
}