API Plateforme ePV ePV Platform API ePV Platform API API Piattaforma ePV

// Send binary audio data directly
ws.send(audioBlobData);

{
  "status": "active_transcription",
  "lines": [
    {
      "speaker": 0,
      "text": "Transcribed text segment",
      "start": "00:00:00.000",
      "end": "00:00:03.200"
    }
  ],
  "buffer_transcription": "",
  "buffer_diarization": "",
  "remaining_time_transcription": 0.0,
  "remaining_time_diarization": 0.0,
  "token_usage": {
    "tokens_consumed": 0.5,
    "base_tokens": 0.5,
    "diarization_tokens": 0.0,
    "voice_signature_tokens": 0.0,
    "llm_tokens": 0.0,
    "duration_minutes": 0.5,
    "billing_metadata": {}
  }
}

{
  "type": "end_session"
}

{
  "type": "ready_to_stop"
}

{
  "success": true,
  "signatures": [
    {
      "name": "John Doe",
      "embedding": [0.123, -0.456, 0.789, ...] // 512-dimensional vector
    },
    {
      "name": "Jane Smith",
      "embedding": [0.321, 0.654, -0.987, ...]
    }
  ],
  "count": 2
}

{
  "text": "Full transcription text",
  "segments": [
    {
      "text": "First segment",
      "speaker": 0,
      "start": "00:00:00.000",
      "end": "00:00:03.200"
    }
  ],
  "filename": "audio.wav",
  "duration": 15.3,
  "language": "fr",
  "diarization_enabled": true,
  "voice_signatures_used": false,
  "diarization_summary": {
    "total_segments": 5,
    "unique_speakers": 2,
    "speaker_durations": {
      "0": 8.5,
      "1": 6.8
    }
  },
  "speaker_info": {},
  "processing_mode": "sync",
  "token_usage": {
    "tokens_consumed": 0.5,
    "base_tokens": 0.25,
    "diarization_tokens": 0.125,
    "voice_signature_tokens": 0.0,
    "llm_tokens": 0.0,
    "duration_minutes": 0.255,
    "billing_metadata": {
      "filename": "audio.wav",
      "duration_seconds": 15.3,
      "num_segments": 5,
      "unique_speakers": 2,
      "processing_mode": "sync"
    }
  }
}

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "queued",
  "message": "Task submitted successfully. Use /transcribe/status/{task_id} to check progress.",
  "token_usage": {
    "tokens_consumed": 0.5,
    "base_tokens": 0.25,
    "diarization_tokens": 0.125,
    "voice_signature_tokens": 0.0,
    "llm_tokens": 0.0,
    "duration_minutes": 0.255,
    "billing_metadata": {
      "filename": "audio.wav",
      "task_id": "550e8400-e29b-41d4-a716-446655440000",
      "processing_mode": "async",
      "estimated": true
    }
  }
}

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "completed",
  "progress": 100,
  "current_step": "Completed successfully",
  "created_at": "2025-11-07T10:30:00Z",
  "started_at": "2025-11-07T10:30:01Z",
  "completed_at": "2025-11-07T10:31:45Z",
  "filename": "audio.wav",
  "duration": 104.5,
  "error": null
}

{
  "text": "Complete transcription text",
  "segments": [
    {
      "text": "Segment text",
      "speaker": 0,
      "start": "00:00:00.000",
      "end": "00:00:03.200"
    }
  ],
  "filename": "audio.wav",
  "duration": 120.5,
  "language": "fr",
  "diarization_enabled": true,
  "diarization_summary": {
    "total_segments": 25,
    "unique_speakers": 3,
    "speaker_durations": {
      "0": 45.2,
      "1": 38.7,
      "2": 36.6
    }
  },
  "speaker_info": {},
  "processing_mode": "background",
  "token_usage": {
    "tokens_consumed": 2.5,
    "base_tokens": 2.0,
    "diarization_tokens": 0.5,
    "voice_signature_tokens": 0.0,
    "llm_tokens": 0.0,
    "duration_minutes": 2.008,
    "billing_metadata": {
      "filename": "audio.wav",
      "duration_seconds": 120.5,
      "num_segments": 25,
      "unique_speakers": 3,
      "processing_mode": "background"
    }
  }
}

{
  "message": "Task cancelled successfully",
  "task_id": "550e8400-e29b-41d4-a716-446655440000"
}

{
  "active_connections_per_token": {
    "abc123...": 2,
    "def456...": 1
  },
  "total_active_connections": 3,
  "rate_limits": {
    "max_concurrent_per_token": 3,
    "max_per_minute_per_token": 10
  }
}

{
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful assistant."
    },
    {
      "role": "user",
      "content": "Summarize this meeting transcript..."
    }
  ],
  "model": "qwen3",
  "profile_type": "standard",
  "temperature": 1.0,
  "max_tokens": 2048,
  "stream": false
}

{
  "id": "chatcmpl-7890123456",
  "model": "qwen3",
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "Generated response text..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 45,
    "completion_tokens": 123,
    "total_tokens": 168
  }
}

const generateResponse = async (messages) => {
  try {
    const response = await fetch('https://api.mayorsoftware.ch/v1/llm/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer epv_your_token_here',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        messages: messages,
        model: 'qwen3',
        profile_type: 'standard',
        temperature: 1.0,
        stream: false
      })
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const result = await response.json();
    return result.choices[0].message.content;

  } catch (error) {
    console.error('LLM request failed:', error);
    return null;
  }
};

// Usage
const messages = [
  { role: 'system', content: 'You are a helpful assistant.' },
  { role: 'user', content: 'Write a short story about AI.' }
];
const response = await generateResponse(messages);
console.log(response);

const streamResponse = async (messages) => {
  try {
    const response = await fetch('https://api.mayorsoftware.ch/v1/llm/chat/completions', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer epv_your_token_here',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        messages: messages,
        model: 'qwen3',
        profile_type: 'standard',
        temperature: 1.0,
        stream: true
      })
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const reader = response.body.getReader();
    const decoder = new TextDecoder();
    let buffer = '';
    let fullText = '';

    while (true) {
      const { done, value } = await reader.read();
      if (done) break;

      const chunk = decoder.decode(value, { stream: true });
      buffer += chunk;
      const lines = buffer.split('\n');
      buffer = lines.pop() || '';

      for (const line of lines) {
        if (line.startsWith('data: ') && !line.includes('[DONE]')) {
          try {
            const data = JSON.parse(line.slice(6));
            if (data.choices && data.choices[0].delta.content) {
              const content = data.choices[0].delta.content;
              fullText += content;
              console.log(content); // Display token by token
            }
          } catch (e) {
            // Ignore parsing errors
          }
        }
      }
    }

    return fullText;

  } catch (error) {
    console.error('Streaming failed:', error);
    return null;
  }
};

// Using JWT token (from user login)
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

// OR using API token
Authorization: Bearer epv_1a2b3c4d5e6f7g8h9i0j...

{
  "current_period": {
    "start_date": "2025-11-01T00:00:00.000Z",
    "end_date": "2025-11-30T23:59:59.999Z",
    "transcription_minutes": 45.3,
    "llm_tokens": 12450,
    "cost": 23.75
  },
  "limits": {
    "transcription_minutes_limit": 100,
    "llm_tokens_limit": 50000,
    "plan": "professional"
  },
  "usage_history": [
    {
      "date": "2025-11-07",
      "transcription_minutes": 5.2,
      "llm_tokens": 850,
      "requests": 3
    }
  ],
  "transactions": [
    {
      "_id": "673...",
      "userId": "672...",
      "tokenId": "673...",
      "type": "deduction",
      "amount": 520,
      "serviceType": "transcription",
      "createdAt": "2025-11-07T14:23:45.000Z",
      "usageMetrics": {
        "duration": 5.2,
        "diarization": true
      }
    }
  ],
  "total": 125,
  "limit": 50,
  "offset": 0,
  "hasMore": true
}

const getUsageStats = async (apiToken) => {
  try {
    // Build query parameters
    const params = new URLSearchParams({
      limit: '30',  // Get last 30 days
      service_type: 'transcription'  // Filter for transcription only
    });

    const response = await fetch(`https://api.mayorsoftware.ch/v1/token-balance/usage?${params}`, {
      headers: {
        'Authorization': `Bearer ${apiToken}`  // Works with JWT or API token
      }
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const usage = await response.json();
    
    console.log('Current Period Usage:');
    console.log(`Transcription: ${usage.current_period.transcription_minutes} minutes`);
    console.log(`LLM Tokens: ${usage.current_period.llm_tokens}`);
    console.log(`Cost: $${usage.current_period.cost}`);
    
    console.log(`\nTotal transactions: ${usage.total}`);
    console.log(`Showing ${usage.transactions.length} transactions`);
    
    // Display usage history
    usage.usage_history.forEach(day => {
      console.log(`${day.date}: ${day.requests} requests, ${day.transcription_minutes.toFixed(2)} min`);
    });
    
    return usage;

  } catch (error) {
    console.error('Failed to fetch usage:', error);
    return null;
  }
};

// Check usage with date range filter
const getUsageByDateRange = async (apiToken, startDate, endDate) => {
  const params = new URLSearchParams({
    start_date: startDate,  // e.g., '2025-11-01'
    end_date: endDate,      // e.g., '2025-11-30'
    limit: '100'
  });

  const response = await fetch(`https://api.mayorsoftware.ch/v1/token-balance/usage?${params}`, {
    headers: {
      'Authorization': `Bearer ${apiToken}`
    }
  });

  return response.json();
};

// Monitor usage and warn if approaching limits
getUsageStats('epv_your_token_here').then(usage => {
  if (usage) {
    const transcriptionUsagePercent = 
      (usage.current_period.transcription_minutes / usage.limits.transcription_minutes_limit) * 100;
    
    if (transcriptionUsagePercent > 80) {
      console.warn('WARNING: High transcription usage! Consider upgrading your plan.');
    }
    
    if (usage.hasMore) {
      console.log('More transactions available. Use offset parameter for pagination.');
    }
  }
});

import requests
from datetime import datetime, timedelta

def get_usage_stats(api_token, limit=50, service_type=None):
    """Get token usage statistics with optional filtering."""
    url = 'https://api.mayorsoftware.ch/v1/token-balance/usage'
    
    headers = {
        'Authorization': f'Bearer {api_token}'
    }
    
    params = {
        'limit': limit
    }
    
    if service_type:
        params['service_type'] = service_type
    
    try:
        response = requests.get(url, headers=headers, params=params)
        response.raise_for_status()
        
        usage = response.json()
        
        print(f"Current Period Usage:")
        print(f"  Transcription: {usage['current_period']['transcription_minutes']} minutes")
        print(f"  LLM Tokens: {usage['current_period']['llm_tokens']}")
        print(f"  Cost: ${usage['current_period']['cost']}")
        print(f"\nTotal transactions: {usage['total']}")
        
        # Display usage history
        for day in usage['usage_history']:
            print(f"{day['date']}: {day['requests']} requests, {day['transcription_minutes']:.2f} min")
        
        return usage
        
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

def get_usage_by_date_range(api_token, start_date, end_date):
    """Get usage statistics for a specific date range."""
    url = 'https://api.mayorsoftware.ch/v1/token-balance/usage'
    
    headers = {
        'Authorization': f'Bearer {api_token}'
    }
    
    params = {
        'start_date': start_date.isoformat(),
        'end_date': end_date.isoformat(),
        'limit': 100
    }
    
    response = requests.get(url, headers=headers, params=params)
    response.raise_for_status()
    return response.json()

# Usage examples
if __name__ == '__main__':
    api_token = 'epv_your_token_here'
    
    # Get overall usage
    usage = get_usage_stats(api_token)
    
    # Get only transcription usage
    transcription_usage = get_usage_stats(api_token, service_type='transcription')
    
    # Get usage for last 7 days
    end_date = datetime.now()
    start_date = end_date - timedelta(days=7)
    weekly_usage = get_usage_by_date_range(api_token, start_date, end_date)
    
    # Check if approaching limits
    if usage:
        transcription_percent = (
            usage['current_period']['transcription_minutes'] / 
            usage['limits']['transcription_minutes_limit'] * 100
        )
        
        if transcription_percent > 80:
            print('WARNING: High transcription usage!')