Docs/Core Concepts/Credits Credit System
AgenticAnts uses a flexible, usage-based credit system that scales with your needs.
What are Credits?
Credits are AgenticAnts' unit of measurement for platform usage. Think of credits like cloud compute units - they represent the resources consumed by your AI operations.
Why Credits?
- Flexibility: Use credits across all platform features
- Predictability: Know costs before you commit
- Scalability: Pay for what you use
- Simplicity: One unit for all operations
How Credits Work
Credit Allocation
Credits are included with your plan and can be purchased additionally:
Pro Plan: $49/month
├─ 100,000 credits included
├─ Additional credits: $5 per 1,000
└─ No expiration within billing cycle
Enterprise Plan: Custom pricing
├─ Custom credit allocation
├─ Volume discounts available
└─ Dedicated support included
Credit Consumption
Different operations consume different amounts of credits:
| Operation | Credits per Unit | Example |
|---|
| Trace Ingestion | 1 per 1,000 traces | 5,000 traces = 5 credits |
| Span Ingestion | 0.1 per 1,000 spans | 10,000 spans = 1 credit |
| Metric Data Points | 0.05 per 1,000 points | 20,000 points = 1 credit |
| Data Storage | 5 per GB/month | 10 GB = 50 credits/month |
| API Requests | 0.5 per 1,000 requests | 2,000 requests = 1 credit |
| Evaluation Runs | 2 per 1,000 evaluations | 500 evaluations = 1 credit |
ℹ
Actual Usage: Your credit consumption depends on your actual usage patterns. Most teams use 5,000-15,000 credits per month.
Usage Examples
Example 1: Small Team
Profile: 5 developers, 3 AI agents, development and staging
Monthly Usage:
├─ Traces: 50,000 (50 credits)
├─ Spans: 200,000 (20 credits)
├─ Metrics: 100,000 (5 credits)
├─ Storage: 2 GB (10 credits)
└─ API calls: 10,000 (5 credits)
Total: 90 credits/month
Cost: $49/month (Pro plan with 100,000 credits)
Example 2: Growing Startup
Profile: 20 developers, 10 AI agents, production workload
Monthly Usage:
├─ Traces: 500,000 (500 credits)
├─ Spans: 2,000,000 (200 credits)
├─ Metrics: 1,000,000 (50 credits)
├─ Storage: 20 GB (100 credits)
└─ API calls: 100,000 (50 credits)
Total: 900 credits/month
Cost: $49 (Pro) + $0 (under 100,000 credits)
Example 3: Enterprise
Profile: 100+ developers, 50+ agents, high-volume production
Monthly Usage:
├─ Traces: 10,000,000 (10,000 credits)
├─ Spans: 50,000,000 (5,000 credits)
├─ Metrics: 20,000,000 (1,000 credits)
├─ Storage: 500 GB (2,500 credits)
└─ API calls: 5,000,000 (2,500 credits)
Total: 21,000 credits/month
Cost: Custom Enterprise pricing
Monitoring Credit Usage
Real-Time Dashboard
View your credit consumption in real-time:
// Get current usage
const usage = await ants.credits.getCurrentUsage()
console.log(`Credits used: ${usage.used}`)
console.log(`Credits remaining: ${usage.remaining}`)
console.log(`Reset date: ${usage.resetDate}`)
console.log(`Usage by category:`)
console.log(` Traces: ${usage.breakdown.traces} credits`)
console.log(` Metrics: ${usage.breakdown.metrics} credits`)
console.log(` Storage: ${usage.breakdown.storage} credits`)
Usage Alerts
Set up alerts for credit consumption:
# Alert when 70% of credits are consumed
ants.credits.create_alert({
'threshold': 0.7,
'type': 'warning',
'channels': ['email', 'slack']
})
# Alert when 90% of credits are consumed
ants.credits.create_alert({
'threshold': 0.9,
'type': 'critical',
'channels': ['email', 'slack', 'pagerduty']
})
Usage Analytics
Analyze credit consumption patterns:
// Get usage trends
const trends = await ants.credits.getTrends({
period: 'last_30_days',
groupBy: 'day'
})
// Identify top consumers
const topConsumers = await ants.credits.getTopConsumers({
period: 'last_7_days',
limit: 10
})
// Project future usage
const projection = await ants.credits.projectUsage({
basedOn: 'last_30_days',
projectFor: '90_days'
})
Credit Optimization
Tips to Reduce Credit Usage
1. Sampling
Don't trace everything - use intelligent sampling:
const ants = new AgenticAnts({
apiKey: process.env.AGENTICANTS_API_KEY,
sampling: {
rate: 0.1, // Sample 10% of traces
strategy: 'head-based', // Decide at trace start
rules: [
// Always sample errors
{ condition: 'error', rate: 1.0 },
// Always sample slow requests
{ condition: 'duration > 5s', rate: 1.0 },
// Sample 50% of specific users
{ condition: 'user = "test_user"', rate: 0.5 }
]
}
})
2. Data Retention
Configure appropriate retention periods:
# Set retention policies
ants.config.set_retention({
'traces': '30_days', # Keep traces for 30 days
'metrics': '90_days', # Keep metrics for 90 days
'logs': '7_days', # Keep logs for 7 days
'raw_data': '24_hours' # Keep raw data for 24 hours
})
3. Batch Processing
Batch operations to reduce API calls:
// Instead of individual calls
for (const trace of traces) {
await ants.trace.create(trace) // 1 API call per trace
}
// Batch them
await ants.trace.createBatch(traces) // 1 API call for all
4. Compression
Enable compression for data transfer:
ants = AgenticAnts(
api_key=os.getenv('AGENTICANTS_API_KEY'),
compression='gzip', # Enable compression
batch_size=100 # Batch traces
)
5. Selective Instrumentation
Only instrument what matters:
// Don't trace everything
if (shouldTrace(request)) {
const trace = await ants.trace.create({ /* ... */ })
}
function shouldTrace(request) {
// Skip health checks
if (request.path === '/health') return false
// Skip internal requests
if (request.internal) return false
// Trace production traffic
if (request.env === 'production') return true
// Sample development traffic
return Math.random() < 0.1
}
Purchasing Credits
Additional Credits
Need more credits? Purchase them as needed:
# Via Dashboard
1. Go to Settings → Billing
2. Click "Purchase Credits"
3. Select quantity (1,000 to 1,000,000 credits)
4. Complete payment
Volume Discounts
Bulk purchases receive discounts:
| Credits | Price per 1,000 | Discount |
|---|
| 1,000 - 9,999 | $5.00 | 0% |
| 10,000 - 49,999 | $4.50 | 10% |
| 50,000 - 99,999 | $4.00 | 20% |
| 100,000+ | $3.50 | 30% |
Enterprise Agreements
Custom credit packages for enterprise needs:
Enterprise Benefits:
├─ Custom credit allocation
├─ Flexible payment terms
├─ Volume discounts
├─ Dedicated support
├─ SLA guarantees
└─ Custom retention policies
Credit Rollover
Monthly Plans
- Credits reset at the start of each billing cycle
- Unused credits do not roll over (Scale plan)
- Purchase additional credits anytime
Enterprise Plans
- Flexible rollover policies
- Annual credit pools
- Custom terms available
Fair Use Policy
AgenticAnts credits are subject to fair use:
Normal Use
- Monitoring production AI agents
- Development and testing
- Reasonable API usage
- Standard data retention
Not Allowed
- Reselling credits
- Mining or scraping data
- Excessive API hammering
- Storing non-agent data
⚠
Fair Use: Unusual usage patterns may be flagged for review. Contact support if you have questions about your use case.
Credit FAQs
Do credits expire?
Monthly plan credits reset each billing cycle. Enterprise plans can have custom terms.
Can I transfer credits?
No, credits are non-transferable between accounts.
What happens if I run out?
Your data collection pauses until credits are added or the billing cycle resets. Historical data remains accessible.
Can I get a refund?
Monthly subscription fees are non-refundable. Unused purchased credits can be refunded within 30 days.
How do I estimate my needs?
Start with the Scale plan and monitor your usage for a month. We'll help you optimize or upgrade as needed.
Monitoring Best Practices
Set Budgets
await ants.budgets.create({
name: 'Monthly Credit Budget',
credits: 10000,
period: 'monthly',
alerts: [
{ at: 7000, notify: 'slack' }, // 70%
{ at: 9000, notify: 'email' } // 90%
]
})
Review Weekly
Check your credit usage every week:
# Weekly usage report
report = ants.credits.get_weekly_report()
print(f"This week: {report.current_week} credits")
print(f"Last week: {report.last_week} credits")
print(f"Change: {report.change_percent}%")
Optimize Continuously
// Get optimization recommendations
const recommendations = await ants.credits.getOptimizations()
for (const rec of recommendations) {
console.log(`${rec.title}: Save ${rec.potentialSavings} credits/month`)
console.log(`Action: ${rec.action}`)
}
Next Steps