Code Examples

Ready-to-use code snippets for the most common DRIP API tasks. Just copy, paste, and customize! 🚀

New to APIs? Each example includes error handling and comments explaining what’s happening. Perfect for learning!

Setup & Authentication

Basic API Client Setup

JavaScript
Python
cURL

class DripClient {
  constructor(apiKey, realmId) {
    this.apiKey = apiKey;
    this.realmId = realmId;
    this.baseUrl = 'https://api.drip.re/api/v1';
  }

  async request(method, endpoint, data = null) {
    const url = `${this.baseUrl}${endpoint}`;
    const options = {
      method,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    };

    if (data) {
      options.body = JSON.stringify(data);
    }

    try {
      const response = await fetch(url, options);
      
      if (!response.ok) {
        const error = await response.json();
        throw new Error(`API Error: ${response.status} - ${error.message || 'Unknown error'}`);
      }

      return response.json();
    } catch (error) {
      console.error('DRIP API Error:', error);
      throw error;
    }
  }
}

// Usage
const client = new DripClient('your_api_key', 'your_realm_id');

import requests
import json

class DripClient:
    def __init__(self, api_key, realm_id):
        self.api_key = api_key
        self.realm_id = realm_id
        self.base_url = 'https://api.drip.re/api/v1'
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })

    def request(self, method, endpoint, data=None):
        url = f"{self.base_url}{endpoint}"
        
        try:
            response = self.session.request(method, url, json=data)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            print(f'DRIP API Error: {e}')
            raise
        except Exception as e:
            print(f'Request failed: {e}')
            raise

# Usage
client = DripClient('your_api_key', 'your_realm_id')

# Set your variables
DRIP_API_KEY="your_api_key_here"
REALM_ID="your_realm_id_here"
BASE_URL="https://api.drip.re/api/v1"

# Function to make API calls
drip_api() {
  local method=$1
  local endpoint=$2
  local data=$3
  
  if [ -n "$data" ]; then
    curl -s -X "$method" "$BASE_URL$endpoint" \
      -H "Authorization: Bearer $DRIP_API_KEY" \
      -H "Content-Type: application/json" \
      -d "$data"
  else
    curl -s -X "$method" "$BASE_URL$endpoint" \
      -H "Authorization: Bearer $DRIP_API_KEY"
  fi
}

# Usage
# drip_api GET "/realms/$REALM_ID"

Member Management

Search for Members

JavaScript
Python
cURL

// Search by different identifiers
async function searchMembers(client, searchType, values) {
  const endpoint = `/realm/${client.realmId}/members/search?type=${searchType}&values=${values}`;
  return await client.request('GET', endpoint);
}

// Examples
const client = new DripClient('your_api_key', 'your_realm_id');

// Search by Discord ID
const discordMembers = await searchMembers(client, 'discord-id', '123456789012345678');

// Search by multiple usernames
const usernameMembers = await searchMembers(client, 'username', 'user1,user2,user3');

// Search by wallet address
const walletMembers = await searchMembers(client, 'wallet', '0x742d35Cc6634C0532925a3b8D23');

// Search by email
const emailMembers = await searchMembers(client, 'email', '[email protected]');

console.log('Found members:', discordMembers.data);

def search_members(client, search_type, values):
    endpoint = f'/realm/{client.realm_id}/members/search?type={search_type}&values={values}'
    return client.request('GET', endpoint)

# Examples
client = DripClient('your_api_key', 'your_realm_id')

# Search by Discord ID
discord_members = search_members(client, 'discord-id', '123456789012345678')

# Search by multiple usernames
username_members = search_members(client, 'username', 'user1,user2,user3')

# Search by wallet address
wallet_members = search_members(client, 'wallet', '0x742d35Cc6634C0532925a3b8D23')

print(f"Found {len(discord_members.get('data', []))} members")

# Search by Discord ID
drip_api GET "/realm/$REALM_ID/members/search?type=discord-id&values=123456789012345678"

# Search by multiple usernames
drip_api GET "/realm/$REALM_ID/members/search?type=username&values=user1,user2,user3"

# Search by wallet
drip_api GET "/realm/$REALM_ID/members/search?type=wallet&values=0x742d35Cc6634C0532925a3b8D23"

Get Member Details

JavaScript
Python

async function getMemberDetails(client, memberId) {
  // First search for the member to get their full details
  const members = await searchMembers(client, 'drip-id', memberId);
  
  if (members.data && members.data.length > 0) {
    const member = members.data[0];
    
    return {
      id: member.id,
      name: member.displayName || member.username,
      joinedAt: member.joinedAt,
      lastVisit: member.lastVisit,
      points: member.pointBalances || [],
      credentials: member.credentials || []
    };
  }
  
  throw new Error('Member not found');
}

// Usage
try {
  const member = await getMemberDetails(client, 'member_id_here');
  console.log(`${member.name} has ${member.points[0]?.balance || 0} points`);
} catch (error) {
  console.error('Member not found:', error.message);
}

def get_member_details(client, member_id):
    members = search_members(client, 'drip-id', member_id)
    
    if members.get('data') and len(members['data']) > 0:
        member = members['data'][0]
        
        return {
            'id': member['id'],
            'name': member.get('displayName') or member.get('username'),
            'joined_at': member.get('joinedAt'),
            'last_visit': member.get('lastVisit'),
            'points': member.get('pointBalances', []),
            'credentials': member.get('credentials', [])
        }
    
    raise Exception('Member not found')

# Usage
try:
    member = get_member_details(client, 'member_id_here')
    points = member['points'][0]['balance'] if member['points'] else 0
    print(f"{member['name']} has {points} points")
except Exception as e:
    print(f"Member not found: {e}")

Points Management

Award Points to a Member

JavaScript
Python
cURL

async function awardPoints(client, memberId, points, realmPointId = null) {
  const endpoint = `/realm/${client.realmId}/members/${memberId}/point-balance`;
  const data = { tokens: points };
  
  if (realmPointId) {
    data.realmPointId = realmPointId;
  }
  
  return await client.request('PATCH', endpoint, data);
}

// Examples
const client = new DripClient('your_api_key', 'your_realm_id');

// Award 100 points (default currency)
const result = await awardPoints(client, 'member_id', 100);
console.log('Points awarded:', result);

// Award points to specific currency
const specificResult = await awardPoints(client, 'member_id', 50, 'specific_point_id');

// Deduct points (negative number)
const deductResult = await awardPoints(client, 'member_id', -25);

def award_points(client, member_id, points, realm_point_id=None):
    endpoint = f'/realm/{client.realm_id}/members/{member_id}/point-balance'
    data = {'tokens': points}
    
    if realm_point_id:
        data['realmPointId'] = realm_point_id
    
    return client.request('PATCH', endpoint, data)

# Examples
client = DripClient('your_api_key', 'your_realm_id')

# Award 100 points
result = award_points(client, 'member_id', 100)
print('Points awarded:', result)

# Deduct 25 points
deduct_result = award_points(client, 'member_id', -25)

# Award 100 points
drip_api PATCH "/realm/$REALM_ID/members/MEMBER_ID/point-balance" '{"tokens": 100}'

# Award points to specific currency
drip_api PATCH "/realm/$REALM_ID/members/MEMBER_ID/point-balance" '{"tokens": 50, "realmPointId": "POINT_ID"}'

# Deduct points
drip_api PATCH "/realm/$REALM_ID/members/MEMBER_ID/point-balance" '{"tokens": -25}'

Batch Update Multiple Members

JavaScript
Python

async function batchUpdatePoints(client, updates) {
  const endpoint = `/realm/${client.realmId}/members/transaction`;
  return await client.request('PATCH', endpoint, { updates });
}

// Example: Award points to multiple members
const updates = [
  { memberId: 'member_1', tokens: 100 },
  { memberId: 'member_2', tokens: 150 },
  { memberId: 'member_3', tokens: 75, realmPointId: 'specific_point_id' }
];

const batchResult = await batchUpdatePoints(client, updates);
console.log('Batch update result:', batchResult);

// Example: Weekly point distribution
async function weeklyPointDistribution(client, memberIds, basePoints = 50) {
  const updates = memberIds.map(memberId => ({
    memberId,
    tokens: basePoints + Math.floor(Math.random() * 50) // 50-100 points
  }));
  
  return await batchUpdatePoints(client, updates);
}

def batch_update_points(client, updates):
    endpoint = f'/realm/{client.realm_id}/members/transaction'
    return client.request('PATCH', endpoint, {'updates': updates})

# Example: Award points to multiple members
updates = [
    {'memberId': 'member_1', 'tokens': 100},
    {'memberId': 'member_2', 'tokens': 150},
    {'memberId': 'member_3', 'tokens': 75, 'realmPointId': 'specific_point_id'}
]

batch_result = batch_update_points(client, updates)
print('Batch update result:', batch_result)

# Weekly distribution function
def weekly_point_distribution(client, member_ids, base_points=50):
    import random
    updates = [
        {
            'memberId': member_id,
            'tokens': base_points + random.randint(0, 50)
        }
        for member_id in member_ids
    ]
    return batch_update_points(client, updates)

Transfer Points Between Members

JavaScript
Python

async function transferPoints(client, senderId, recipientId, amount, realmPointId) {
  const endpoint = `/realm/${client.realmId}/members/${senderId}/transfer`;
  const data = {
    tokens: amount,
    recipientId: recipientId,
    realmPointId: realmPointId
  };
  
  return await client.request('PATCH', endpoint, data);
}

// Example: Transfer 100 points from one member to another
const transfer = await transferPoints(
  client,
  'sender_member_id',
  'recipient_member_id', 
  100,
  'realm_point_id'
);

console.log('Transfer successful:', transfer);

def transfer_points(client, sender_id, recipient_id, amount, realm_point_id):
    endpoint = f'/realm/{client.realm_id}/members/{sender_id}/transfer'
    data = {
        'tokens': amount,
        'recipientId': recipient_id,
        'realmPointId': realm_point_id
    }
    return client.request('PATCH', endpoint, data)

# Example usage
transfer = transfer_points(
    client,
    'sender_member_id',
    'recipient_member_id',
    100,
    'realm_point_id'
)
print('Transfer successful:', transfer)

Common Patterns

Find and Reward Active Members

JavaScript
Python

async function rewardActiveMembers(client, minPoints = 0, reward = 50) {
  // Get all members
  const allMembers = await searchMembers(client, 'drip-id', 'all');
  
  // Filter active members (you can customize this logic)
  const activeMembers = allMembers.data.filter(member => {
    const points = member.pointBalances[0]?.balance || 0;
    const lastVisit = new Date(member.lastVisit);
    const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
    
    return points >= minPoints && lastVisit > weekAgo;
  });

  // Prepare batch update
  const updates = activeMembers.map(member => ({
    memberId: member.id,
    tokens: reward
  }));

  if (updates.length > 0) {
    const result = await batchUpdatePoints(client, updates);
    console.log(`Rewarded ${updates.length} active members with ${reward} points each`);
    return result;
  } else {
    console.log('No active members found to reward');
    return null;
  }
}

// Usage
await rewardActiveMembers(client, 100, 75); // Reward members with 100+ points who visited in last week

from datetime import datetime, timedelta

def reward_active_members(client, min_points=0, reward=50):
    # Get all members
    all_members = search_members(client, 'drip-id', 'all')
    
    # Filter active members
    active_members = []
    week_ago = datetime.now() - timedelta(days=7)
    
    for member in all_members.get('data', []):
        points = member.get('pointBalances', [{}])[0].get('balance', 0)
        last_visit = datetime.fromisoformat(member.get('lastVisit', '').replace('Z', '+00:00'))
        
        if points >= min_points and last_visit > week_ago:
            active_members.append(member)

    # Prepare batch update
    updates = [
        {'memberId': member['id'], 'tokens': reward}
        for member in active_members
    ]

    if updates:
        result = batch_update_points(client, updates)
        print(f"Rewarded {len(updates)} active members with {reward} points each")
        return result
    else:
        print("No active members found to reward")
        return None

# Usage
reward_active_members(client, 100, 75)

Create a Leaderboard

JavaScript
Python

async function getLeaderboard(client, limit = 10) {
  // Get all members
  const allMembers = await searchMembers(client, 'drip-id', 'all');
  
  // Filter members with points and sort
  const leaderboard = allMembers.data
    .filter(member => member.pointBalances && member.pointBalances.length > 0)
    .map(member => ({
      id: member.id,
      name: member.displayName || member.username || 'Anonymous',
      points: member.pointBalances[0]?.balance || 0,
      joinedAt: member.joinedAt,
      lastVisit: member.lastVisit
    }))
    .sort((a, b) => b.points - a.points)
    .slice(0, limit)
    .map((member, index) => ({
      ...member,
      rank: index + 1
    }));

  return leaderboard;
}

// Usage
const topMembers = await getLeaderboard(client, 10);
console.log('Top 10 Members:');
topMembers.forEach(member => {
  console.log(`${member.rank}. ${member.name}: ${member.points} points`);
});

def get_leaderboard(client, limit=10):
    # Get all members
    all_members = search_members(client, 'drip-id', 'all')
    
    # Filter and sort members
    leaderboard = []
    for member in all_members.get('data', []):
        if member.get('pointBalances') and len(member['pointBalances']) > 0:
            leaderboard.append({
                'id': member['id'],
                'name': member.get('displayName') or member.get('username') or 'Anonymous',
                'points': member['pointBalances'][0].get('balance', 0),
                'joined_at': member.get('joinedAt'),
                'last_visit': member.get('lastVisit')
            })
    
    # Sort by points and add ranks
    leaderboard = sorted(leaderboard, key=lambda x: x['points'], reverse=True)[:limit]
    for i, member in enumerate(leaderboard):
        member['rank'] = i + 1
    
    return leaderboard

# Usage
top_members = get_leaderboard(client, 10)
print("Top 10 Members:")
for member in top_members:
    print(f"{member['rank']}. {member['name']}: {member['points']} points")

Discord Bot Integration

JavaScript (Discord.js)
Python (discord.py)

const { Client, GatewayIntentBits } = require('discord.js');

const bot = new Client({
  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
});

const dripClient = new DripClient('your_drip_api_key', 'your_realm_id');

// Award points for messages
bot.on('messageCreate', async (message) => {
  if (message.author.bot) return;

  try {
    // Find member by Discord ID
    const members = await searchMembers(dripClient, 'discord-id', message.author.id);
    
    if (members.data && members.data.length > 0) {
      const memberId = members.data[0].id;
      
      // Award 5 points per message
      await awardPoints(dripClient, memberId, 5);
      
      // Optional: React to show points were awarded
      await message.react('⭐');
    }
  } catch (error) {
    console.error('Error awarding points:', error);
  }
});

// Leaderboard command
bot.on('messageCreate', async (message) => {
  if (message.content === '!leaderboard') {
    try {
      const leaderboard = await getLeaderboard(dripClient, 5);
      
      const leaderboardText = leaderboard
        .map(member => `${member.rank}. ${member.name}: ${member.points} points`)
        .join('\n');
      
      await message.reply(`🏆 **Top 5 Members:**\n\`\`\`\n${leaderboardText}\n\`\`\``);
    } catch (error) {
      await message.reply('Sorry, I couldn\'t fetch the leaderboard right now.');
    }
  }
});

bot.login('your_discord_bot_token');

import discord
from discord.ext import commands

bot = commands.Bot(command_prefix='!', intents=discord.Intents.all())
drip_client = DripClient('your_drip_api_key', 'your_realm_id')

@bot.event
async def on_message(message):
    if message.author.bot:
        return

    try:
        # Find member by Discord ID
        members = search_members(drip_client, 'discord-id', str(message.author.id))
        
        if members.get('data') and len(members['data']) > 0:
            member_id = members['data'][0]['id']
            
            # Award 5 points per message
            award_points(drip_client, member_id, 5)
            
            # React to show points were awarded
            await message.add_reaction('⭐')
    except Exception as e:
        print(f'Error awarding points: {e}')

    await bot.process_commands(message)

@bot.command()
async def leaderboard(ctx):
    try:
        top_members = get_leaderboard(drip_client, 5)
        
        leaderboard_text = '\n'.join([
            f"{member['rank']}. {member['name']}: {member['points']} points"
            for member in top_members
        ])
        
        await ctx.send(f"🏆 **Top 5 Members:**\n```\n{leaderboard_text}\n```")
    except Exception as e:
        await ctx.send("Sorry, I couldn't fetch the leaderboard right now.")

bot.run('your_discord_bot_token')

Error Handling Patterns

Robust Error Handling

JavaScript
Python

async function safeApiCall(apiCall, fallbackValue = null) {
  try {
    return await apiCall();
  } catch (error) {
    console.error('API call failed:', error.message);
    
    // Handle specific error types
    if (error.message.includes('401')) {
      console.error('Authentication failed - check your API key');
    } else if (error.message.includes('403')) {
      console.error('Permission denied - check your scopes');
    } else if (error.message.includes('404')) {
      console.error('Resource not found');
    } else if (error.message.includes('429')) {
      console.error('Rate limited - slow down your requests');
    }
    
    return fallbackValue;
  }
}

// Usage
const members = await safeApiCall(
  () => searchMembers(client, 'discord-id', 'invalid_id'),
  { data: [] }
);

def safe_api_call(api_call, fallback_value=None):
    try:
        return api_call()
    except Exception as e:
        print(f'API call failed: {e}')
        
        # Handle specific error types
        error_str = str(e).lower()
        if '401' in error_str:
            print('Authentication failed - check your API key')
        elif '403' in error_str:
            print('Permission denied - check your scopes')
        elif '404' in error_str:
            print('Resource not found')
        elif '429' in error_str:
            print('Rate limited - slow down your requests')
        
        return fallback_value

# Usage
members = safe_api_call(
    lambda: search_members(client, 'discord-id', 'invalid_id'),
    {'data': []}
)

Quick Reference

Most Common API Calls

// Authentication & Setup
const client = new DripClient('api_key', 'realm_id');

// Get realm info
const realm = await client.request('GET', `/realms/${client.realmId}`);

// Search members
const members = await searchMembers(client, 'discord-id', 'user_id');

// Award points
await awardPoints(client, 'member_id', 100);

// Get leaderboard
const top10 = await getLeaderboard(client, 10);

// Batch update
await batchUpdatePoints(client, [
  { memberId: 'id1', tokens: 50 },
  { memberId: 'id2', tokens: 75 }
]);

Common Search Types

Type	Use Case	Example Value
`discord-id`	Find Discord users	`123456789012345678`
`username`	Find by display name	`cooluser123`
`email`	Find by email	`[email protected]`
`wallet`	Find crypto users	`0x742d35Cc6634C0532925a3b8D23`
`twitter-id`	Find Twitter users	`987654321`
`drip-id`	Find by DRIP ID	`507f1f77bcf86cd799439013`

Need more examples? Check out our First App tutorial for a complete working project, or browse the API Reference for detailed endpoint documentation.

Overview

Developer Guide

Apps

Drip Academy

FAQ

Links

Code Examples

Setup & Authentication

Basic API Client Setup

Member Management

Search for Members

Get Member Details

Points Management

Award Points to a Member

Batch Update Multiple Members

Transfer Points Between Members

Common Patterns

Find and Reward Active Members

Create a Leaderboard

Discord Bot Integration

Error Handling Patterns

Robust Error Handling

Quick Reference

Most Common API Calls

Common Search Types

​Setup & Authentication

​Basic API Client Setup

​Member Management

​Search for Members

​Get Member Details

​Points Management

​Award Points to a Member

​Batch Update Multiple Members

​Transfer Points Between Members

​Common Patterns

​Find and Reward Active Members

​Create a Leaderboard

​Discord Bot Integration

​Error Handling Patterns

​Robust Error Handling

​Quick Reference

​Most Common API Calls

​Common Search Types

Setup & Authentication

Basic API Client Setup

Member Management

Search for Members

Get Member Details

Points Management

Award Points to a Member

Batch Update Multiple Members

Transfer Points Between Members

Common Patterns

Find and Reward Active Members

Create a Leaderboard

Discord Bot Integration

Error Handling Patterns

Robust Error Handling

Quick Reference

Most Common API Calls

Common Search Types