Examples

This section provides practical examples of how to use the Taglife API for common use cases.

Authentication Examples

Basic Authentication

JavaScript/Node.js:

const axios = require('axios');

// Login and get token
async function login(username, password) {
  try {
    const response = await axios.post('https://api.taglife.com/api/auth/token/', {
      username: username,
      password: password
    });

    return response.data.token;
  } catch (error) {
    console.error('Login failed:', error.response.data);
    throw error;
  }
}

// Use token for authenticated requests
async function getCampaigns(token) {
  try {
    const response = await axios.get('https://api.taglife.com/api/get/campaigns/', {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to get campaigns:', error.response.data);
    throw error;
  }
}

// Example usage
async function main() {
  try {
    const token = await login('your_username', 'your_password');
    const campaigns = await getCampaigns(token);
    console.log('Available campaigns:', campaigns);
  } catch (error) {
    console.error('Error:', error.message);
  }
}

Python:

import requests
import json

class TaglifeAPI:
    def __init__(self, base_url='https://api.taglife.com'):
        self.base_url = base_url
        self.token = None

    def login(self, username, password):
        """Login and get JWT token"""
        url = f"{self.base_url}/api/auth/token/"
        data = {
            'username': username,
            'password': password
        }

        response = requests.post(url, json=data)
        response.raise_for_status()

        result = response.json()
        self.token = result['token']
        return result

    def get_headers(self):
        """Get headers with authentication token"""
        return {
            'Authorization': f'JWT {self.token}',
            'Content-Type': 'application/json'
        }

    def get_campaigns(self):
        """Get available campaigns"""
        url = f"{self.base_url}/api/get/campaigns/"
        response = requests.get(url, headers=self.get_headers())
        response.raise_for_status()
        return response.json()

# Example usage
api = TaglifeAPI()
try:
    # Login
    result = api.login('your_username', 'your_password')
    print(f"Logged in as: {result['user']['username']}")

    # Get campaigns
    campaigns = api.get_campaigns()
    print(f"Found {len(campaigns)} campaigns")

except requests.exceptions.RequestException as e:
    print(f"API Error: {e}")

cURL:

# Login and get token
TOKEN=$(curl -s -X POST https://api.taglife.com/api/auth/token/ \
  -H "Content-Type: application/json" \
  -d '{"username": "your_username", "password": "your_password"}' \
  | jq -r '.token')

echo "Token: $TOKEN"

# Use token to get campaigns
curl -X GET https://api.taglife.com/api/get/campaigns/ \
  -H "Authorization: JWT $TOKEN" \
  -H "Content-Type: application/json"

Social Authentication

Facebook Authentication:

// After getting Facebook access token from Facebook SDK
async function authenticateWithFacebook(facebookAccessToken) {
  try {
    const response = await axios.post('https://api.taglife.com/api/auth/facebook/', {
      access_token: facebookAccessToken
    });

    return response.data;
  } catch (error) {
    console.error('Facebook authentication failed:', error.response.data);
    throw error;
  }
}

Instagram Authentication:

def authenticate_with_instagram(instagram_access_token):
    """Authenticate using Instagram access token"""
    url = f"{self.base_url}/api/auth/instagram/"
    data = {
        'access_token': instagram_access_token
    }

    response = requests.post(url, json=data)
    response.raise_for_status()
    return response.json()

Campaign Management Examples

Getting Available Campaigns

JavaScript:

async function getAvailableCampaigns(token) {
  try {
    const response = await axios.get('https://api.taglife.com/api/get/campaigns/', {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      },
      params: {
        status: 'active',
        networks: 'instagram,facebook',
        categories: 'fashion,beauty'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to get campaigns:', error.response.data);
    throw error;
  }
}

Python:

def get_available_campaigns(self, status='active', networks=None, categories=None):
    """Get available campaigns with filters"""
    url = f"{self.base_url}/api/get/campaigns/"
    params = {'status': status}

    if networks:
        params['networks'] = ','.join(networks)
    if categories:
        params['categories'] = ','.join(categories)

    response = requests.get(url, headers=self.get_headers(), params=params)
    response.raise_for_status()
    return response.json()

Joining a Campaign

JavaScript:

async function joinCampaign(token, campaignId) {
  try {
    const response = await axios.post(`https://api.taglife.com/api/campaigns/${campaignId}/join/`, {}, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to join campaign:', error.response.data);
    throw error;
  }
}

Python:

def join_campaign(self, campaign_id):
    """Join a campaign"""
    url = f"{self.base_url}/api/campaigns/{campaign_id}/join/"
    response = requests.post(url, headers=self.get_headers())
    response.raise_for_status()
    return response.json()

Completing a Task

JavaScript:

async function completeTask(token, taskId, submissionData) {
  try {
    const formData = new FormData();
    formData.append('post_url', submissionData.postUrl);
    formData.append('reach', submissionData.reach);
    formData.append('engagement', submissionData.engagement);

    // Add screenshots
    submissionData.screenshots.forEach((screenshot, index) => {
      formData.append(`screenshots`, screenshot);
    });

    const response = await axios.post(`https://api.taglife.com/api/tasks/${taskId}/complete/`, formData, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'multipart/form-data'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to complete task:', error.response.data);
    throw error;
  }
}

Python:

def complete_task(self, task_id, post_url, reach, engagement, screenshots):
    """Complete a task with submission"""
    url = f"{self.base_url}/api/tasks/{task_id}/complete/"

    data = {
        'post_url': post_url,
        'reach': reach,
        'engagement': engagement
    }

    files = []
    for screenshot in screenshots:
        files.append(('screenshots', screenshot))

    response = requests.post(url, headers=self.get_headers(), data=data, files=files)
    response.raise_for_status()
    return response.json()

Social Network Management Examples

Connecting Social Networks

Instagram Connection:

async function connectInstagram(token, instagramData) {
  try {
    const response = await axios.post('https://api.taglife.com/api/connect/instagram/', {
      network_id: instagramData.username,
      network_url: instagramData.profileUrl,
      followers: instagramData.followers,
      category: instagramData.category,
      engagement_rate: instagramData.engagementRate
    }, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to connect Instagram:', error.response.data);
    throw error;
  }
}

Facebook Page Connection:

def connect_facebook_page(self, page_id, page_name, page_url, followers, category):
    """Connect a Facebook page"""
    url = f"{self.base_url}/api/connect/facebook/pages/"
    data = {
        'page_id': page_id,
        'page_name': page_name,
        'page_url': page_url,
        'followers': followers,
        'category': category
    }

    response = requests.post(url, headers=self.get_headers(), json=data)
    response.raise_for_status()
    return response.json()

Getting Social Networks

JavaScript:

async function getSocialNetworks(token) {
  try {
    const response = await axios.get('https://api.taglife.com/api/connect/networks/', {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to get social networks:', error.response.data);
    throw error;
  }
}

Python:

def get_social_networks(self):
    """Get user's connected social networks"""
    url = f"{self.base_url}/api/connect/networks/"
    response = requests.get(url, headers=self.get_headers())
    response.raise_for_status()
    return response.json()

Payment Management Examples

Getting Balance

JavaScript:

async function getBalance(token) {
  try {
    const response = await axios.get('https://api.taglife.com/api/payments/balance/', {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to get balance:', error.response.data);
    throw error;
  }
}

Python:

def get_balance(self):
    """Get user's current balance"""
    url = f"{self.base_url}/api/payments/balance/"
    response = requests.get(url, headers=self.get_headers())
    response.raise_for_status()
    return response.json()

Requesting Payout

JavaScript:

async function requestPayout(token, amount, method, paymentDetails) {
  try {
    const response = await axios.post('https://api.taglife.com/api/payments/payouts/', {
      amount: amount,
      method: method,
      bank_account: paymentDetails.bankAccount,
      paypal_email: paymentDetails.paypalEmail
    }, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to request payout:', error.response.data);
    throw error;
  }
}

Python:

def request_payout(self, amount, method, bank_account_id=None, paypal_email=None):
    """Request a payout"""
    url = f"{self.base_url}/api/payments/payouts/"
    data = {
        'amount': amount,
        'method': method
    }

    if bank_account_id:
        data['bank_account'] = bank_account_id
    if paypal_email:
        data['paypal_email'] = paypal_email

    response = requests.post(url, headers=self.get_headers(), json=data)
    response.raise_for_status()
    return response.json()

Adding Bank Account

JavaScript:

async function addBankAccount(token, bankData) {
  try {
    const response = await axios.post('https://api.taglife.com/api/payments/bank-accounts/', {
      bank_name: bankData.bankName,
      account_number: bankData.accountNumber,
      routing_number: bankData.routingNumber,
      account_type: bankData.accountType,
      account_holder_name: bankData.accountHolderName
    }, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to add bank account:', error.response.data);
    throw error;
  }
}

Python:

def add_bank_account(self, bank_name, account_number, routing_number, account_type, account_holder_name):
    """Add a bank account for payouts"""
    url = f"{self.base_url}/api/payments/bank-accounts/"
    data = {
        'bank_name': bank_name,
        'account_number': account_number,
        'routing_number': routing_number,
        'account_type': account_type,
        'account_holder_name': account_holder_name
    }

    response = requests.post(url, headers=self.get_headers(), json=data)
    response.raise_for_status()
    return response.json()

User Management Examples

Updating Profile

JavaScript:

async function updateProfile(token, profileData) {
  try {
    const response = await axios.patch('https://api.taglife.com/api/users/profile/', {
      first_name: profileData.firstName,
      last_name: profileData.lastName,
      country: profileData.country,
      city: profileData.city,
      language: profileData.language
    }, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to update profile:', error.response.data);
    throw error;
  }
}

Python:

def update_profile(self, first_name=None, last_name=None, country=None, city=None, language=None):
    """Update user profile"""
    url = f"{self.base_url}/api/users/profile/"
    data = {}

    if first_name:
        data['first_name'] = first_name
    if last_name:
        data['last_name'] = last_name
    if country:
        data['country'] = country
    if city:
        data['city'] = city
    if language:
        data['language'] = language

    response = requests.patch(url, headers=self.get_headers(), json=data)
    response.raise_for_status()
    return response.json()

Updating Preferences

JavaScript:

async function updatePreferences(token, preferences) {
  try {
    const response = await axios.patch('https://api.taglife.com/api/users/preferences/', {
      categories: preferences.categories,
      networks: preferences.networks,
      notifications: preferences.notifications
    }, {
      headers: {
        'Authorization': `JWT ${token}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  } catch (error) {
    console.error('Failed to update preferences:', error.response.data);
    throw error;
  }
}

Python:

def update_preferences(self, categories=None, networks=None, notifications=None):
    """Update user preferences"""
    url = f"{self.base_url}/api/users/preferences/"
    data = {}

    if categories:
        data['categories'] = categories
    if networks:
        data['networks'] = networks
    if notifications:
        data['notifications'] = notifications

    response = requests.patch(url, headers=self.get_headers(), json=data)
    response.raise_for_status()
    return response.json()

Error Handling Examples

JavaScript:

class TaglifeAPIError extends Error {
  constructor(message, status, code, details) {
    super(message);
    this.name = 'TaglifeAPIError';
    this.status = status;
    this.code = code;
    this.details = details;
  }
}

async function handleAPIRequest(requestFunction) {
  try {
    return await requestFunction();
  } catch (error) {
    if (error.response) {
      const { status, data } = error.response;

      switch (status) {
        case 400:
          throw new TaglifeAPIError('Bad Request', status, data.error, data.details);
        case 401:
          throw new TaglifeAPIError('Unauthorized', status, data.error, data.details);
        case 403:
          throw new TaglifeAPIError('Forbidden', status, data.error, data.details);
        case 404:
          throw new TaglifeAPIError('Not Found', status, data.error, data.details);
        case 429:
          throw new TaglifeAPIError('Rate Limited', status, data.error, data.details);
        case 500:
          throw new TaglifeAPIError('Server Error', status, data.error, data.details);
        default:
          throw new TaglifeAPIError('Unknown Error', status, data.error, data.details);
      }
    } else {
      throw new TaglifeAPIError('Network Error', 0, 'NETWORK_ERROR', null);
    }
  }
}

Python:

class TaglifeAPIError(Exception):
    def __init__(self, message, status_code, error_code, details):
        super().__init__(message)
        self.status_code = status_code
        self.error_code = error_code
        self.details = details

def handle_api_request(self, request_func):
    """Handle API requests with proper error handling"""
    try:
        return request_func()
    except requests.exceptions.RequestException as e:
        if hasattr(e, 'response') and e.response is not None:
            status_code = e.response.status_code
            try:
                data = e.response.json()
                error_code = data.get('error', 'UNKNOWN_ERROR')
                details = data.get('details', {})
            except ValueError:
                error_code = 'INVALID_RESPONSE'
                details = {}

            error_messages = {
                400: 'Bad Request',
                401: 'Unauthorized',
                403: 'Forbidden',
                404: 'Not Found',
                429: 'Rate Limited',
                500: 'Server Error'
            }

            message = error_messages.get(status_code, 'Unknown Error')
            raise TaglifeAPIError(message, status_code, error_code, details)
        else:
            raise TaglifeAPIError('Network Error', 0, 'NETWORK_ERROR', None)

Complete Integration Example

Here’s a complete example of how to integrate with the Taglife API:

JavaScript/Node.js:

const axios = require('axios');

class TaglifeAPI {
  constructor(baseURL = 'https://api.taglife.com') {
    this.baseURL = baseURL;
    this.token = null;
  }

  async login(username, password) {
    try {
      const response = await axios.post(`${this.baseURL}/api/auth/token/`, {
        username,
        password
      });

      this.token = response.data.token;
      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  async getCampaigns(filters = {}) {
    try {
      const response = await axios.get(`${this.baseURL}/api/get/campaigns/`, {
        headers: this.getHeaders(),
        params: filters
      });

      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  async joinCampaign(campaignId) {
    try {
      const response = await axios.post(`${this.baseURL}/api/campaigns/${campaignId}/join/`, {}, {
        headers: this.getHeaders()
      });

      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  async completeTask(taskId, submission) {
    try {
      const formData = new FormData();
      Object.keys(submission).forEach(key => {
        formData.append(key, submission[key]);
      });

      const response = await axios.post(`${this.baseURL}/api/tasks/${taskId}/complete/`, formData, {
        headers: {
          ...this.getHeaders(),
          'Content-Type': 'multipart/form-data'
        }
      });

      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  async getBalance() {
    try {
      const response = await axios.get(`${this.baseURL}/api/payments/balance/`, {
        headers: this.getHeaders()
      });

      return response.data;
    } catch (error) {
      throw this.handleError(error);
    }
  }

  getHeaders() {
    return {
      'Authorization': `JWT ${this.token}`,
      'Content-Type': 'application/json'
    };
  }

  handleError(error) {
    if (error.response) {
      const { status, data } = error.response;
      return new Error(`API Error ${status}: ${data.message || data.error || 'Unknown error'}`);
    }
    return new Error('Network error');
  }
}

// Usage example
async function main() {
  const api = new TaglifeAPI();

  try {
    // Login
    await api.login('your_username', 'your_password');
    console.log('Logged in successfully');

    // Get available campaigns
    const campaigns = await api.getCampaigns({
      status: 'active',
      networks: 'instagram,facebook'
    });
    console.log(`Found ${campaigns.length} campaigns`);

    // Join a campaign
    if (campaigns.length > 0) {
      const campaign = campaigns[0];
      await api.joinCampaign(campaign.id);
      console.log(`Joined campaign: ${campaign.name}`);
    }

    // Check balance
    const balance = await api.getBalance();
    console.log(`Current balance: $${balance.available_balance}`);

  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

Python:

import requests
import json
from typing import Dict, List, Optional

class TaglifeAPI:
    def __init__(self, base_url: str = 'https://api.taglife.com'):
        self.base_url = base_url
        self.token: Optional[str] = None

    def login(self, username: str, password: str) -> Dict:
        """Login and get JWT token"""
        url = f"{self.base_url}/api/auth/token/"
        data = {'username': username, 'password': password}

        response = requests.post(url, json=data)
        response.raise_for_status()

        result = response.json()
        self.token = result['token']
        return result

    def get_campaigns(self, filters: Dict = None) -> List[Dict]:
        """Get available campaigns"""
        url = f"{self.base_url}/api/get/campaigns/"
        params = filters or {}

        response = requests.get(url, headers=self.get_headers(), params=params)
        response.raise_for_status()
        return response.json()

    def join_campaign(self, campaign_id: int) -> Dict:
        """Join a campaign"""
        url = f"{self.base_url}/api/campaigns/{campaign_id}/join/"

        response = requests.post(url, headers=self.get_headers())
        response.raise_for_status()
        return response.json()

    def complete_task(self, task_id: int, submission: Dict) -> Dict:
        """Complete a task"""
        url = f"{self.base_url}/api/tasks/{task_id}/complete/"

        response = requests.post(url, headers=self.get_headers(), json=submission)
        response.raise_for_status()
        return response.json()

    def get_balance(self) -> Dict:
        """Get user balance"""
        url = f"{self.base_url}/api/payments/balance/"

        response = requests.get(url, headers=self.get_headers())
        response.raise_for_status()
        return response.json()

    def get_headers(self) -> Dict:
        """Get headers with authentication token"""
        return {
            'Authorization': f'JWT {self.token}',
            'Content-Type': 'application/json'
        }

# Usage example
def main():
    api = TaglifeAPI()

    try:
        # Login
        result = api.login('your_username', 'your_password')
        print(f"Logged in as: {result['user']['username']}")

        # Get available campaigns
        campaigns = api.get_campaigns({
            'status': 'active',
            'networks': 'instagram,facebook'
        })
        print(f"Found {len(campaigns)} campaigns")

        # Join a campaign
        if campaigns:
            campaign = campaigns[0]
            result = api.join_campaign(campaign['id'])
            print(f"Joined campaign: {campaign['name']}")

        # Check balance
        balance = api.get_balance()
        print(f"Current balance: ${balance['available_balance']}")

    except requests.exceptions.RequestException as e:
        print(f"API Error: {e}")
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()