Transcription

POST /voice/transcription

curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "audio_url": "https://your-storage.com/deposition-audio.m4a",
    "speaker_labels": true,
    "language_code": "en"
  }'

{
  "id": "5f9c5c3e-1234-5678-9abc-def012345678",
  "status": "queued",
  "audio_url": "https://your-storage.com/deposition-audio.m4a",
  "language_code": "en",
  "speaker_labels": true
}

GET /voice/transcription/:id

curl https://api.case.dev/voice/transcription/5f9c5c3e-1234-5678-9abc-def012345678 \
  -H "Authorization: Bearer sk_case_your_api_key_here"

{
  "id": "5f9c5c3e-1234-5678-9abc-def012345678",
  "status": "processing",
  "audio_url": "https://your-storage.com/deposition-audio.m4a",
  "audio_duration": 3847.2
}

{
  "id": "5f9c5c3e-1234-5678-9abc-def012345678",
  "status": "completed",
  "audio_url": "https://your-storage.com/deposition-audio.m4a",
  "text": "Speaker A: Please state your name for the record. Speaker B: My name is Dr. Sarah Johnson...",
  "words": [
    {
      "text": "Please",
      "start": 100,
      "end": 350,
      "confidence": 0.99,
      "speaker": "A"
    },
    {
      "text": "state",
      "start": 400,
      "end": 650,
      "confidence": 0.98,
      "speaker": "A"
    }
  ],
  "utterances": [
    {
      "text": "Please state your name for the record.",
      "start": 100,
      "end": 2450,
      "confidence": 0.97,
      "speaker": "A"
    },
    {
      "text": "My name is Dr. Sarah Johnson.",
      "start": 3100,
      "end": 5200,
      "confidence": 0.96,
      "speaker": "B"
    }
  ],
  "audio_duration": 3847.2,
  "confidence": 0.95,
  "language_code": "en"
}

curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_..." \
  -H "Content-Type: application/json" \
  -d '{
    "audio_url": "https://vault.s3.amazonaws.com/deposition-2024-1234.m4a",
    "speaker_labels": true,
    "language_code": "en",
    "redact_pii": true,
    "redact_pii_policies": ["name", "address", "ssn", "medical"],
    "webhook_url": "https://your-app.com/transcription-complete"
  }'

curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_..." \
  -H "Content-Type: application/json" \
  -d '{
    "audio_url": "https://storage.com/doctor-notes.mp3",
    "redact_pii": true,
    "redact_pii_policies": ["name", "medical", "date_of_birth"],
    "content_safety_labels": true
  }'

curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_..." \
  -H "Content-Type: application/json" \
  -d '{
    "audio_url": "https://storage.com/spanish-interview.m4a",
    "language_detection": true,
    "speaker_labels": true
  }'

#!/bin/bash
TRANSCRIPT_ID="5f9c5c3e-1234-5678-9abc-def012345678"

while true; do
  RESPONSE=$(curl -s https://api.case.dev/voice/transcription/$TRANSCRIPT_ID \
    -H "Authorization: Bearer sk_case_...")

  STATUS=$(echo "$RESPONSE" | jq -r '.status')
  echo "Status: $STATUS"

  if [ "$STATUS" = "completed" ]; then
    echo "Transcription complete!"
    echo "$RESPONSE" | jq -r '.text' > transcript.txt
    break
  elif [ "$STATUS" = "error" ]; then
    echo "Transcription failed"
    break
  fi

  sleep 5
done

{
  "transcript_id": "5f9c5c3e-1234-5678-9abc-def012345678",
  "status": "completed",
  "text": "Full transcript text...",
  "audio_duration": 1847.3,
  "confidence": 0.96
}

# Get vault object with audio file
VAULT_ID="sytp1b5f5j1yuj7uffzzxgw6"
OBJECT_ID="audio123"

# Get presigned download URL (valid for 1 hour)
DOWNLOAD_URL=$(curl -s https://api.case.dev/vault/$VAULT_ID/objects/$OBJECT_ID \
  -H "Authorization: Bearer sk_case_..." \
  | jq -r '.downloadUrl')

# Submit for transcription
curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_..." \
  -H "Content-Type: application/json" \
  -d "{
    \"audio_url\": \"$DOWNLOAD_URL\",
    \"speaker_labels\": true,
    \"language_code\": \"en\"
  }"

# Generate 24-hour presigned URL
PRESIGNED_RESPONSE=$(curl -s -X POST https://api.case.dev/vault/$VAULT_ID/objects/$OBJECT_ID/presigned-url \
  -H "Authorization: Bearer sk_case_..." \
  -H "Content-Type: application/json" \
  -d '{"operation": "GET", "expiresIn": 86400}')

AUDIO_URL=$(echo "$PRESIGNED_RESPONSE" | jq -r '.presignedUrl')

# Submit for transcription
curl -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer sk_case_..." \
  -d "{\"audio_url\": \"$AUDIO_URL\", \"speaker_labels\": true}"

#!/bin/bash
API_KEY="sk_case_your_api_key_here"
VAULT_ID="sytp1b5f5j1yuj7uffzzxgw6"
AUDIO_FILE="deposition-recording.m4a"

# Step 1: Upload audio to vault
UPLOAD_RESPONSE=$(curl -s -X POST https://api.case.dev/vault/$VAULT_ID/upload \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"filename\": \"$AUDIO_FILE\",
    \"contentType\": \"audio/m4a\",
    \"metadata\": {
      \"case\": \"2024-CV-1234\",
      \"type\": \"deposition\",
      \"date\": \"2024-11-10\"
    }
  }")

OBJECT_ID=$(echo "$UPLOAD_RESPONSE" | jq -r '.objectId')
UPLOAD_URL=$(echo "$UPLOAD_RESPONSE" | jq -r '.uploadUrl')

# Upload the file
curl -X PUT "$UPLOAD_URL" \
  -H "Content-Type: audio/m4a" \
  --data-binary "@$AUDIO_FILE"

echo "✓ Audio uploaded to vault: $OBJECT_ID"

# Step 2: Get download URL
DOWNLOAD_URL=$(curl -s https://api.case.dev/vault/$VAULT_ID/objects/$OBJECT_ID \
  -H "Authorization: Bearer $API_KEY" \
  | jq -r '.downloadUrl')

# Step 3: Submit for transcription
TRANSCRIPT_RESPONSE=$(curl -s -X POST https://api.case.dev/voice/transcription \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d "{
    \"audio_url\": \"$DOWNLOAD_URL\",
    \"speaker_labels\": true,
    \"language_code\": \"en\",
    \"redact_pii\": true
  }")

TRANSCRIPT_ID=$(echo "$TRANSCRIPT_RESPONSE" | jq -r '.id')
echo "✓ Transcription started: $TRANSCRIPT_ID"

# Step 4: Poll for completion
while true; do
  STATUS_RESPONSE=$(curl -s https://api.case.dev/voice/transcription/$TRANSCRIPT_ID \
    -H "Authorization: Bearer $API_KEY")

  STATUS=$(echo "$STATUS_RESPONSE" | jq -r '.status')
  echo "Transcription status: $STATUS"

  if [ "$STATUS" = "completed" ]; then
    echo "✓ Transcription complete!"

    # Save transcript
    echo "$STATUS_RESPONSE" | jq -r '.text' > transcript.txt

    # Step 5: Upload transcript back to vault
    TRANSCRIPT_UPLOAD=$(curl -s -X POST https://api.case.dev/vault/$VAULT_ID/upload \
      -H "Authorization: Bearer $API_KEY" \
      -H "Content-Type: application/json" \
      -d "{
        \"filename\": \"${AUDIO_FILE%.m4a}-transcript.txt\",
        \"contentType\": \"text/plain\",
        \"metadata\": {
          \"source_audio_id\": \"$OBJECT_ID\",
          \"transcript_id\": \"$TRANSCRIPT_ID\"
        }
      }")

    TRANSCRIPT_OBJECT_ID=$(echo "$TRANSCRIPT_UPLOAD" | jq -r '.objectId')
    TRANSCRIPT_UPLOAD_URL=$(echo "$TRANSCRIPT_UPLOAD" | jq -r '.uploadUrl')

    curl -X PUT "$TRANSCRIPT_UPLOAD_URL" \
      -H "Content-Type: text/plain" \
      --data-binary "@transcript.txt"

    echo "✓ Transcript uploaded to vault: $TRANSCRIPT_OBJECT_ID"
    break
  elif [ "$STATUS" = "error" ]; then
    echo "✗ Transcription failed"
    exit 1
  fi

  sleep 10
done

echo ""
echo "=== Complete! ==="
echo "Audio in vault: $OBJECT_ID"
echo "Transcript in vault: $TRANSCRIPT_OBJECT_ID"
echo "Transcript ID: $TRANSCRIPT_ID"

wss://casemark-ai--websocket-stream-helper-fastapi-app.modal.run/ws?token=sk_case_your_api_key_here

const token = 'sk_case_your_api_key_here';
const ws = new WebSocket(`wss://casemark-ai--websocket-stream-helper-fastapi-app.modal.run/ws?token=${token}`);

ws.onopen = () => {
  console.log('Connected to streaming transcription');
};

ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  console.log('Transcript:', data);
};

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

ws.onclose = (event) => {
  console.log('Connection closed:', event.code, event.reason);
};

// Example: Send audio from microphone
navigator.mediaDevices.getUserMedia({ audio: true })
  .then(stream => {
    const mediaRecorder = new MediaRecorder(stream);
    const audioContext = new AudioContext({ sampleRate: 16000 });
    
    mediaRecorder.ondataavailable = async (event) => {
      const audioData = await event.data.arrayBuffer();
      
      // Convert to PCM 16-bit if needed
      const pcmData = convertToPCM16(audioData);
      
      // Send to WebSocket
      if (ws.readyState === WebSocket.OPEN) {
        ws.send(pcmData);
      }
    };
    
    mediaRecorder.start(100); // Send every 100ms
  });

{
  "type": "session_begins",
  "session_id": "abc123",
  "message": "Streaming session started"
}

{
  "message_type": "PartialTranscript",
  "text": "Hello, this is a test",
  "audio_start": 0,
  "audio_end": 2000,
  "confidence": 0.95,
  "words": [
    {
      "text": "Hello",
      "start": 0,
      "end": 400,
      "confidence": 0.98
    },
    {
      "text": "this",
      "start": 400,
      "end": 600,
      "confidence": 0.97
    }
  ]
}

{
  "message_type": "FinalTranscript",
  "text": "Hello, this is a test.",
  "audio_start": 0,
  "audio_end": 2500,
  "confidence": 0.96,
  "punctuated": true,
  "words": [
    {
      "text": "Hello",
      "start": 0,
      "end": 400,
      "confidence": 0.98
    },
    {
      "text": "this",
      "start": 400,
      "end": 600,
      "confidence": 0.97
    },
    {
      "text": "is",
      "start": 600,
      "end": 750,
      "confidence": 0.96
    },
    {
      "text": "a",
      "start": 750,
      "end": 850,
      "confidence": 0.95
    },
    {
      "text": "test",
      "start": 850,
      "end": 2500,
      "confidence": 0.97
    }
  ]
}

{
  "message_type": "SessionTerminated"
}

ws.send(JSON.stringify({ terminate: true }));

// Wait a moment for final transcripts
setTimeout(() => {
  ws.close();
}, 1000);

const WebSocket = require('ws');
const fs = require('fs');

const token = 'sk_case_your_api_key_here';
const ws = new WebSocket(`wss://casemark-ai--websocket-stream-helper-fastapi-app.modal.run/ws?token=${token}`);

ws.on('open', () => {
  console.log('✓ Connected to streaming transcription');
  
  // Read audio file (16kHz, PCM 16-bit, mono)
  const audioFile = fs.readFileSync('./audio.raw');
  
  // Send in chunks (100ms at 16kHz = 3200 bytes)
  const chunkSize = 3200;
  let offset = 0;
  
  const sendChunk = () => {
    if (offset < audioFile.length) {
      const chunk = audioFile.slice(offset, offset + chunkSize);
      ws.send(chunk);
      offset += chunkSize;
      setTimeout(sendChunk, 100); // Send every 100ms
    } else {
      // End of audio
      console.log('✓ Audio sent, waiting for final transcripts...');
      ws.send(JSON.stringify({ terminate: true }));
      setTimeout(() => ws.close(), 2000);
    }
  };
  
  sendChunk();
});

ws.on('message', (data) => {
  const message = JSON.parse(data.toString());
  
  if (message.message_type === 'FinalTranscript') {
    console.log('Final:', message.text);
  } else if (message.message_type === 'PartialTranscript') {
    console.log('Partial:', message.text);
  } else {
    console.log('Message:', message);
  }
});

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

ws.on('close', (code, reason) => {
  console.log(`Connection closed: ${code} ${reason}`);
});

// Get microphone access
const stream = await navigator.mediaDevices.getUserMedia({
  audio: {
    sampleRate: 16000,
    channelCount: 1,
    echoCancellation: true,
    noiseSuppression: true,
  }
});

const token = 'sk_case_your_api_key_here';
const ws = new WebSocket(`wss://casemark-ai--websocket-stream-helper-fastapi-app.modal.run/ws?token=${token}`);

// Set up AudioWorklet for PCM processing
const audioContext = new AudioContext({ sampleRate: 16000 });
const source = audioContext.createMediaStreamSource(stream);

await audioContext.audioWorklet.addModule('/audio-processor.js');
const processor = new AudioWorkletNode(audioContext, 'pcm-processor');

processor.port.onmessage = (event) => {
  // Send PCM data to WebSocket
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(event.data);
  }
};

source.connect(processor);
processor.connect(audioContext.destination);

// Handle transcripts
ws.onmessage = (event) => {
  const data = JSON.parse(event.data);
  
  if (data.message_type === 'FinalTranscript') {
    document.getElementById('transcript').textContent += data.text + ' ';
  } else if (data.message_type === 'PartialTranscript') {
    document.getElementById('interim').textContent = data.text;
  }
};

// Stop recording
document.getElementById('stop').onclick = () => {
  ws.send(JSON.stringify({ terminate: true }));
  stream.getTracks().forEach(track => track.stop());
  audioContext.close();
  ws.close();
};

{
  "error": "Authentication failed",
  "code": "AUTH_INVALID"
}

let reconnectAttempts = 0;
const maxReconnects = 3;

function connect() {
  const ws = new WebSocket(`wss://casemark-ai--websocket-stream-helper-fastapi-app.modal.run/ws?token=${token}`);
  
  ws.onclose = (event) => {
    if (event.code !== 1000 && reconnectAttempts < maxReconnects) {
      reconnectAttempts++;
      console.log(`Reconnecting... (${reconnectAttempts}/${maxReconnects})`);
      setTimeout(connect, 1000 * reconnectAttempts);
    }
  };
  
  ws.onopen = () => {
    reconnectAttempts = 0; // Reset on successful connection
  };
  
  return ws;
}

const startTime = Date.now();

ws.onclose = () => {
  const durationSeconds = (Date.now() - startTime) / 1000;
  const cost = (durationSeconds / 60) * 0.30; // $0.30 per minute
  console.log(`Session duration: ${durationSeconds}s, Est. cost: $${cost.toFixed(2)}`);
};