Quick Start Guide

Get your first stablecoin allocation deployed and earning yield in under 10 minutes.

Prerequisites

Before you begin, ensure you have:

RebelFi account (Request demo to get started)
Stablecoin balance to deploy (minimum $100 USDC recommended for testing)
Custody solution or ability to sign transactions

Step 1: Dashboard Setup (3 minutes)

No-Code Option Available: RebelFi’s dashboard provides a complete interface for managing wallets, operations, and yield without writing any code. Perfect for getting started before migrating to API-based automation.

Create Your Account & Configure Custody

Log into your RebelFi dashboard
Navigate to Settings → Organization
Review your organization configuration

Connect Your Custody Solution

This is the “connection” between RebelFi and your custody infrastructure.

Navigate to Custody Settings

Go to Settings → Custody Platform in the dashboard

Choose Integration Type

Select how you want RebelFi to integrate with your custody:

Agent Polling - Use RebelFi’s agent or deploy your own
Direct API - Provide custody API credentials (Fireblocks, BitGo, etc.)
Custom Adapter - Contact us to build custom integration

Configure Connection

Follow the setup wizard based on your chosen integration type. You may need:

API credentials from your custody provider
Wallet addresses to monitor
Policy/approval configurations

Generate API Key (Optional)

API keys are only needed if you plan to use RebelFi’s APIs or run your own agent. Many users operate entirely through the dashboard.

Navigate to API Keys

Go to Settings → API Keys in the dashboard

Generate New Key

Click Generate API Key and provide a descriptive name

{
  name: "Production Agent"
}

Save Your Key

Copy and securely store your API key. It will only be shown once.

# Store in environment variable
export REBELFI_API_KEY="rfk_live_xxxxxxxxxxxxx"

Treat API keys like passwords. Never commit them to version control or share them publicly.

Step 2: Add Your First Wallet (3 minutes)

Connect a Custody Wallet

Agent-Based Custody
Quick Test (No Custody)

If you’re using Fireblocks, BitGo, Privy, or a custom custody solution:

Navigate to Wallets in the dashboard
Click Add Wallet
Select your blockchain (e.g., Solana)
Enter wallet details:
- Wallet address
- Label (for your reference)
- Custody provider

The wallet will be added to your organization. Next, you’ll set up monitoring.

Enable Monitoring

Once your wallet is added, configure it for yield optimization:

Open Wallet Settings

Click on your wallet → Enable Monitoring

Configure Buffer

Set your buffer amount (funds kept liquid for operational needs):

{
  enableYield: true,
  bufferAmount: "1000.00", // Keep $1,000 USDC liquid
  token: "USDC"
}

RebelFi will automatically optimize funds above the buffer.

Save Configuration

Click Save to activate monitoringThe wallet is now monitored and ready for yield deployment.

Step 3: Agent Setup (Optional)

Dashboard Users: If you’re using the RebelFi dashboard with our managed agent or direct API integration, you can skip this step. The agent is only needed if you want to run your own polling service.

Option A: Use RebelFi’s Managed Agent

The simplest option—RebelFi runs the agent for you:

During custody setup (Step 1), select “Use RebelFi Agent”
Provide your custody API credentials securely
RebelFi’s agent polls, signs using your custody, and executes operations
Monitor activity in the dashboard

No additional setup required!

Option B: Run Your Own Agent

For maximum control, deploy your own agent that polls RebelFi APIs:

Understand the Agent APIs

Your agent needs to call two endpoints:

POST /api/agent/transactions/poll - Get unsigned transactions to sign
POST /api/agent/transactions/:id/report - Submit signed transaction or report txid

See the Agent API Reference for full details.

Implement Polling Logic

// Basic polling loop
async function pollAndExecute() {
const {data} = await fetch('https://api.rebelfi.io/api/agent/transactions/poll', {
method: 'POST',
headers: {'X-API-Key': process.env.REBELFI_API_KEY},
body: JSON.stringify({leaseDurationMs: 30000})
});

if (data.transaction) {
// Sign with your custody solution
const signedTx = await custodySolution.sign(data.transaction.unsignedTx);

// Submit to blockchain or report txid
const txHash = await blockchain.submit(signedTx);

// Report back
await fetch(`https://api.rebelfi.io/api/agent/transactions/${data.transaction.id}/report`, {
method: 'POST',
headers: {'X-API-Key': process.env.REBELFI_API_KEY},
body: JSON.stringify({status: 'SUBMITTED', txHash})
});
}
}

// Poll every 10-30 seconds
setInterval(pollAndExecute, 10000);

Deploy & Monitor

Deploy your agent to your infrastructure and monitor logs to verify successful polling and execution.

Complete agent implementation examples and deployment patterns are available in the Custody Integration Guide.

Step 4: Deploy Your First Allocation (2 minutes)

Now that your wallet is monitored and agent is running, let’s deploy funds to yield!

Option A: Automatic Deployment

If you have sufficient funds above your buffer, RebelFi will automatically:

Detect the opportunity
Create a supply operation
Queue it for execution
Your agent will poll, sign, and submit

Simply wait a minute and check your dashboard:

# Or check via API
curl https://api.rebelfi.io/api/v1/allocations \
  -H "Authorization: Bearer YOUR_API_KEY"

Option B: Manual Deployment via API

Trigger a specific allocation:

// Using TypeScript/JavaScript
const response = await fetch('https://api.rebelfi.io/api/v1/allocations', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    managedWalletId: 123, // Your wallet ID
    amount: "500.00",
    asset: "USDC"
  })
});

const result = await response.json();
console.log('Reservation created:', result.reservationId);
console.log('Operation ID:', result.bundleId);

# Using cURL
curl -X POST https://api.rebelfi.io/api/v1/allocations \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "managedWalletId": 123,
    "amount": "500.00",
    "asset": "USDC"
  }'

The API returns immediately with a reservation ID and operation ID. The actual execution happens asynchronously via your agent.

Track Operation Progress

Monitor your operation:

// Get operations queue
const queue = await fetch('https://api.rebelfi.io/api/core/operations/queue', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

// Get operation history
const history = await fetch('https://api.rebelfi.io/api/core/operations/history?limit=10', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

Step 5: Verify & Monitor

Your allocation should complete within 1-2 minutes (depending on blockchain confirmation times).

Check Allocation Status

// List all allocations
const allocations = await fetch('https://api.rebelfi.io/api/v1/allocations', {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

const data = await allocations.json();
console.log('Active allocations:', data.allocations);
console.log('Portfolio summary:', data.portfolioSummary);

Dashboard Visibility

In your RebelFi dashboard:

Wallets tab shows current balances (available, deployed)
Operations tab shows operation history
Allocations tab shows active yield positions

Yield accrues in real-time. Check your allocation details to see current value and earnings.

What You’ve Accomplished

✅ Account Setup

Created your RebelFi account and generated API keys

✅ Wallet Integration

Connected your custody wallet and enabled monitoring

✅ Agent Deployment

Deployed and configured your custody agent for automated execution

✅ First Allocation

Created and deployed your first yield-earning allocation

✅ Monitoring Setup

Set up real-time tracking of operations and allocations

Next Steps

Custody Integration

Deep dive into custody adapter configuration for production

API Documentation

Explore the complete API reference

Use Case Examples

See how other companies integrate RebelFi

Understanding Operations

Learn about the operation lifecycle and architecture

Troubleshooting

Agent not picking up transactions

Check:

Agent logs show successful polling (200 responses)
API key has correct scopes (agent, wallets, operations)
Network connectivity to api.rebelfi.io
Operation status is not PENDING_APPROVAL (approve it first)

Solution:

# Check agent logs
docker logs rebelfi-agent

# Verify API key
curl https://api.rebelfi.io/api/core/apikeys/validate \
  -H "X-API-Key: YOUR_API_KEY"

Insufficient balance errors

Check:

Wallet has enough funds above buffer amount
Funds are not already reserved by another operation
Token balance is for the correct asset (USDC, etc.)

Solution:

// Check wallet balance
const response = await fetch(`https://api.rebelfi.io/api/core/wallets/{id}/balances`, {
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
});

Operation stuck in EXECUTING

Possible causes:

Agent is not running or not polling
Custody signing failed
Blockchain congestion (transaction pending)

Solution: Check agent logs and blockchain explorer for transaction status

Need Help?

Join our Discord or email support@rebelfi.io

Getting Started

Integration

Use Cases

Quick Start Guide

Prerequisites

Step 1: Dashboard Setup (3 minutes)

Create Your Account & Configure Custody

Connect Your Custody Solution

Generate API Key (Optional)

Step 2: Add Your First Wallet (3 minutes)

Connect a Custody Wallet

Enable Monitoring

Step 3: Agent Setup (Optional)

Option A: Use RebelFi’s Managed Agent

Option B: Run Your Own Agent

Step 4: Deploy Your First Allocation (2 minutes)

Option A: Automatic Deployment

Option B: Manual Deployment via API

Track Operation Progress

Step 5: Verify & Monitor

Check Allocation Status

Dashboard Visibility

What You’ve Accomplished

Next Steps

Custody Integration

API Documentation

Use Case Examples

Understanding Operations

Troubleshooting

Need Help?

Getting Started

Integration

Use Cases

​Prerequisites

​Step 1: Dashboard Setup (3 minutes)

​Create Your Account & Configure Custody

​Connect Your Custody Solution

​Generate API Key (Optional)

​Step 2: Add Your First Wallet (3 minutes)

​Connect a Custody Wallet

​Enable Monitoring

​Step 3: Agent Setup (Optional)

​Option A: Use RebelFi’s Managed Agent

​Option B: Run Your Own Agent

​Step 4: Deploy Your First Allocation (2 minutes)

​Option A: Automatic Deployment

​Option B: Manual Deployment via API

​Track Operation Progress

​Step 5: Verify & Monitor

​Check Allocation Status

​Dashboard Visibility

​What You’ve Accomplished

​Next Steps

Custody Integration

API Documentation

Use Case Examples

Understanding Operations

​Troubleshooting

Need Help?

Prerequisites

Step 1: Dashboard Setup (3 minutes)

Create Your Account & Configure Custody

Connect Your Custody Solution

Generate API Key (Optional)

Step 2: Add Your First Wallet (3 minutes)

Connect a Custody Wallet

Enable Monitoring

Step 3: Agent Setup (Optional)

Option A: Use RebelFi’s Managed Agent

Option B: Run Your Own Agent

Step 4: Deploy Your First Allocation (2 minutes)

Option A: Automatic Deployment

Option B: Manual Deployment via API

Track Operation Progress

Step 5: Verify & Monitor

Check Allocation Status

Dashboard Visibility

What You’ve Accomplished

Next Steps

Troubleshooting