Integration Guide

Quick assessment for potential customers: How much development work is required?

TL;DR: Integration Effort

Integration Type	Time Estimate	Complexity
Basic Setup	15-30 minutes	⭐ Easy
Smart Contract Deployment	2-4 hours	⭐⭐ Moderate
Conversion Tracking	2-4 hours	⭐⭐ Moderate
Full Integration	6-8 hours	⭐⭐ Moderate

Total Development Time: One full day for a complete integration.

---

What You Need to Integrate

1. Account Setup (15-30 minutes)

• Contact ReplyCorp to request access

• ReplyCorp registers your organization and creates your account

• Log into the admin panel and retrieve:

  • Your API key

  • Your campaign ID

• Enter contract parameters in the admin panel:

  • Chain (blockchain network)

  • Token address for fee distribution

  • Revenue share percentage

  • ReplyCorp fee percentage (set by ReplyCorp when creating your account)

What you provide to ReplyCorp:

• Organization name and slug

• Admin email address

• Campaign details (Twitter handle to track, campaign name)

What ReplyCorp handles:

• Account provisioning

• Initial account setup

---

2. Smart Contract Deployment (2-4 hours)

Required step: Deploy the fee routing smart contract that receives fees and distributes them based on attribution data.

What you need to do:

• Enter contract parameters in the admin panel (chain, token address, revenue share %)

• ReplyCorp fee percentage is set by ReplyCorp when creating your account

• Receive contract code from ReplyCorp

• Deploy the contract to your specified chain with the parameters you entered

• Configure your system to interact with the deployed contract address

⚠️ CRITICAL: Funding the Distribution Wallet

The wallet that calls startDistribution() must have sufficient ERC-20 token balance available at the time the function is executed. The contract pulls tokens from this wallet to perform all distributions.

The distribution wallet may be funded in either of the following ways:

1. Real-time funding Conversion transactions can be configured to route ERC-20 proceeds directly to the distribution wallet as they occur.

2. Pre-funding You may pre-fund the distribution wallet by transferring ERC-20 tokens in advance to cover an expected amount of upcoming rewards over a defined timeframe. This is not a one-time setup — the wallet balance must be monitored and periodically topped up over time to continue supporting future distributions.

In both cases, the contract does not mint or source tokens. It only transfers tokens already held by the distribution wallet. If the wallet balance is insufficient when startDistribution() is called, the transaction will revert.

⚠️ CRITICAL: Token Denomination

• Token denomination consistency: If you're rewarding with a specific token (e.g., USDC), all financial data posted to the API (totalVolume, netProfit, commission) must be denominated in that same token. For example, if distributing USDC, all amounts should be in USDC, not USD or other currencies.

How the contract works:

1. When you call the conversion API, ReplyCorp calculates attribution and updates the contract with attribution data (tied to conversion ID) before sending you the API response

2. The API response includes the conversion.id, attributionHash, and totalToSendToContract amount

3. You send the total fees (from the API response), conversion ID, and attribution hash to the contract - the contract automatically verifies the hash matches and distributes fees to referrers based on the pre-calculated and now approved attribution breakdown

Code Example:

// Calculate financial values
const grossRevenue = 100.00; // Total volume
const costs = 17.00; // Platform fees, gas, cost of goods, etc.
const netProfit = grossRevenue - costs; // $83
const commission = 20.00; // Amount you want to distribute to referrers

// 1. Record conversion - ReplyCorp updates contract with attribution BEFORE responding
const conversionResponse = await fetch('https://prod.api.replycorp.io/api/v1/campaigns/{campaignId}/conversions', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    twitterId: '1234567890',
    eventType: 'purchase',
    totalVolume: grossRevenue, // Gross revenue
    netProfit: netProfit, // Net profit (totalVolume - costs)
    commission: commission, // Amount to distribute to referrers
    walletAddress: '0x...'
  })
});

const result = await conversionResponse.json();
const conversionId = result.conversion.id;
const attributionHash = result.feeDistribution.attributionHash; // Hash for verification
const totalToSend = result.feeDistribution.totalToSendToContract; // commission + ReplyCorp fee

// 2. Check distribution route in contract and verify hash
const distributionRoute = await feeRouterContract.getDistributionRoute(conversionId);
// Returns: {distributions, commission, replyCorpFee, totalAmount, attributionHash, distributed}
// Verify attributionHash matches the one in the API response

if (distributionRoute.attributionHash !== attributionHash) {
  throw new Error('Attribution hash mismatch - do not proceed with distribution');
}

// 3. Approve contract to spend tokens (for ERC20)
await tokenContract.approve(feeRouterContractAddress, totalToSend);

// 4. Start distribution (contract pulls tokens via transferFrom)
await feeRouterContract.startDistribution(
  conversionId,
  totalToSend,
  attributionHash
);

// 5. Process batches (for conversions with >200 recipients, call multiple times)
// Batch 0: processes recipients 0-199, Batch 1: processes 200-399, etc.
const batchCount = await feeRouterContract.getBatchCount(conversionId);

for (let batchIndex = 0; batchIndex < batchCount; batchIndex++) {
  // Check if batch already completed (idempotent)
  const isCompleted = await feeRouterContract.isBatchCompleted(conversionId, batchIndex);
  if (isCompleted) {
    console.log(`Batch ${batchIndex} already completed, skipping`);
    continue;
  }
  
  const tx = await feeRouterContract.processBatch(conversionId, batchIndex);
  const receipt = await tx.wait();
  
  // Parse BatchDistributed event to check for failures
  const batchEvent = receipt.events.find(e => e.event === 'BatchDistributed');
  const failedCount = batchEvent?.args.failedCount || 0;
  
  console.log(`Batch ${batchIndex} completed. Failed transfers: ${failedCount}`);
}

// 6. Finalize distribution (converts any remaining reserved balance to dust)
await feeRouterContract.finalizeDistribution(conversionId);

// Contract validates hash, pulls tokens (on startDistribution), transfers ReplyCorp fee immediately,
// then distributes commission to referrers in batches. Failed transfers are skipped and accumulated as dust.

What you build:

• Contract deployment script with parameters from admin panel

• Fee sending logic that includes conversion ID

What ReplyCorp handles:

• Contract code and deployment instructions

• Attribution calculation and contract updates (happens automatically before API response)

---

2.5A. Alternative: Smart Contract Deployment + Later/Periodic Fee Distribution (instead of real-time fee distribution)

When to use this approach:

• You want to use the fee router contract for automated distribution

• But you need to batch payments or distribute commissions on a schedule (weekly, monthly, etc.) instead of real-time

• You want to manually review attribution data before distributing fees

• You want to aggregate multiple conversions before distributing fees

How it works:

1. Deploy the fee router contract (same as section 2)

2. Call the conversion API - ReplyCorp automatically updates the contract with attribution data

3. Store conversion IDs and fee distribution data from API responses

4. Later (weekly/monthly), batch process multiple conversions by calling the contract distribution functions

Best Practices:

1. Store Conversion Data for Batching

   // After each conversion API call
   const result = await conversionResponse.json();
   
   await db.pendingDistributions.create({
     data: {
       conversionId: result.conversion.id,
       campaignId: campaignId,
       totalToSend: result.feeDistribution.totalToSendToContract,
       attributionHash: result.feeDistribution.attributionHash,
       commission: result.feeDistribution.totalCommission,
       replyCorpFee: result.feeDistribution.replyCorpFee,
       createdAt: new Date(),
       distributionStatus: 'pending'
     }
   });

2. Batch Process Multiple Conversions

   // Weekly/monthly batch job
   const pendingDistributions = await db.pendingDistributions.findMany({
     where: {
       distributionStatus: 'pending',
       createdAt: { lte: batchCutoffDate }
     }
   });
   
   // Process each conversion through the contract
   for (const distribution of pendingDistributions) {
     try {
       // Approve contract to spend tokens (if not already approved)
       await tokenContract.approve(
         feeRouterContractAddress, 
         distribution.totalToSend
       );
       
       // Start distribution
       await feeRouterContract.startDistribution(
         distribution.conversionId,
         distribution.totalToSend,
         distribution.attributionHash
       );
       
       // Process all batches
       const batchCount = await feeRouterContract.getBatchCount(distribution.conversionId);
       for (let batchIndex = 0; batchIndex < batchCount; batchIndex++) {
         const isCompleted = await feeRouterContract.isBatchCompleted(
           distribution.conversionId, 
           batchIndex
         );
         if (!isCompleted) {
           await feeRouterContract.processBatch(distribution.conversionId, batchIndex);
         }
       }
       
       // Finalize distribution
       await feeRouterContract.finalizeDistribution(distribution.conversionId);
       
       // Mark as distributed
       await db.pendingDistributions.update({
         where: { id: distribution.id },
         data: { distributionStatus: 'distributed', distributedAt: new Date() }
       });
     } catch (error) {
       console.error(`Failed to distribute conversion ${distribution.conversionId}:`, error);
       // Mark as failed, retry later
       await db.pendingDistributions.update({
         where: { id: distribution.id },
         data: { distributionStatus: 'failed', error: error.message }
       });
     }
   }

3. Consider Gas Optimization

   • Batch multiple startDistribution calls in a single transaction if possible

   • Process batches sequentially to avoid gas limit issues

   • Monitor gas costs - batching may be more cost-effective than real-time distribution

4. Handle Failures and Retries

   • Track which conversions failed to distribute

   • Implement retry logic with exponential backoff

   • Set maximum retry attempts before manual review

5. Reconciliation

   • Use conversion.id to track which conversions have been distributed

   • Query contract state to verify distribution completion

   • Reconcile with your accounting system

Important Notes:

• The contract stores attribution data permanently - you can distribute at any time

• Attribution hash verification ensures you're distributing the correct amounts

• You can batch process conversions in any order

• Failed transfers accumulate as dust (see contract documentation)

• Consider gas costs when deciding batch frequency

Benefits of This Approach:

• ✅ Uses automated contract distribution (no manual payout logic)

• ✅ Allows batching for gas efficiency

• ✅ Maintains attribution verification via hash

• ✅ Can aggregate multiple conversions before distributing

• ✅ Still benefits from contract's best-effort distribution model

---

2.5B. Alternative: Independent Fee Routing

When to use this approach:

• You're using a different payment system or smart contract architecture

We recommend using the fee router contract for real-time, automated fee distribution. However, if you're using a different payment system or smart contract architecture, you can store the attribution data from our API and distribute fees using your own system.

Best Practices:

1. Store the Complete Attribution Data

   • Save the entire API response, including:

     • conversion.id - Unique identifier for the conversion

     • attribution.attributions[] - Array of all attributed referrers with percentages

     • attribution.attributions[].walletAddress - Wallet addresses (may be null)

     • attribution.attributions[].attributedAmount - Dollar amount attributed to each referrer

     • attribution.attributions[].attributionPercentage - Percentage of conversion attributed

     • conversion.conversionValue - The conversion amount

2. Handle Missing Wallet Addresses

   • Some referrers may not have connected their wallets (walletAddress: null)

   • Options for handling:

     • Escrow: Hold funds in your system until wallet is connected (set a time limit, e.g., 30 days)

     • Match on your side: If you have wallet addresses linked to Twitter IDs in your system, match them

     • Webhook notifications: Subscribe to webhook updates when participants connect wallets

3. Calculate Payouts When Ready to Distribute

   // Example: Calculate payouts from stored attribution data
   const conversionValue = storedConversion.conversionValue; // e.g., $100
   const commissionRate = 0.20; // 20% commission rate
   const totalCommission = conversionValue * commissionRate; // $20
   
   const payouts = storedConversion.attribution.attributions.map(attr => {
     // Calculate payout based on attribution percentage
     const payoutAmount = totalCommission * (attr.attributionPercentage / 100);
     
     return {
       walletAddress: attr.walletAddress, // May be null
       twitterId: attr.twitterId,
       twitterHandle: attr.twitterHandle,
       attributedAmount: attr.attributedAmount,
       attributionPercentage: attr.attributionPercentage,
       payoutAmount: payoutAmount
     };
   });
   
   // Filter out payouts without wallet addresses (handle separately)
   const payoutsWithWallets = payouts.filter(p => p.walletAddress !== null);
   const payoutsWithoutWallets = payouts.filter(p => p.walletAddress === null);
   
   // Distribute payouts with wallets
   for (const payout of payoutsWithWallets) {
     await distributeToWallet(payout.walletAddress, payout.payoutAmount);
   }
   
   // Handle payouts without wallets (escrow, match, or wait)
   await handlePayoutsWithoutWallets(payoutsWithoutWallets);

4. Track Distribution Status

   • Store which conversions have been distributed

   • Track which referrers have been paid

   • Handle partial distributions (if some wallets are missing)

   • Reconcile with your accounting system

5. Consider Batch Processing

   • If distributing weekly/monthly, aggregate attribution data:

     // Aggregate attributions across multiple conversions
     const aggregatedPayouts = new Map();
     
     for (const conversion of conversionsToDistribute) {
       for (const attr of conversion.attribution.attributions) {
         if (attr.walletAddress) {
           const existing = aggregatedPayouts.get(attr.walletAddress) || {
             walletAddress: attr.walletAddress,
             totalPayout: 0,
             conversions: []
           };
           existing.totalPayout += attr.attributedAmount * commissionRate;
           existing.conversions.push(conversion.id);
           aggregatedPayouts.set(attr.walletAddress, existing);
         }
       }
     }
     
     // Distribute aggregated payouts
     for (const payout of aggregatedPayouts.values()) {
       await distributeToWallet(payout.walletAddress, payout.totalPayout);
     }

6. Use Conversion ID for Reconciliation

   • The conversion.id is unique and permanent

   • Use it to track which conversions have been processed

   • Link it to your internal transaction IDs for audit trails

Important Notes:

• Attribution percentages are calculated from totalVolume (who influenced the sale)

• You can still use totalVolume, netProfit, and commission fields in the API request for accurate attribution calculation

• The API response includes all the data you need - no need to query the contract

• Wallet addresses may be null - plan for this in your distribution logic

• Attribution data is immutable once returned - store it securely for your records

Example Storage Schema:

// Example database schema for storing attribution data
{
  conversionId: "conv_123456", // From API response
  campaignId: "campaign_uuid",
  conversionValue: 100.00,
  convertedAt: "2025-01-15T10:30:00.000Z",
  attributionData: {
    attributions: [...], // Full attributions array from API
    totalPointsDistributed: 1235,
    firstDegreeCount: 2,
    secondDegreeCount: 5
  },
  distributionStatus: "pending", // pending, distributed, partial, failed
  distributedAt: null,
  payoutTransactions: [] // Array of transaction hashes when distributed
}

---

3. Conversion Tracking (2-4 hours)

Required step: Call ReplyCorp's API whenever a conversion happens in your system.

CRITICAL: Financial Fields

⚠️ CRITICAL: Token Denomination

• All financial data must be denominated in your reward token: If you're distributing rewards in a specific ERC20 token (e.g., USDC), all financial fields (totalVolume, netProfit, commission) must be denominated in that same token. For example, if your contract uses USDC, all amounts should be in USDC units, not USD or other currencies. This ensures accurate attribution calculations and proper distribution amounts.

If using the fee router contract, you must provide three financial fields:

• totalVolume: Gross revenue from the conversion

• netProfit: Net profit (totalVolume minus all costs)

• commission: Amount you want to distribute to referrers

If NOT using the fee router contract, you can use the simpler amount field:

• amount: The conversion amount (positive for purchases/locks, negative for refunds/unlocks)

Important Notes:

• You determine your desired commission percentage - This is not fixed by our system. You have full control over how much commission you allocate for referral rewards, and you can vary this on a per-user or per-transaction basis before calling our API. This flexibility allows you to implement different commission structures (e.g., lower total fees on transactions from VIP users, promotional rates for specific campaigns, etc.) entirely within your own system.

• Attribution percentages are calculated from totalVolume (if provided) or amount (who influenced the sale)

• If using fee router: Commission amounts are distributed from commission (the portion you allocate to referrers)

• If using fee router: ReplyCorp fee is calculated from netProfit

• If not using fee router: Store the attribution data from the API response and distribute fees later using your own system

What you must do (Fee Router Path):

• Identify when conversions occur (purchases, token locks, etc.)

• Calculate totalVolume, netProfit, and commission for each conversion

• Get the user's Twitter/X ID

• Make a single API call to record the conversion with all three financial fields

• Extract the conversion ID and attributionHash from the response

• Verify attribution data in contract matches the hash

• Approve contract to spend tokens (for ERC20)

• Call startDistribution with conversion ID and hash

• Process batches using processBatch (for conversions with >200 recipients)

• Call finalizeDistribution to complete the distribution

What you must do (Non-Fee Router Path):

• Identify when conversions occur (purchases, token locks, etc.)

• Get the user's Twitter/X ID

• Make a single API call to record the conversion with amount field (or totalVolume/netProfit/commission if you want more detailed attribution)

• Store the complete API response (including conversion.id and attribution.attributions[])

• Later, calculate payouts from stored attribution data and distribute using your own system (see section 2.5 for best practices)

Integration flow (Fee Router Path):

1. After a successful purchase → calculate totalVolume, netProfit, commission

2. Call conversion API with all three financial fields

3. ReplyCorp calculates attribution percentages from totalVolume

4. ReplyCorp calculates ReplyCorp fee from netProfit

5. ReplyCorp updates your smart contract with attribution data (percentages from totalVolume, amounts from commission)

6. ReplyCorp returns API response with conversion ID, attributionHash, and fee distribution amounts

7. You verify attribution hash matches contract data

8. You approve contract to spend tokens

9. You call startDistribution with conversion ID and hash (contract pulls tokens)

10. You process batches using processBatch (for conversions with >200 recipients)

11. You call finalizeDistribution to complete the distribution

12. Contract transfers ReplyCorp fee immediately, then distributes commission to referrers in batches

Integration flow (Non-Fee Router Path):

1. After a successful purchase → record conversion with amount field

2. Call conversion API with conversion data

3. ReplyCorp calculates attribution percentages from amount (or totalVolume if provided)

4. ReplyCorp returns API response with conversion ID and attribution data

5. Store the complete API response in your database

6. Later (weekly/monthly/on-demand), calculate payouts from stored attribution data

7. Distribute fees using your own payment system or smart contract

Code Example:

// After a user purchases $100 worth of tokens
const grossRevenue = 100.00; // totalVolume
const platformFees = 5.00;
const gasFees = 2.00;
const costOfGoods = 10.00;
const netProfit = grossRevenue - platformFees - gasFees - costOfGoods; // $83
const commission = 20.00; // Amount to distribute to referrers

// Record conversion with all financial fields
const conversionResponse = await fetch('https://prod.api.replycorp.io/api/v1/campaigns/{campaignId}/conversions', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    twitterId: '1234567890',
    eventType: 'purchase',
    totalVolume: grossRevenue,
    netProfit: netProfit,
    commission: commission,
    walletAddress: '0x...'
  })
});

const result = await conversionResponse.json();
const conversionId = result.conversion.id;
const feeDistribution = result.feeDistribution;

// Verify attribution hash before proceeding
const distributionRoute = await feeRouterContract.getDistributionRoute(conversionId);
if (distributionRoute.attributionHash !== feeDistribution.attributionHash) {
  throw new Error('Attribution hash mismatch');
}

// Approve contract to spend tokens
await tokenContract.approve(feeRouterContractAddress, feeDistribution.totalToSendToContract);

// Start distribution (contract pulls tokens)
await feeRouterContract.startDistribution(
  conversionId,
  feeDistribution.totalToSendToContract,
  feeDistribution.attributionHash
);

// Process batches (for conversions with >200 recipients)
const batchCount = await feeRouterContract.getBatchCount(conversionId);
for (let batchIndex = 0; batchIndex < batchCount; batchIndex++) {
  const isCompleted = await feeRouterContract.isBatchCompleted(conversionId, batchIndex);
  if (!isCompleted) {
    await feeRouterContract.processBatch(conversionId, batchIndex);
  }
}

// Finalize distribution
await feeRouterContract.finalizeDistribution(conversionId);

Code Example (Non-Fee Router Path):

// After a user purchases $100 worth of tokens
const purchaseAmount = 100.00;

// Record conversion (simple amount field)
const conversionResponse = await fetch('https://prod.api.replycorp.io/api/v1/campaigns/{campaignId}/conversions', {
  method: 'POST',
  headers: {
    'X-API-Key': 'your-api-key',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    twitterId: '1234567890',
    eventType: 'purchase',
    amount: purchaseAmount,
    walletAddress: '0x...'
  })
});

const result = await conversionResponse.json();
const conversionId = result.conversion.id;

// Store the complete API response for later distribution
await db.conversions.create({
  data: {
    conversionId: conversionId,
    campaignId: campaignId,
    conversionValue: result.conversion.conversionValue,
    convertedAt: result.conversion.convertedAt,
    attributionData: result.attribution, // Store full attribution data
    distributionStatus: 'pending'
  }
});

// Later, when ready to distribute (e.g., weekly batch):
// 1. Query all pending conversions
// 2. Calculate payouts from stored attribution data
// 3. Distribute using your own payment system
// See section 2.5 for detailed payout calculation examples

What ReplyCorp handles automatically:

• Attribution calculation (who influenced the conversion)

• Contract updates with attribution data (before API response) - only when fee router contract is configured

• Network graph tracking

---

EXAMPLE COMPLETE INTEGRATION FLOW: CEX SCENARIO

This example walks through a complete integration flow for a CEX (Centralized Exchange) scenario to illustrate how all the pieces fit together.

Scenario Setup:

• User buys $100 of tokens on your platform (totalVolume)

• Platform fees (2% transaction fee): $2

• Net profit: $2 (platform fees = your revenue)

• Commission: $0.40 (Assuming 20% commission of net profit = 20% × $2)

• ReplyCorp fee: $0.10 (5% of net profit = 5% × $2)

Integration Flow:

1. When the transaction happens, you call our API with:

   • User's X ID

   • totalVolume = $100

   • netProfit = $2

   • commission = $0.40

2. ReplyCorp's API responds telling you to send $0.50 total to the fee router contract, which would then route $0.40 to referrers, and $0.10 to ReplyCorp.

3. You send the funds to the contract using startDistribution(), processBatch(), and finalizeDistribution() as described in section 2.

This example demonstrates how totalVolume represents the user's purchase amount, netProfit is your actual revenue (platform fees), commission is the portion you allocate for referral rewards, and how ReplyCorp calculates its fee from your net profit.

---

What You DON'T Need to Build

ReplyCorp handles all of this automatically:

• ✅ Twitter/X stream monitoring - We track mentions, replies, and engagement

• ✅ Network graph construction - We map who influenced whom

• ✅ Attribution calculations - We determine which referrers drove conversions

• ✅ Points distribution - We calculate and distribute points automatically

• ✅ Participant onboarding - Users join automatically when they engage on Twitter

---

Integration Checklist

Pre-Integration (Before Starting)

• Contact ReplyCorp to request API access

• Have your Twitter/X handle ready (what you want to track)

• Identify where conversions happen in your system

• Determine if you have Twitter IDs for your users

Integration Steps

• Log into admin panel and retrieve API key and campaign ID (15-30 minutes)

• Enter contract parameters in admin panel (chain, token address, revenue share %)

• ReplyCorp fee percentage is set by ReplyCorp when creating your account

• Deploy smart contract (2-4 hours)

  • Receive contract code from ReplyCorp

  • Deploy contract with parameters from admin panel

  • Test contract deployment and basic interactions

• Add conversion tracking API call (2-4 hours)

  • Identify conversion events in your codebase

  • Map users to Twitter IDs (if needed)

  • Implement net profit calculation (gross revenue minus all costs)

  • Add API call after each conversion with net profit amount

  • Extract conversion ID from response

  • Integrate contract distribution check and fee sending

  • Test end-to-end flow: API call → contract check → fee distribution

Post-Integration

• Test with real conversions

• Monitor attribution results

• Adjust campaign settings as needed

---

Technical Requirements

What you must have:

• Ability to make HTTP requests (any language/framework)

• Access to user's Twitter/X ID when conversions occur

• Basic understanding of REST APIs

• Smart contract deployment capability

• Web3 wallet/account for contract deployment

• Ability to interact with smart contracts (send transactions, read state)

What you don't need:

• Twitter API credentials (ReplyCorp handles that)

• Database changes (ReplyCorp stores everything)

• Background workers (ReplyCorp processes in real-time)

• Complex infrastructure (ReplyCorp is the infrastructure)

---

Support & Resources

Documentation:

• Full API docs: See REPLYWEB_API_DOCUMENTATION.md (ReplyCorp API Documentation)

• Code examples: JavaScript, Python, PHP available

Support:

• Account Setup & Access: Contact ReplyCorp

• Technical Support: Email [email protected]

• Response time: Typically within 24 hours

Getting Started:

1. Contact ReplyCorp with your organization name and use case

2. ReplyCorp sets up your account

3. Log into the admin panel to retrieve your API key and campaign ID

4. Enter contract parameters in the admin panel (ReplyCorp fee percentage is set by ReplyCorp)

5. Follow the integration steps above

6. Test with sample data

7. Go live!

---

Prerequisites

Before starting integration, ensure you have:

⚠️ CRITICAL Requirements:

• Funded distribution wallet: The wallet that calls startDistribution() must have sufficient ERC-20 token balance at the time of execution. The contract pulls tokens from this wallet to perform distributions. You can fund it in real time by routing conversion proceeds to it, or pre-fund it in advance and keep it topped up over time. See section 2 for details.

• Consistent token denomination: All financial data (totalVolume, netProfit, commission) posted to the API must be denominated in the same ERC20 token you're using for rewards. For example, if distributing USDC, all amounts must be in USDC units.

1. Twitter IDs for your users - You must be able to map users to their Twitter/X IDs when conversions occur. If you don't have this, add 1-2 hours to build the mapping.

2. Smart contract deployment capability - You must be able to deploy contracts to your chosen blockchain network and interact with them programmatically.

3. Contract parameters - You must enter contract parameters in the admin panel before deployment:

   • Blockchain network (chain)

   • Token address for fee distribution

   • Revenue share percentage

   • ReplyCorp fee percentage (set by ReplyCorp when creating your account)

4. Net profit calculation capability - You must be able to calculate net profit for each conversion (gross revenue minus all costs). The amount field in conversion API calls must always be net profit, as this determines the referral fees that will be distributed.

---

Bottom Line: Most integrations take 6-8 hours of development time. The integration requires: (1) entering contract parameters in the admin panel (chain, token address, revenue share %) and deploying a smart contract, (2) calling the conversion API which automatically updates your contract with attribution data, and (3) checking the contract and sending fees for distribution. ReplyCorp handles all the complex parts (Twitter monitoring, attribution calculation, contract updates, fee percentage configuration). If you can deploy smart contracts, make HTTP requests, and have access to Twitter IDs, you're ready to integrate.

---

Last Updated: February 2026