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

Paramètres de Connexion Verbindungsparameter Parametri di Connessione

Limites de Taux (Rate Limiting) Rate Limiting Rate-Limiting Rate Limiting

Pour protéger le service contre la surcharge, les limites suivantes s'appliquent par token API: To protect the service against overload, the following limits apply per API token: Zum Schutz des Dienstes vor Überlastung gelten folgende Limits pro API-Token: Per proteggere il servizio dal sovraccarico, si applicano i seguenti limiti per token API:

• Maximum 3 connexions WebSocket simultanées par token Maximum 3 simultaneous WebSocket connections per token Maximal 3 gleichzeitige WebSocket-Verbindungen pro Token Massimo 3 connessioni WebSocket simultanee per token
• Maximum 10 nouvelles connexions par minute par token Maximum 10 new connections per minute per token Maximal 10 neue Verbindungen pro Minute pro Token Massimo 10 nuove connessioni al minuto per token

Si ces limites sont dépassées, la connexion WebSocket sera fermée avec le code 1008 (Policy Violation). If these limits are exceeded, the WebSocket connection will be closed with code 1008 (Policy Violation). Wenn diese Limits überschritten werden, wird die WebSocket-Verbindung mit Code 1008 (Richtlinienverletzung) geschlossen. Se questi limiti vengono superati, la connessione WebSocket verrà chiusa con codice 1008 (Violazione delle Policy).

Protocole WebSocket WebSocket Protocol WebSocket-Protokoll Protocollo WebSocket

Séquence de Connexion Connection Sequence Verbindungssequenz Sequenza di Connessione

Types de Messages Message Types Nachrichtentypen Tipi di Messaggi

1️⃣ Audio Data (Client → Server) - Binary

Envoyez les données audio brutes (WebM/Opus) directement via WebSocket. Pas besoin de JSON ou de base64. Send raw audio data (WebM/Opus) directly via WebSocket. No JSON or base64 encoding needed. Senden Sie rohe Audiodaten (WebM/Opus) direkt über WebSocket. Kein JSON oder Base64-Kodierung erforderlich. Invia dati audio grezzi (WebM/Opus) direttamente tramite WebSocket. Non è necessaria la codifica JSON o base64.

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

2️⃣ Transcription Result (Server → Client) - JSON

{
  "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": {}
  }
}

3️⃣ End Session (Client → Server) - JSON

Pour terminer proprement une session de transcription, envoyez ce message de contrôle : To properly end a transcription session, send this control message: Um eine Transkriptionssitzung ordnungsgemäß zu beenden, senden Sie diese Kontrollnachricht: Per terminare correttamente una sessione di trascrizione, invia questo messaggio di controllo:

{
  "type": "end_session"
}

Important : Ceci permet au serveur de traiter tout l'audio restant dans le buffer et d'envoyer les derniers résultats avant de fermer la connexion. Le serveur répondra avec un message ready_to_stop quand tout est terminé. Important: This allows the server to process any remaining audio in the buffer and send final results before closing the connection. The server will respond with a ready_to_stop message when complete.

4️⃣ Ready to Stop (Server → Client) - JSON

Le serveur envoie ce message après avoir traité tous les résultats suite à un end_session : The server sends this message after processing all results following an end_session:

{
  "type": "ready_to_stop"
}

Le client peut maintenant fermer la connexion WebSocket en toute sécurité avec ws.close(). The client can now safely close the WebSocket connection with ws.close().

Note: Les champs buffer_transcription, buffer_diarization, remaining_time_transcription, remaining_time_diarization et token_usage sont optionnels et peuvent ne pas être présents dans toutes les réponses.

Cas Spéciaux Special Cases Sonderfälle Casi Speciali

Exemples de Code Code Examples Codebeispiele Esempi di Codice

const apiToken = 'epv_your_token_here';
const enableDiarization = true;
const voiceSignatures = [  // Get from /generate_signatures endpoint
  { name: 'Alice', embedding: [/* 512 dimensions */] },
  { name: 'Bob', embedding: [/* 512 dimensions */] }
];

const wsUrl = `wss://api.mayorsoftware.ch/v1/asr?token=${encodeURIComponent(apiToken)}&enable_diarization=${enableDiarization}`;

const ws = new WebSocket(wsUrl);
let mediaRecorder = null;
let configReceived = false;

ws.onopen = () => {
  console.log('WebSocket connected, waiting for server config...');
};

ws.onmessage = async (event) => {
  const data = JSON.parse(event.data);
  
  // 1. Handle initial server config
  if (data.type === 'config' && !configReceived) {
    console.log('Received server config:', data);
    configReceived = true;
    
    // 2. Send voice signatures if diarization is enabled
    if (enableDiarization && voiceSignatures.length > 0) {
      console.log('Sending voice signatures...');
      ws.send(JSON.stringify({
        type: 'config',
        voice_signatures: voiceSignatures
      }));
    } else if (enableDiarization) {
      // Send empty array if no signatures but diarization enabled
      ws.send(JSON.stringify({
        type: 'config',
        voice_signatures: []
      }));
    }
    
    // 3. Start audio capture after config is sent (or skipped)
    if (!enableDiarization || voiceSignatures) {
      startAudioCapture();
    }
    return;
  }
  
  // 4. Handle signature acknowledgment
  if (data.type === 'config_ack') {
    console.log(`Signatures confirmed: ${data.signatures_received} received`);
    startAudioCapture();
    return;
  }
  
  // 5. Handle ready_to_stop signal
  if (data.type === 'ready_to_stop') {
    console.log('Server ready to stop, closing connection...');
    ws.close();
    return;
  }
  
  // 6. Handle transcription results
  if (data.status === 'active_transcription' && data.lines) {
    data.lines.forEach(line => {
      if (line.text && line.text.trim()) {
        console.log(`Speaker ${line.speaker}: ${line.text}`);
      }
    });
    
    // Check for token usage information
    if (data.token_usage) {
      console.log(`Tokens consumed: ${data.token_usage.tokens_consumed}`);
    }
  }
};

function startAudioCapture() {
  console.log('Starting audio capture...');
  navigator.mediaDevices.getUserMedia({ audio: true })
    .then(stream => {
      mediaRecorder = new MediaRecorder(stream, {
        mimeType: 'audio/webm;codecs=opus'
      });
      
      mediaRecorder.ondataavailable = (event) => {
        if (event.data.size > 0 && ws.readyState === WebSocket.OPEN) {
          // Send raw binary audio data
          ws.send(event.data);
        }
      };
      
      mediaRecorder.start(250); // Send data every 250ms
      console.log('Audio capture started');
    })
    .catch(err => console.error('Audio capture error:', err));
}

function stopRecording() {
  console.log('⏹️ Stopping recording...');
  if (mediaRecorder && mediaRecorder.state !== 'inactive') {
    mediaRecorder.stop();
  }
  
  // Send end_session message for graceful shutdown
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: 'end_session' }));
    console.log('Sent end_session, waiting for server confirmation...');
  }
}

ws.onerror = (error) => {
  console.error('WebSocket error:', error);
};

ws.onclose = (event) => {
  console.log(`WebSocket disconnected (code: ${event.code}, reason: ${event.reason || 'none'})`);
  if (mediaRecorder && mediaRecorder.state !== 'inactive') {
    mediaRecorder.stop();
  }
};

// Usage: Call stopRecording() when user wants to end the session
// setTimeout(() => stopRecording(), 60000); // Example: stop after 60 seconds

import asyncio
import websockets
import json
import pyaudio

async def transcribe_live():
    api_token = "epv_your_token_here"
    uri = f"wss://api.mayorsoftware.ch/v1/asr?token={api_token}"
    
    async with websockets.connect(uri) as websocket:
        # Audio configuration
        chunk = 1024
        format = pyaudio.paInt16
        channels = 1
        rate = 16000
        
        audio = pyaudio.PyAudio()
        stream = audio.open(
            format=format,
            channels=channels,
            rate=rate,
            input=True,
            frames_per_buffer=chunk
        )
        
        async def send_audio():
            while True:
                # Read and send raw audio data
                data = stream.read(chunk)
                await websocket.send(data)
                await asyncio.sleep(0.05)
        
        async def receive_transcription():
            async for message in websocket:
                data = json.loads(message)
                if data.get("status") == "active_transcription" and data.get("lines"):
                    for line in data["lines"]:
                        if line.get("text") and line["text"].strip():
                            print(f"Speaker {line['speaker']}: {line['text']}")
                    
                    # Check for token usage information
                    if data.get("token_usage"):
                        tokens = data["token_usage"].get("tokens_consumed", 0)
                        print(f"Tokens consumed: {tokens}")
        
        await asyncio.gather(send_audio(), receive_transcription())

asyncio.run(transcribe_live())

Response Format

{
  "models": ["standard", "baseline"],
  "default": "standard",
  "details": [
    {
      "id": "standard",
      "label": "Whisper Large V3 Turbo",
      "description": "Primary production model",
      "backend": "faster-whisper",
      "model_size": "large-v3-turbo",
      "language": "fr",
      "release": "2024-12-15",
      "dataset": "SwissParliament",
      "quantization": "float16",
      "training_stats": { "wer": 5.1 },
      "adapter_rank": 16,
      "lora_alpha": 8,
      "available": true,
      "notes": "Optimised for livestreams"
    }
  ]
}

Keys inside details are optional and mirror the metadata loaded from the model registry. Any dynamically registered model appears even if it lacks metadata, in which case only id, label and available are populated.

Detail Fields

Response Example

{
  "enabled": true,
  "path": "/app/lexicon/lexicon_trie.json",
  "min_weight": 0.35,
  "max_span": 6,
  "loaded": true,
  "children": 742,
  "sentence_case": true,
  "allow_case_only": false,
  "allowed_sources": ["gazette", "manual"],
  "fuzzy": {
    "enabled": true,
    "buckets": 128,
    "similarity": 0.92,
    "min_weight": 0.25,
    "bucket_prefix": "fuzzy_",
    "bucket_len_slack": 2,
    "debug": false,
    "spacy": {
      "enabled": true,
      "model": "fr_core_news_md",
      "loaded": true,
      "error": null,
      "delta": 0.17
    }
  },
  "llm": {
    "enabled": false,
    "model": null,
    "max_spans": 16,
    "max_candidates": 4,
    "timeout": 3.0,
    "cache_max": 256,
    "cache_size": 0,
    "phonetic_index": 0,
    "debug": false
  }
}

JSON Body

Every field is optional. The endpoint returns the same structure as /lexicon/status along with {"success": true} when the reload succeeds.

Request Parameters

Response Format

{
  "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
}

Code Examples

const formData = new FormData();
formData.append('audio_files', johnAudioFile);
formData.append('audio_files', janeAudioFile);
formData.append('speaker_names', JSON.stringify(['John Doe', 'Jane Smith']));

const response = await fetch('https://api.mayorsoftware.ch/v1/generate_signatures', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${token}`
  },
  body: formData
});

const data = await response.json();
console.log(`Generated ${data.count} signatures`);

// Save signatures for later use in transcription
localStorage.setItem('voiceSignatures', JSON.stringify(data.signatures));

import requests

# Prepare audio files
files = [
    ('audio_files', ('john.wav', open('john.wav', 'rb'), 'audio/wav')),
    ('audio_files', ('jane.wav', open('jane.wav', 'rb'), 'audio/wav'))
]

data = {
    'speaker_names': '["John Doe", "Jane Smith"]'
}

response = requests.post(
    'https://api.mayorsoftware.ch/v1/generate_signatures',
    headers={'Authorization': f'Bearer {token}'},
    files=files,
    data=data
)

result = response.json()
print(f"Generated {result['count']} signatures")

# Save signatures for later use
signatures = result['signatures']

Request Parameters

Response Format

{
  "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"
    }
  }
}

Code Examples

const transcribeFile = async (audioFile) => {
  // Step 1: Generate voice signatures (if using known speakers)
  const sigFormData = new FormData();
  sigFormData.append('audio_files', speakerAudioFile1); // Sample from speaker 1
  sigFormData.append('audio_files', speakerAudioFile2); // Sample from speaker 2
  sigFormData.append('speaker_names', JSON.stringify(['Alice', 'Bob']));

  const sigResponse = await fetch('https://api.mayorsoftware.ch/generate_signatures', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer epv_your_token_here'
    },
    body: sigFormData
  });

  const { signatures } = await sigResponse.json();
  // signatures = [{name: 'Alice', embedding: [...]}, {name: 'Bob', embedding: [...]}]

  // Step 2: Transcribe with voice signatures
  const formData = new FormData();
  formData.append('audio', audioFile);
  formData.append('diarization', 'true');
  formData.append('use_voice_signatures', 'true');
  formData.append('voice_signatures', JSON.stringify(signatures)); // Send as JSON string
  formData.append('voice_similarity_threshold', '0.18');

  try {
    const response = await fetch('https://api.mayorsoftware.ch/v1/transcribe/sync', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer epv_your_token_here'
      },
      body: formData
    });

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

    const result = await response.json();
    console.log('Transcription:', result.text);
    console.log('Duration:', result.duration);
    console.log('Language:', result.language);
    
    // Process segments with speaker information
    result.segments.forEach(segment => {
      console.log(`Speaker ${segment.speaker} (${segment.start}-${segment.end}): ${segment.text}`);
    });
    
    // Display diarization summary
    if (result.diarization_summary) {
      console.log(`Total segments: ${result.diarization_summary.total_segments}`);
      console.log(`Unique speakers: ${result.diarization_summary.unique_speakers}`);
    }
    
    // Display token usage
    if (result.token_usage) {
      console.log(`Tokens consumed: ${result.token_usage.tokens_consumed}`);
    }

  } catch (error) {
    console.error('Transcription failed:', error);
  }
};

// Usage with file input
document.getElementById('fileInput').addEventListener('change', (event) => {
  const file = event.target.files[0];
  if (file) {
    transcribeFile(file);
  }
});

import requests

def transcribe_audio_file(file_path, enable_diarization=True):
    url = 'https://api.mayorsoftware.ch/v1/transcribe/sync'
    
    headers = {
        'Authorization': 'Bearer epv_your_token_here'
    }
    
    files = {
        'audio': open(file_path, 'rb')
    }
    
    data = {
        'diarization': str(enable_diarization).lower()
    }
    
    try:
        response = requests.post(url, headers=headers, files=files, data=data)
        response.raise_for_status()
        
        result = response.json()
        
        print(f"Transcription: {result['text']}")
        print(f"Duration: {result['duration']}s")
        print(f"Language: {result['language']}")
        
        # Print diarization summary
        if result.get('diarization_summary'):
            summary = result['diarization_summary']
            print(f"Speakers: {summary['unique_speakers']}")
            print(f"Total segments: {summary['total_segments']}")
        
        # Print segments with timestamps
        for segment in result['segments']:
            print(f"Speaker {segment['speaker']} ({segment['start']}-{segment['end']}): {segment['text']}")
        
        # Print token usage
        if result.get('token_usage'):
            print(f"Tokens consumed: {result['token_usage']['tokens_consumed']}")
            
        return result
        
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None
    finally:
        files['audio'].close()

# Usage
result = transcribe_audio_file('meeting_recording.wav')

Request Parameters

Response Format

{
  "task_id": "550e8400-e29b-41d4-a716-446655440000",
  "status": "queued",
  "message": "Task submitted successfully. Use /transcribe/status/{task_id} to check progress.",
  "model_id": "standard",
  "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
    }
  }
}

Code Examples

const submitAsyncTranscription = async (audioFile, signatures = null) => {
  // Step 1: Generate voice signatures if needed
  let voiceSignatures = signatures;
  if (!voiceSignatures && speakerAudioSamples) {
    const sigFormData = new FormData();
    speakerAudioSamples.forEach(sample => {
      sigFormData.append('audio_files', sample);
    });
    sigFormData.append('speaker_names', JSON.stringify(['Alice', 'Bob']));

    const sigResponse = await fetch('https://api.mayorsoftware.ch/generate_signatures', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer epv_your_token_here'
      },
      body: sigFormData
    });

    const sigResult = await sigResponse.json();
    voiceSignatures = sigResult.signatures;
  }

  // Step 2: Submit transcription task
  const formData = new FormData();
  formData.append('audio', audioFile);
  formData.append('diarization', 'true');
  if (voiceSignatures) {
    formData.append('use_voice_signatures', 'true');
    formData.append('voice_signatures', JSON.stringify(voiceSignatures));
    formData.append('voice_similarity_threshold', '0.18');
  }

  try {
    const response = await fetch('https://api.mayorsoftware.ch/v1/transcribe/submit', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer epv_your_token_here'
      },
      body: formData
    });

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

    const result = await response.json();
    console.log('Task submitted:', result.task_id);
    console.log('Status:', result.status);
    console.log('Message:', result.message);
    
    // Display estimated token usage
    if (result.token_usage) {
      console.log(`Estimated tokens: ${result.token_usage.tokens_consumed}`);
    }
    
    return result.task_id;

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

// Usage
const fileInput = document.getElementById('fileInput');
fileInput.addEventListener('change', async (event) => {
  const file = event.target.files[0];
  if (file) {
    const taskId = await submitAsyncTranscription(file);
    if (taskId) {
      // Poll for results
      pollTranscriptionStatus(taskId);
    }
  }
});

import requests
import json

def generate_signatures(audio_files, speaker_names):
    """Generate voice signatures from audio samples."""
    url = 'https://api.mayorsoftware.ch/generate_signatures'
    
    headers = {
        'Authorization': 'Bearer epv_your_token_here'
    }
    
    files = [('audio_files', open(f, 'rb')) for f in audio_files]
    data = {
        'speaker_names': json.dumps(speaker_names)
    }
    
    try:
        response = requests.post(url, headers=headers, files=files, data=data)
        response.raise_for_status()
        return response.json()['signatures']
    finally:
        for _, file_obj in files:
            file_obj.close()

def submit_async_transcription(file_path, signatures=None):
    url = 'https://api.mayorsoftware.ch/v1/transcribe/submit'
    
    headers = {
        'Authorization': 'Bearer epv_your_token_here'
    }
    
    files = {
        'audio': open(file_path, 'rb')
    }
    
    data = {
        'diarization': 'true'
    }
    
    # Add voice signatures if provided
    if signatures:
        data['use_voice_signatures'] = 'true'
        data['voice_signatures'] = json.dumps(signatures)
        data['voice_similarity_threshold'] = '0.18'
    
    try:
        response = requests.post(url, headers=headers, files=files, data=data)
        response.raise_for_status()
        
        result = response.json()
        
        print(f"Task submitted: {result['task_id']}")
        print(f"Status: {result['status']}")
        print(f"Message: {result['message']}")
        
        # Display estimated token usage
        if result.get('token_usage'):
            print(f"Estimated tokens: {result['token_usage']['tokens_consumed']}")
        
        return result['task_id']
        
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None
    finally:
        files['audio'].close()

# Usage
task_id = submit_async_transcription('large_meeting.mp3')
if task_id:
    print(f"Track your task at: https://api.mayorsoftware.ch/v1/transcribe/status/{task_id}")

Response Format

{
  "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
}

Status Values

Response Format

{
  "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,
  "voice_signatures_used": 2,
  "model_id": "standard",
  "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.5,
    "llm_tokens": 0.0,
    "duration_minutes": 2.008,
    "billing_metadata": {
      "filename": "audio.wav",
      "duration": 120.5,
      "num_segments": 25,
      "unique_speakers": 3,
      "processing_mode": "background",
      "model_id": "standard"
    }
  },
  "signature_refinement": {
    "mode": "on",
    "iterations": 2,
    "matches": [
      {
        "speaker": "Alice",
        "score": 0.88
      }
    ]
  }
}

Response Format

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

Path Parameters

Response Example

{
  "filename": "session_01.wav",
  "reference_text": "Mesdames et Messieurs, bienvenue...",
  "duration": 123.4,
  "source": "Swiss Parliament"
}

HTTP 404 is returned when the filename cannot be found in either manifest file. Any unexpected error triggers a 500 response with the error message in detail.

Réponse Succès (200 OK) Success Response (200 OK) Erfolgreiche Antwort (200 OK) Risposta di Successo (200 OK)

{
  "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
  }
}

Description des Champs Field Descriptions Feldbeschreibungen Descrizioni dei Campi

Rate Limiting Rate Limiting Rate-Limiting Rate Limiting

Le service applique des limites strictes pour éviter la surcharge: The service applies strict limits to prevent overload: Der Dienst wendet strenge Limits an, um Überlastung zu vermeiden: Il servizio applica limiti rigorosi per prevenire il sovraccarico:

• 3 connexions simultanées maximum par token API Maximum 3 simultaneous connections per API token Maximal 3 gleichzeitige Verbindungen pro API-Token Massimo 3 connessioni simultanee per token API
• 10 nouvelles connexions maximum par minute par token Maximum 10 new connections per minute per token Maximal 10 neue Verbindungen pro Minute pro Token Massimo 10 nuove connessioni al minuto per token
• Code d'erreur WebSocket 1008 si les limites sont dépassées WebSocket error code 1008 if limits are exceeded WebSocket-Fehlercode 1008 bei Überschreitung der Limits Codice errore WebSocket 1008 se i limiti vengono superati

Response Example

{
  "status": "healthy",
  "active_connections": 2,
  "unique_tokens": 2
}

Request Parameters

Request Format

{
  "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
}

Response Format

{
  "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
  }
}

JavaScript Example (Non-Streaming)

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);

JavaScript Example (Streaming)

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;
  }
};