# How to Integrate Meetily with Other Applications: A Complete Tauri Integration Guide

> Integrate Meetily with external apps via Tauri. Invoke commands from the frontend, listen for real-time events, and access the SQLite database for seamless integration.

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

---

**You can integrate Meetily with external applications by invoking Tauri commands from the frontend using `@tauri-apps/api`, listening to real-time events like `transcript-update`, and accessing the SQLite database through the exposed `api_*` command layer.**

Meetily is a self-contained desktop application built by Zackriya-Solutions using Tauri and Next.js. To integrate Meetily with other applications, you interact with its Rust-based backend through the frontend API, enabling automation, custom workflows, and third-party service connections without modifying core system files.

## Understanding Meetily's Tauri-Based Architecture

### The Command Registry Pattern

All public APIs are declared with `#[tauri::command]` attributes in the Rust backend. The `run()` function in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) registers every command through the `invoke_handler!` macro, creating a thin, well-typed surface for integration. Any new integration point requires only adding a command function to this registry.

### Core System Layers

- **Frontend UI**: React components in `frontend/src/app/` use `invoke` to call backend commands and `listen` to react to events.
- **Audio System**: Located in `frontend/src-tauri/src/audio/`, handles device discovery, professional mixing, and recording management.
- **AI Engines**: Whisper and Parakeet implementations in `frontend/src-tauri/src/whisper_engine/` and `parakeet_engine/` directories.
- **Database Layer**: SQLite operations exposed through `api_*` commands defined in [`frontend/src-tauri/src/api/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/mod.rs).

## Methods to Integrate Meetily with Other Applications

### Invoking Backend Commands

External integration starts with calling Tauri commands from the frontend using `@tauri-apps/api/core`. The `invoke` function accepts command names registered in [`lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/lib.rs) and passes serialized arguments to the Rust backend. All recording, AI, and database operations are accessible through this pattern.

### Subscribing to Real-Time Events

The application emits events such as `transcript-update` during audio processing. Use the `listen` function from `@tauri-apps/api/event` to capture live transcription data and forward it to external services or update UI components in real time.

### Leveraging the Database API

The `api_*` command family provides CRUD operations for meetings, transcripts, and configuration. These commands in [`frontend/src-tauri/src/api/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/mod.rs) allow reading and writing to the SQLite database without direct file access, enabling persistent integration state management.

## Practical Integration Code Examples

### Starting a Recording Programmatically

Trigger recordings from any external widget or automation script by invoking the `start_recording_with_devices_and_meeting` command defined in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs).

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

async function startMeetilyRecording() {
  await invoke('start_recording_with_devices_and_meeting', {
    mic_device_name: 'Built-in Microphone',
    system_device_name: 'BlackHole 2ch',
    meeting_name: 'Quarterly Review',
  });
}

```

### Capturing Live Transcript Updates

Listen for the `transcript-update` event emitted by the audio pipeline to stream text to external webhooks or databases in real time.

```typescript
import { listen } from '@tauri-apps/api/event';

async function subscribeToTranscripts() {
  await listen<{
    text: string;
    timestamp: number;
  }>('transcript-update', event => {
    console.log('New snippet:', event.payload);
    // Forward to external webhook, store in DB, etc.
  });
}

```

### Configuring Custom AI Endpoints

Swap LLM providers at runtime by updating the custom OpenAI configuration using `api_save_custom_openai_config` and verify connectivity with `api_test_custom_openai_connection`.

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

async function setCustomOpenAI() {
  await invoke('api_save_custom_openai_config', {
    config: {
      base_url: 'http://localhost:8000/v1',
      api_key: 'sk-my-local-key',
    },
  });

  const result = await invoke('api_test_custom_openai_connection');
  console.log('Connection test:', result);
}

```

### Exporting Meeting Data

Export completed meetings by calling database commands and saving files to accessible locations using `save_transcript` and `open_meeting_folder`.

```typescript
import { invoke } from '@tauri-apps/api/core';
import { path } from '@tauri-apps/api';

async function exportMeeting(meetingId: string) {
  const folder = await path.appDataDir();
  const markdownPath = `${folder}/exports/${meetingId}.md`;

  const transcript = await invoke<string>('api_get_meeting_transcripts', { meetingId });
  await invoke('save_transcript', { file_path: markdownPath, content: transcript });
  
  await invoke('open_meeting_folder', { meetingId });
}

```

## Key Integration Points in the Source Code

### Command Registration

The `invoke_handler!` macro in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) registers all available commands, including `track_event` for analytics and `show_notification` for system alerts.

### Audio Commands

[`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) contains the core recording API for start/stop operations and device selection.

### AI Engine Commands

[`frontend/src-tauri/src/whisper_engine/commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/whisper_engine/commands.rs) manages model lifecycle operations including initialization, loading, and transcription via `whisper_transcribe_audio`.

### Frontend Service Wrappers

[`frontend/src/services/recordingService.ts`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src/services/recordingService.ts) provides TypeScript wrappers around the `invoke` calls, offering type-safe interfaces for recording operations.

## Summary

- **Meetily uses Tauri's command pattern** to expose Rust backend functionality to the Next.js frontend and external integrations.
- **All commands are registered** in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) through the `invoke_handler!` macro, providing a stable API surface.
- **Real-time integration** is possible by listening to events like `transcript-update` emitted during audio processing.
- **Database operations** are accessible through the `api_*` command family, enabling programmatic access to meetings and transcripts.
- **Custom AI providers** can be configured at runtime without restarting the application using the custom OpenAI config commands.

## Frequently Asked Questions

### Can I integrate Meetily with my existing CRM or project management tool?

Yes. You can build a bridge by listening to the `transcript-update` event in a custom React component and forwarding the payload to your CRM's REST API. Alternatively, query completed transcripts using `api_get_meeting_transcripts` and push them to external systems on demand.

### How do I trigger a recording from an external application?

Use the `invoke` function to call `start_recording_with_devices_and_meeting` with specific device names and a meeting identifier. This command is implemented in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) and accepts parameters for microphone and system audio devices.

### Is it possible to switch AI providers without restarting Meetily?

Yes. Call `api_save_custom_openai_config` to update the base URL and API key, then verify the connection with `api_test_custom_openai_connection`. These commands are defined in the API module and allow runtime configuration of OpenAI-compatible endpoints.

### Where are the integration entry points defined in the source code?

All integration entry points are defined in [`frontend/src-tauri/src/lib.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/lib.rs) within the `invoke_handler!` macro. Additional command implementations are located in [`frontend/src-tauri/src/audio/recording_commands.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) for recording operations and [`frontend/src-tauri/src/api/mod.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/api/mod.rs) for database interactions.