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

> Meetily needs microphone and screen recording permissions on macOS for audio capture. Learn why screen recording is essential for system audio.

- Repository: [Zackriya Solutions/meetily](https://github.com/Zackriya-Solutions/meetily)
- Tags: documentation
- Published: 2026-07-12

---

**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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/recording_commands.rs) checks permissions early and aborts with descriptive errors if access is denied.

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

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

```typescript
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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/frontend/src-tauri/src/audio/devices/platform/macos.rs)**: Platform-specific device enumeration and ScreenCaptureKit integration
- **[`frontend/src-tauri/src/audio/recording_manager.rs`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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`](https://github.com/Zackriya-Solutions/meetily/blob/main/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.