What Permissions Are Required for Audio Capture in Meetily on macOS?

Meetily requires both microphone and screen recording permissions on macOS to capture meeting audio, with screen recording being mandatory for ScreenCaptureKit-based system audio capture.

The open-source meeting assistant Meetily (Zackriya-Solutions/meetily) relies on specific macOS system entitlements to record both microphone input and system audio during meetings. Understanding these permission requirements is essential for users and developers, as missing entitlements will cause the Rust backend to abort recording initialization before any audio streams begin.

Required macOS Permissions for Audio Capture

Meetily’s macOS build needs two distinct system permissions before it can capture audio:

• Microphone Access: Allows the app to record from the built-in or external microphone
• Screen Recording Permission: Required because Meetily uses Apple’s ScreenCaptureKit to capture system audio, which is tied to the screen-recording entitlement

According to the repository documentation, these permissions are enforced at the system level before the audio backend can initialize capture streams.

Why Screen Recording Permission Is Required for Audio

On macOS, system audio capture relies on ScreenCaptureKit, which requires the screen recording permission even when only capturing audio. This architectural requirement is implemented in frontend/src-tauri/src/audio/capture/backend_config.rs, where ScreenCaptureKit is defined as the default audio backend for macOS targets.

The macOS-specific device enumeration module at frontend/src-tauri/src/audio/devices/platform/macos.rs prepares the ScreenCaptureKit stream, which cannot initialize without the screen recording entitlement granted by the user in System Preferences → Security & Privacy.

Permission Check Implementation in Rust

When the Tauri command start_recording is invoked, the Rust side verifies that both permissions have been granted before initializing the capture pipeline. The implementation in frontend/src-tauri/src/audio/recording_commands.rs checks permissions early and aborts with descriptive errors if access is denied.

#[tauri::command]
async fn start_recording(
    app: tauri::AppHandle,
    mic: Option<String>,
    system: Option<String>,
    meeting_name: Option<String>,
) -> Result<(), String> {
    // Verify macOS permissions early
    #[cfg(target_os = "macos")]
    {
        use tauri::api::permission::request_permission;
        // Microphone
        request_permission(&app, "audio").await
            .map_err(|e| format!("Microphone permission denied: {}", e))?;
        // Screen recording (required for ScreenCaptureKit)
        request_permission(&app, "screen").await
            .map_err(|e| format!("Screen‑recording permission denied: {}", e))?;
    }

    // Proceed with normal recording setup …
    audio::recording_commands::start(app, mic, system, meeting_name).await
}

The recording_manager.rs file orchestrates these parallel audio paths (microphone + system) and ensures they share a consistent 48 kHz sample rate once permissions are verified.

Frontend Permission Handling

The TypeScript frontend invokes these permissions through Tauri’s API before starting a recording session:

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

async function startMeeting() {
  try {
    await invoke('start_recording', {
      mic_device_name: 'Built-in Microphone',
      system_device_name: 'BlackHole 2ch',
      meeting_name: 'Team Sync',
    });
  } catch (e) {
    // Show a helpful UI message directing the user to System Preferences
    alert(
      'Meetily needs access to your microphone and screen recording. Please enable them in System Preferences → Security & Privacy.'
    );
  }
}

Alternatively, permissions can be requested explicitly using Tauri’s permission API:

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

async function ensurePermissions() {
  await requestPermission('audio');   // Microphone
  await requestPermission('screen');  // Screen recording (ScreenCaptureKit)
}

Virtual Audio Device Requirements

While not a system permission, successful system audio capture requires a virtual audio device such as BlackHole to route output audio into the capture pipeline. Users must install this device separately and select it in Meetily’s settings before ScreenCaptureKit can capture system audio.

This routing setup is handled by the platform-specific implementation in frontend/src-tauri/src/audio/devices/platform/macos.rs, which enumerates available audio devices including virtual outputs.

Key Source Files

The following files in the Zackriya-Solutions/meetily repository handle macOS audio permissions and capture:

• frontend/src-tauri/src/audio/capture/backend_config.rs: Defines ScreenCaptureKit as the default macOS audio backend
• frontend/src-tauri/src/audio/devices/platform/macos.rs: Platform-specific device enumeration and ScreenCaptureKit integration
• frontend/src-tauri/src/audio/recording_manager.rs: Orchestrates mic and system audio streams with permission coordination
• frontend/src-tauri/src/audio/recording_commands.rs: Implements the start_recording Tauri command with permission checks

Summary

• Two permissions required: Microphone access and screen recording permission are both mandatory for audio capture in Meetily on macOS
• ScreenCaptureKit dependency: Screen recording permission is required specifically because Meetily uses Apple's ScreenCaptureKit for system audio capture
• Early validation: The start_recording command in recording_commands.rs validates permissions before initializing the audio backend
• Virtual device needed: BlackHole or similar virtual audio devices are required for system audio routing but must be installed separately
• Frontend coordination: TypeScript frontend handles permission requests through Tauri’s API and surfaces errors to users

Frequently Asked Questions

Why does Meetily need screen recording permission for audio-only capture?

Meetily uses Apple's ScreenCaptureKit framework to capture system audio, which is technically classified as a screen recording API on macOS. Even when capturing only audio streams, macOS requires the screen recording entitlement to access the ScreenCaptureKit interface, as configured in frontend/src-tauri/src/audio/capture/backend_config.rs.

What happens if a user denies microphone permission in Meetily?

If microphone permission is denied, the start_recording command in frontend/src-tauri/src/audio/recording_commands.rs catches the permission error and returns a formatted string error message. The frontend then surfaces an alert directing the user to System Preferences → Security & Privacy to enable microphone access before retrying.

Is BlackHole a required permission or a separate installation?

BlackHole is not a system permission but a separate virtual audio driver that must be installed manually. It routes system output into Meetily's capture pipeline. While macOS permissions control access to hardware, BlackHole acts as a software audio device that appears in the device enumeration logic in frontend/src-tauri/src/audio/devices/platform/macos.rs.

Does Meetily check permissions before every recording session?

Yes. According to the implementation in frontend/src-tauri/src/audio/recording_commands.rs, permission checks run every time the start_recording Tauri command is invoked. This ensures that if a user revokes permissions between sessions, Meetily will immediately detect the change and abort the recording with an appropriate error message.

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