Getting Started

Get up and running with ObscuraProof in minutes. This guide walks you through the essential steps to start verifying your sustainability metrics with privacy-preserving technology.

Quick Start for Enterprises

Start with our 30-day free enterprise trial:

# Visit our platform
https://app.obscuraproof.com/signup

# Or use CLI
curl -X POST https://api.obscuraproof.com/v1/trial \
  -H "Content-Type: application/json" \
  -d '{
    "company": "Your Company Name",
    "email": "contact@company.com",
    "employees": 5000
  }'

You'll receive:

Trial API key
Dashboard access
1,000 free verifications
Full feature access

Connect Your First Data Source

Choose from multiple connection methods:

Option A: Upload CSV

// Simple CSV upload for testing
const data = await obscura.upload({
  file: 'sustainability_metrics.csv',
  type: 'emissions_data',
  period: '2025-Q3'
});

Option B: API Integration

// Connect via API
const connection = await obscura.connect({
  type: 'rest_api',
  endpoint: 'https://your-api.com/metrics',
  authentication: 'bearer_token'
});

Option C: Database Connection

-- Direct database connection
CREATE READ USER FOR obscura_platform;
GRANT SELECT ON metrics_table TO obscura_platform;

Generate Your First Proof

Create a privacy-preserving proof of your sustainability metrics:

// Generate carbon neutrality proof
const proof = await obscura.createProof({
  metric: 'carbon_neutrality',
  data: {
    emissions: 15000, // tons CO2
    offsets: 16000   // tons CO2 offset
  },
  period: '2025-Q3'
});

console.log('Proof ID:', proof.id);
console.log('Status:', proof.verified ? 'Verified' : 'Pending');

View Results in Dashboard

Access your sustainability intelligence dashboard:

Navigate to app.obscuraproof.com
View verification status
Check benchmark position
Review AI recommendations

Dashboard Features:

Real-time verification status
Industry benchmarking
AI-powered insights
Compliance reports

For Developers

Install SDK

Choose your preferred language:

JavaScript/TypeScript

npm install @obscuraproof/sdk
# or
yarn add @obscuraproof/sdk

Python

pip install obscuraproof

go get github.com/obscuraproof/sdk-go

Initialize Client

Set up the ObscuraProof client:

import { ObscuraProof } from '@obscuraproof/sdk';

const client = new ObscuraProof({
  apiKey: process.env.OBSCURA_API_KEY,
  environment: 'production', // or 'sandbox'
  region: 'us-east-1' // or 'eu-west-1'
});

// Test connection
const status = await client.healthCheck();
console.log('API Status:', status); // Should return "healthy"

Create Custom Circuit

Build a custom verification circuit for your specific needs:

// Define custom sustainability metric
const customCircuit = client.createCircuit({
  name: 'water_efficiency',
  inputs: {
    private: ['consumption', 'recycled', 'sources'],
    public: ['period', 'facility_id']
  },
  logic: `
    efficiency = recycled / consumption;
    return efficiency > 0.5; // 50% recycling target
  `
});

// Use the custom circuit
const proof = await client.prove({
  circuit: customCircuit,
  data: {
    consumption: 100000, // liters
    recycled: 60000,    // liters
    sources: ['municipal', 'rainwater']
  }
});

Integrate with Your App

Add ObscuraProof to your application:

// Express.js example
app.post('/api/sustainability/verify', async (req, res) => {
  try {
    const { metric, data } = req.body;
    
    // Generate proof
    const proof = await client.createProof({
      metric: metric,
      data: data
    });
    
    // Get benchmarking data
    const benchmark = await client.getBenchmark({
      industry: 'manufacturing',
      metric: metric
    });
    
    // Get AI recommendations
    const recommendations = await client.getRecommendations({
      currentMetrics: data,
      targetImprovement: 20 // 20% improvement
    });
    
    res.json({
      verified: proof.verified,
      proofId: proof.id,
      benchmark: benchmark,
      recommendations: recommendations
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

Enterprise Implementation Patterns

Comprehensive Carbon Footprint Verification

// Verify comprehensive GHG Protocol compliance
const carbonProof = await client.createProof({
  circuit: 'ghg_protocol',
  data: {
    scope1: 5000,  // Direct emissions (tons CO2e)
    scope2: 3000,  // Indirect energy (tons CO2e)
    scope3: 12000, // Value chain (tons CO2e)
    offsets: 20000 // Verified carbon credits
  },
  metadata: {
    standard: 'GHG Protocol Corporate Standard',
    auditor: 'Third-party verified',
    period: '2025-FY'
  }
});

Supply Chain Sustainability Verification

// Verify supply chain sustainability compliance
const supplyChainProof = await client.createProof({
  circuit: 'sustainable_supply_chain',
  data: {
    suppliers: [
      { id: 'sup_001', score: 85, certified: true, tier: 1 },
      { id: 'sup_002', score: 92, certified: true, tier: 1 },
      { id: 'sup_003', score: 78, certified: false, tier: 2 }
    ],
    threshold: 80, // Minimum sustainability score
    coverage: 0.95 // 95% of spend covered
  }
});

Renewable Energy Verification

// Prove renewable energy percentage compliance
const energyProof = await client.createProof({
  circuit: 'renewable_energy_verification',
  data: {
    totalConsumption: 1000000, // kWh annual
    renewableSources: {
      solar: 400000,   // kWh from solar
      wind: 300000,    // kWh from wind  
      hydro: 100000    // kWh from hydro
    },
    certificates: ['REC_2025_001', 'REC_2025_002']
  },
  claim: 'minimum_80_percent_renewable_target'
});

API Rate Limits

Different tiers have different rate limits:

Tier	Requests/Hour	Concurrent Proofs	Data Storage
Trial	100	5	1 GB
Basic	1,000	20	10 GB
Professional	10,000	100	100 GB
Enterprise	Unlimited	Unlimited	Unlimited

Error Handling

Implement robust error handling:

try {
  const proof = await client.createProof(data);
} catch (error) {
  if (error.code === 'INVALID_DATA') {
    console.error('Data validation failed:', error.details);
  } else if (error.code === 'RATE_LIMIT') {
    console.error('Rate limit exceeded, retry after:', error.retryAfter);
  } else if (error.code === 'CIRCUIT_ERROR') {
    console.error('Circuit computation failed:', error.message);
  } else {
    console.error('Unexpected error:', error);
  }
}

Testing in Sandbox

Use our sandbox environment for development:

// Sandbox configuration
const sandboxClient = new ObscuraProof({
  apiKey: 'sk_test_...', // Test API key
  environment: 'sandbox',
  debug: true // Enable debug logging
});

// Generate test data
const testData = sandboxClient.generateTestData({
  metric: 'carbon_footprint',
  scenario: 'carbon_neutral' // or 'high_emissions', 'improving'
});

// Create test proof
const testProof = await sandboxClient.createProof({
  circuit: 'carbon_neutrality',
  data: testData
});

Webhook Integration

Set up webhooks for real-time updates:

// Configure webhook endpoint
await client.webhooks.create({
  url: 'https://your-app.com/webhooks/obscura',
  events: [
    'proof.created',
    'proof.verified',
    'benchmark.updated',
    'recommendation.generated'
  ]
});

// Handle webhook events
app.post('/webhooks/obscura', (req, res) => {
  const event = req.body;
  
  switch(event.type) {
    case 'proof.verified':
      // Handle verification completion
      console.log('Proof verified:', event.data.proofId);
      break;
    case 'benchmark.updated':
      // Handle benchmark updates
      console.log('New benchmark data:', event.data);
      break;
  }
  
  res.status(200).send('OK');
});

Next Steps

You're Ready to Go!

You now have everything needed to start using ObscuraProof:

✓ Account created
✓ SDK installed
✓ First proof generated
✓ Dashboard access

Explore Further:

You now have the foundation to implement ObscuraProof in your enterprise environment. The platform provides comprehensive sustainability intelligence through verified metrics, anonymous benchmarking, and AI-powered optimization recommendations that transform how organizations approach ESG reporting.

On this page