Skip to main content
This section provides practical, step-by-step guides for each role in the Centrix network.

​
For Providers

Providers are hardware owners who monetize idle computing resources through the Centrix network. By running a provider node, you can earn CXT tokens passively.

​
Getting Started as a Provider

System Requirements
  • Minimum: 4-core CPU, 8GB RAM, 100GB storage, 100 Mbps Internet
  • Recommended: 16+ core CPU, 32GB+ RAM, 1TB+ SSD, 1 Gbps Internet
  • Optional: GPU (NVIDIA RTX 3060+) for higher earnings
  • OS: Linux (recommended), macOS, or Windows
Installation 
# Download and install Centrix Provider Node
curl -L https://centrix.network/install | bash

# Initialize your provider
centrix-provider init \
  --wallet 0x1234567890abcdef... \
  --cpu 16 \
  --memory 32000 \
  --storage 1000000

# Start the provider node
centrix-provider start
Configuration 
# ~/.centrix/provider.yml
hardware:
  cpu_cores: 16
  memory_mb: 32000
  storage_gb: 1000
  gpu_models:
    - NVIDIA RTX 3090
    - NVIDIA RTX 3080

pricing:
  cpu_per_core_hour: 0.50 CXT
  gpu_per_hour: 5.00 CXT
  storage_per_gb: 0.01 CXT

availability:
  schedule: "24/7"
  uptime_target: 99.5
Staking
  • Stake minimum 100 CXT as security deposit
  • Higher stakes = higher visibility and priority
  • Earn reputation faster with consistent performance
  • Slashed if dishonest (fraud penalties)

​
Earning Model

Revenue Sources:
  1. Task Execution (Primary income)
    • Earn 95% of task cost
    • Price set by market competition
    • Average: 500−500-5,000/month per provider
  2. Staking Rewards (Secondary income)
    • 5% protocol fee distributed to stakers
    • Annual yield: 20-40% (varies with network activity)
    • Automatic monthly distribution
  3. Reputation Bonuses (Premium tiers)
    • 5-star providers: 10% earnings multiplier
    • Guaranteed uptime: 5% bonus
    • Long-term commitment: additional 5% bonus
Example Earnings Scenario: 
Hardware: 16-core CPU, 32GB RAM, 1x RTX 3080
Pricing: $0.50/CPU hour, $5/GPU hour

Daily Activity:
- 20 CPU tasks: 50 hours @ $0.50 = $25
- 10 GPU tasks: 30 hours @ $5 = $150
- Daily Revenue: $175

Monthly: $5,250 + staking rewards = ~$5,350

​
Best Practices

Performance Optimization:
  • Monitor network latency (target: <50ms)
  • Maintain consistent uptime
  • Update software regularly
  • Scale resources based on demand
Reputation Building:
  • Complete tasks quickly and reliably
  • Maintain 99%+ success rate
  • Respond to customer queries promptly
  • Achieve 5-star ratings
Risk Management:
  • Start with conservative stake
  • Gradually increase capacity
  • Monitor system resources
  • Have backup internet connection
  • Regular data backups

​
For Requestors

Requestors purchase computational resources from the Centrix network. Submit any containerized task and access global computing capacity instantly.

​
Getting Started as a Requestor

Create Account
  • Visit centrix.network
  • Sign up with email or Web3 wallet
  • Verify email address
  • Set up payment method
Fund Your Account 
# Option 1: Direct CXT transfer
centrix wallet transfer \
  --to centrix-account:user@example.com \
  --amount 100 CXT

# Option 2: Swap stablecoins for CXT
# Via Uniswap, Curve, etc.

# Option 3: Credit card onramp
# Automatic conversion to CXT
Create Your First Task 
name: "Blender Render - My Scene"
description: "Render 100 frames of animated scene"

requirements:
  cpu_cores: 8
  memory_mb: 16000
  storage_gb: 100
  gpu: "NVIDIA RTX 3080+"
  duration_estimate: "2 hours"

input:
  files:
    - source: "s3://my-bucket/scene.blend"
      destination: "/input/scene.blend"
    - source: "local:textures/"
      destination: "/input/textures/"

execution:
  container: "centrix/blender:4.0"
  command: [
    "blender", "-b", "/input/scene.blend",
    "-o", "/output/frame_####",
    "-f", "1..100"
  ]

output:
  files:
    - source: "/output/frame_*.png"
      destination: "s3://my-bucket/output/"

verification:
  method: "redundant"
  redundancy_factor: 3
  threshold: 0.67

pricing:
  max_price: 50 CXT
  urgency: "normal"
Submit and Monitor 
# Submit task
centrix task submit task.yml

# Monitor progress
centrix task status <task-id>

# View real-time logs
centrix task logs <task-id> --follow

# Download results
centrix task download <task-id> --output ./results/

​
Task Types and Templates

Pre-built Templates:
  • Blender Rendering - 3D model rendering, animations, batch jobs
  • AI/ML Training - PyTorch/TensorFlow support, distributed training
  • Video Processing - FFmpeg transcoding, GPU acceleration
  • Scientific Computing - Python/NumPy/SciPy, MATLAB compatibility
  • Data Analysis - SQL queries, statistical analysis, ETL pipelines
Custom Task Development: 
# Create custom task from Docker image
centrix task create-custom \
  --image "my-org/my-app:latest" \
  --name "custom-processing" \
  --cpu 8 \
  --memory 16000

# Test locally before submitting
centrix task test ./my-task.yml --local

​
Cost Optimization

Strategies for Lower Costs:
  1. Off-Peak Scheduling
    • Submit non-urgent tasks during low-demand periods
    • Price drops 30-50% during off-peak hours
    • Savings: 10−10-50 per task
  2. Batch Processing
    • Combine multiple small tasks into larger ones
    • Reduced per-task overhead
    • Better provider selection
    • Savings: 20% per task
  3. Provider Selection
    • New providers offer discounts (20-40%)
    • Still reliable with reputation system protection
    • Geographic optimization reduces latency fees
  4. Redundancy Configuration
    • Adjust redundancy for non-critical tasks
    • Use spot verification (30% of time)
    • Balance cost vs. security
Pricing Comparison: 
Traditional Cloud (AWS EC2):
- 8-core instance: $1.20/hour
- 100 hours: $120

Centrix Network:
- 8-core CPU @ $0.50/hour: $40
- Savings: 67%

With optimization:
- Off-peak discount: -30% = $28
- Total savings: 77%

​
For Developers

Developers build applications and services on top of Centrix. Integrate decentralized compute into your products.

​
SDK Integration

Installation 
# Node.js / JavaScript
npm install @centrix/sdk

# Python
pip install centrix-sdk

# Go
go get github.com/centrix/sdk-go
Basic Usage (JavaScript) 
import { Centrix } from '@centrix/sdk';

// Initialize client
const centrix = new Centrix({
  apiKey: process.env.CENTRIX_API_KEY,
  network: 'mainnet'
});

// Submit task
const task = await centrix.tasks.submit({
  name: 'Process Data',
  container: 'centrix/python:3.11',
  command: ['python', '/app/process.py'],
  resources: {
    cpu: 4,
    memory: 8000,
    storage: 50
  },
  input: { files: ['data.csv'] },
  pricing: { maxPrice: 10 }
});

// Monitor progress
task.on('started', () => console.log('Task started'));
task.on('progress', (pct) => console.log(`Progress: ${pct}%`));
task.on('completed', (results) => {
  console.log('Task completed!');
  console.log(results);
});

// Wait for completion
const results = await task.wait();
console.log(results);
Basic Usage (Python) 
from centrix import Centrix

# Initialize client
centrix = Centrix(api_key='YOUR_API_KEY')

# Submit task
task = centrix.tasks.submit(
    name='ML Training',
    container='centrix/pytorch:latest',
    command=['python', '/app/train.py'],
    resources={
        'cpu': 8,
        'memory': 16000,
        'gpu': 'NVIDIA RTX 3080'
    },
    input_files=['model.py', 'data.tar.gz'],
    max_price=50
)

# Monitor and retrieve results
for status in task.monitor():
    print(f'Status: {status}')

results = task.get_results()
print(f'Output files: {results["files"]}')

​
Advanced Features

Monitoring and Analytics: 
// Get task history
const history = await centrix.tasks.list({
  limit: 100,
  status: 'completed'
});

// Analyze costs
const analytics = await centrix.analytics.getCostBreakdown({
  period: '30d',
  groupBy: 'container'
});

// Monitor provider reputation
const provider = await centrix.providers.get(providerId);
console.log(`Reputation: ${provider.reputation.score}/5.0`);
console.log(`Success Rate: ${provider.reputation.successRate}%`);
Custom Verification: 
// Define custom verification
const task = await centrix.tasks.submit({
  // ... task config ...
  verification: {
    method: 'custom',
    function: async (result1, result2, result3) => {
      return result1.hash === result2.hash && 
             result2.hash === result3.hash;
    }
  }
});
Webhooks for Async Processing: 
// Register webhook
await centrix.webhooks.create({
  url: 'https://myapi.example.com/centrix-callback',
  events: ['task.completed', 'task.failed'],
  secret: 'webhook_secret_key'
});

// Backend receives webhook
app.post('/centrix-callback', (req, res) => {
  const { event, task_id, results } = req.body;
  
  if (event === 'task.completed') {
    processResults(task_id, results);
  }
  
  res.status(200).json({ ok: true });
});

​
Best Practices

Error Handling
  • Implement retry logic for transient failures
  • Set appropriate timeouts
  • Handle network interruptions gracefully
Resource Optimization
  • Right-size resource requests
  • Use task templates when possible
  • Batch related tasks efficiently
Security
  • Never hardcode API keys (use environment variables)
  • Validate task results before using
  • Implement access controls on webhooks
Testing
  • Test tasks locally before production
  • Use testnet for development
  • Implement monitoring and alerts