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

> Integrate Meetily local transcriptions with Zoom, Teams, and Meet via API. Push audio processed by Whisper-rs or Parakeet using our Rust API layer.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: how-to-guide
- Published: 2026-08-02

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
// 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:

```typescript
// 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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
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:

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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:

```typescript
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:

```javascript
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:

```rust
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.