How to Integrate Meetily's Local Transcription with External Meeting Platforms via API

Meetily exposes Tauri commands that let you push locally transcribed audio (processed by Whisper-rs or Parakeet) to external meeting platforms like Zoom, Microsoft Teams, and Google Meet through a Rust-based API layer.

Meetily is an open-source meeting assistant that performs speech-to-text locally using on-device AI models. According to the Zackriya-Solutions/meetily source code, the application exposes a set of API integration commands through its Tauri backend, allowing developers to synchronize transcripts with external meeting platforms while keeping sensitive audio data on the local machine.

Architecture Overview

The integration architecture follows a layered approach where local transcription remains decoupled from external platform synchronization:

• Frontend (React/TypeScript): Calls invoke → Tauri commands to trigger recording, transcription, and API actions from the UI.
• Tauri Core (Rust): frontend/src-tauri/src/lib.rs registers all commands as the central command hub, specifically exposing api_* commands through the invoke_handler! macro at lines 558-566.
• Audio Processing: The whisper_engine or parakeet_engine modules handle local transcription via whisper_transcribe_audio and parakeet_transcribe_audio commands.
• API Integration Layer: Located in frontend/src-tauri/src/api/*, this module wraps HTTP calls to external meeting platforms, manages API keys, and handles transcript uploads.
• Database Layer: frontend/src-tauri/src/database/* persists meeting metadata, transcript file paths, and platform-specific identifiers.

The typical integration flow works as follows: Start recording using start_recording_with_devices_and_meeting, process audio locally through the Whisper/Parakeet engine, persist the transcript locally with save_transcript, then push to the external platform using one of the api_* commands.

Integration Workflow

1. Configure Platform Credentials

Before pushing transcripts, authenticate with your external meeting service:

// Retrieve stored API key
const apiKey = await invoke('api_get_api_key', { service: 'zoom' });

// Save new credentials
await invoke('api_save_api_key', { 
  service: 'zoom', 
  apiKey: 'YOUR_ZOOM_JWT_TOKEN' 
});

2. Create or Locate Remote Meetings

Establish the remote meeting context before uploading transcripts:

// List existing meetings
const meetings = await invoke('api_get_meetings');

// Create new meeting
const meeting = await invoke('api_create_meeting', { 
  title: 'Team Sync',
  startTime: new Date().toISOString()
});
const remoteId = meeting.id; // Store for transcript association

3. Record and Transcribe Locally

Execute the standard Meetily workflow for local audio processing. The start_recording_with_devices_and_meeting command initiates capture, while the transcription worker in frontend/src-tauri/src/audio/transcription/worker.rs handles VAD (Voice Activity Detection), audio chunking, and confidence scoring through either Whisper-rs or Parakeet engines.

4. Upload Transcripts to External Platforms

After local transcription completes, push the text to the remote service:

const transcript = await invoke<string>('read_audio_file', { 
  file_path: localPath 
});

await invoke('api_save_transcript', {
  meetingId: remoteId,
  transcript,
  language: 'en' // Optional: Meetily supports auto-detection
});

Under the hood, api::api_save_transcript constructs an HTTP POST request to the platform-specific transcript endpoint (Zoom, Teams, etc.).

5. Update Meeting Metadata

Optionally synchronize meeting titles and metadata:

await invoke('api_save_meeting_title', { 
  meetingId: remoteId, 
  title: 'Weekly Stand-up' 
});

6. Handle Errors and Notifications

All api_* commands return Result<…, String> types. Catch errors on the frontend and display notifications using the built-in notification system at notifications::commands::show_notification.

Key API Commands for External Integration

Authentication Management

• api_get_api_key: Retrieves stored credentials for specified services (Zoom, Teams, Google Meet).
• api_save_api_key: Encrypts and persists API keys to the local database at frontend/src-tauri/src/database/*.

Meeting Lifecycle Management

• api_get_meetings: Fetches remote meeting lists from the external platform's API.
• api_create_meeting: Generates new meetings on the external service and returns a meeting_id for transcript association.
• api_save_meeting_title: Updates remote meeting metadata via platform-specific REST endpoints.

Transcript Upload

• api_save_transcript: The primary integration command located in frontend/src-tauri/src/api/commands.rs. Handles HTTP client initialization, authentication headers, and POST request construction.
• read_audio_file: Utility command that reads local transcript files from the recordings folder.

Implementation Examples

TypeScript Frontend Integration

This complete example demonstrates the full integration cycle from the React frontend:

import { invoke } from '@tauri-apps/api/tauri';

// Configure Zoom credentials
await invoke('api_save_api_key', { 
  service: 'zoom', 
  apiKey: 'YOUR_ZOOM_JWT' 
});

// Create remote meeting context
const meeting = await invoke<any>('api_create_meeting', {
  title: 'Project Kick-off',
  startTime: new Date().toISOString(),
});
const remoteId = meeting.id;

// Assume local transcription completed and saved to path
const localPath = '/Users/me/Meetily/recordings/kickoff.wav';
const transcript = await invoke<string>('read_audio_file', { 
  file_path: localPath 
});

// Push to external platform
await invoke('api_save_transcript', {
  meetingId: remoteId,
  transcript,
  language: 'en',
});

Node.js Script Integration

For automated workflows or external processing pipelines, invoke Tauri commands from Node.js using the Tauri API bridge:

const { invoke } = require('@tauri-apps/api/tauri');

async function pushTranscript(meetingId, transcriptPath) {
  const text = await invoke('read_audio_file', { 
    file_path: transcriptPath 
  });
  
  await invoke('api_save_transcript', {
    meetingId,
    transcript: text,
    language: 'auto',
  });
}

// Usage
pushTranscript('1234567890', '/tmp/meeting.wav');

Rust Extension Example

When extending Meetily's core functionality, use the internal API module directly:

use crate::api::commands::api_save_transcript;

async fn upload_transcript(
    app: &tauri::AppHandle, 
    meeting_id: &str, 
    txt: &str
) -> Result<(), String> {
    api_save_transcript(
        app, 
        meeting_id.to_string(), 
        txt.to_string(), 
        Some("en".into())
    ).await
}

Core Files and Their Roles

Understanding these source files is essential for custom integrations:

• frontend/src-tauri/src/lib.rs (lines 558-566): Command registration hub where all api_* commands are exposed to the frontend via the invoke_handler! macro.
• frontend/src-tauri/src/api/mod.rs: Module entry point that re-exports API sub-modules and initializes the HTTP client.
• frontend/src-tauri/src/api/commands.rs: Contains concrete implementations of platform-specific HTTP logic, authentication handling, and request building for external meeting services.
• frontend/src-tauri/src/api/api.rs: High-level wrapper used by the UI that abstracts platform differences behind a unified interface.
• frontend/src-tauri/src/whisper_engine/commands.rs: Entry point for local transcription using Whisper-rs, returning text that can subsequently be passed to api_save_transcript.
• frontend/src-tauri/src/audio/transcription/worker.rs: Background worker managing VAD, audio chunking, and transcription provider coordination.
• frontend/src-tauri/src/database/*: Persistence layer maintaining mappings between local recording IDs and remote platform meeting identifiers.

Summary

• Meetily performs local transcription using Whisper-rs or Parakeet, ensuring audio data never leaves the machine during speech-to-text processing.
• Tauri commands in the api_* namespace provide the integration interface to external meeting platforms including Zoom, Microsoft Teams, and Google Meet.
• The api_save_transcript command handles HTTP POST requests to push transcribed text to remote services while maintaining local copies.
• Authentication is managed through api_save_api_key and api_get_api_key, storing credentials securely in the local database.
• All integration points are accessible from TypeScript via invoke, from Node.js via the Tauri API bridge, or directly from Rust when extending the core application.

Frequently Asked Questions

Which external meeting platforms does Meetily support for transcript integration?

The API layer in frontend/src-tauri/src/api/commands.rs implements generic HTTP clients that support Zoom, Microsoft Teams, and Google Meet through their respective REST APIs. The modular architecture allows extending support to additional platforms by implementing the standard command interface for new services.

How does Meetily handle API key security when integrating with external platforms?

According to the source code in frontend/src-tauri/src/database/*, API keys are persisted locally on the user's machine using the application's secure storage layer. Keys are never transmitted to Meetily's servers, maintaining a zero-knowledge architecture where credentials remain under user control.

Can I use Meetily's local transcription without uploading to external platforms?

Yes. The transcription workflow in frontend/src-tauri/src/audio/transcription/worker.rs operates independently of the API module. Local transcripts are saved to the user's recordings folder via save_transcript, and external upload via api_save_transcript is entirely optional.

What is the performance impact of running local transcription alongside API uploads?

The architecture separates CPU-intensive transcription (handled by whisper_engine or parakeet_engine in Rust) from network I/O (handled by api_* commands). Transcription occurs in a background worker while API calls execute asynchronously, ensuring that uploading transcripts to external platforms does not block the local recording or transcription processes.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}