Desktop SDK Raw Media

Desktop SDK Raw Media improves recording quality and reduces local resource usage by capturing meeting media remotely instead of recording pixels and audio from the end user's computer.

Raw Media preserves the standard Desktop Recording SDK workflow: your application detects a meeting, creates a Desktop SDK Upload, and calls startRecording. No visible meeting bot is added to the call, and existing SDK events, realtime callbacks, artifacts, and upload webhooks continue to work as expected.

Benefits

When Raw Media is active:

• Media capture and processing run remotely, substantially reducing CPU and memory usage on the end user's computer.
• Participant video and screenshare quality are no longer dependent on the meeting window's size, visibility, or position.
• Video capture continues when the meeting window is covered, minimized, or on another macOS desktop space.
• Separate participant audio streams are available, enabling accurate speaker attribution and diarization.
• Realtime transcripts and participant events are produced from the meeting's underlying media rather than the visible meeting layout.
• For Microsoft Teams on macOS, authoritative meeting URLs can be emitted through meeting-updated without requiring Full Disk Access.

Raw Media is especially useful for applications that require consistent recording quality, reliable screenshare capture, participant-level media, or realtime transcription without placing a heavy processing load on the user's device.

Supported platforms

Raw Media is currently available for the following macOS meeting platforms:

Additional requirements:

• macOS 13 or later
• Apple Silicon Mac
• Raw Media enabled for your Recall.ai workspace
• The standard accessibility permission for meeting detection
• The relevant automation permission granted before a meeting begins

For Google Meet, the supported browser should be configured as the user's default browser before requesting browser-automation.

Raw Media is not currently used for:

• Windows
• Google Meet in Safari
• Google Meet in Chrome Beta
• Google Meet Progressive Web Apps
• Unsupported Chromium-based browsers

Meetings on unsupported configurations continue to use the existing local recording method. See Desktop Recording SDK Supported Platforms for general DSDK platform support.

How Raw Media works

The integration flow remains the same from your application's perspective:

1. The Desktop SDK emits meeting-detected.
2. Your backend creates a Desktop SDK Upload and returns its upload token.
3. Your application calls startRecording.
4. The SDK determines whether Raw Media is enabled and available.
5. When available, Recall.ai starts a remote capture session associated with the existing Desktop SDK Upload.
6. Your application receives the standard Desktop SDK events, realtime callbacks, artifacts, and upload webhooks.

The remote capture session adopts the recording configuration from the Desktop SDK Upload. Media is captured and processed remotely; it is not routed back through the user's computer.

Requesting automation permissions

Raw Media introduces one additional macOS permission for each supported meeting platform:

• Microsoft Teams: teams-automation
• Google Meet: browser-automation

These are pre-call permissions. Request them from a user-initiated onboarding or settings flow before a meeting starts.

Do not request them automatically at application startup or while a meeting is in progress. They are intentionally excluded from acquirePermissionsOnStartup.

const RecallAiSdk = require("@recallai/desktop-sdk");

await RecallAiSdk.init({
  apiUrl: "https://us-west-2.recall.ai",
  acquirePermissionsOnStartup: [],
});

RecallAiSdk.addEventListener("permission-status", ({ permission, status }) => {
  if (
    permission === "teams-automation" ||
    permission === "browser-automation"
  ) {
    console.log(`${permission}: ${status}`);
  }
});

// Call one of these from an explicit user interaction:
async function enableTeamsRawMedia() {
  await RecallAiSdk.requestPermission("teams-automation");
}

async function enableGoogleMeetRawMedia() {
  await RecallAiSdk.requestPermission("browser-automation");
}

Request only the permission relevant to the meeting platforms your application supports.

Recommended permission UX

Before calling requestPermission, explain that:

• The permission allows your application to prepare high-quality, low-resource meeting recording.
• macOS may ask the user to allow your application to control Teams or their browser.
• The selected meeting application or browser may restart once during setup.
• Open browser tabs and the user's current browser session will be restored automatically.
• The permission must be configured before joining a meeting.

Because setup may restart the target application, present a dedicated button such as Enable Teams recording or Enable Google Meet recording instead of requesting access without user interaction.

Permission states

Listen for permission-status to update your onboarding UI.

For Google Meet, browser-automation applies to the selected supported browser. Permission granted for one browser does not automatically authorize a different browser.

Existing macOS permissions and local fallback

Raw Media itself does not depend on local screen or system-audio capture. However, Recall.ai recommends continuing to request the standard DSDK recording permissions:

• accessibility
• microphone
• screen-capture, or system-audio for audio-only recording

These permissions allow the SDK to use its legacy local recording method when Raw Media is unavailable.

See macOS Permissions for the complete permission setup and required Info.plist entries.

Starting a Raw Media recording

There is no separate Raw Media recording method. Continue using the normal startRecording API:

RecallAiSdk.addEventListener("meeting-detected", async (evt) => {
  const upload = await createDesktopSdkUploadOnYourBackend();

  await RecallAiSdk.startRecording({
    windowId: evt.window.id,
    uploadToken: upload.upload_token,
  });
});

When the workspace and local environment support Raw Media, the SDK selects it automatically. Otherwise, it uses local recording.

Google Meet URL availability

Google Meet Raw Media requires the canonical https://meet.google.com/<meeting-code> URL.

The URL may not be present in the initial meeting-detected event. Subscribe to meeting-updated and retain the latest meeting object before starting a recording when window.url is initially missing.

const meetings = new Map();

RecallAiSdk.addEventListener("meeting-detected", ({ window }) => {
  meetings.set(window.id, window);
});

RecallAiSdk.addEventListener("meeting-updated", ({ window }) => {
  meetings.set(window.id, window);

  if (window.url) {
    // The canonical meeting URL is now available.
  }
});

Starting before the canonical URL is available may cause that recording to use the legacy local method.

See Desktop Recording SDK Event Types for the complete event reference.

Fallback behavior

Raw Media is designed to degrade safely to the existing local recording path.

The SDK uses local recording when, before remote recording begins:

• Raw Media is not enabled for the workspace.
• The operating system, meeting application, or browser is unsupported.
• The required automation permission is unavailable.
• Google Meet is open in a browser other than the browser authorized during setup.
• The meeting URL or authenticated meeting context is unavailable.
• The remote capture session cannot be initialized.
• The secure connection to the meeting application or browser cannot be established.

The SDK does not attempt to repair permissions, edit browser settings, or restart applications when startRecording is called.

After a Raw Media recording has started, temporary connections are automatically re-established where possible. The SDK does not start a second local recording during an active Raw Media recording, which prevents duplicate or conflicting recordings. A terminal remote failure is surfaced through the standard DSDK lifecycle and error events.

Events, artifacts, and webhooks

Raw Media uses the existing Desktop SDK event and upload lifecycle.

Your application can continue listening for:

• recording-started
• recording-ended
• meeting-updated
• media-capture-status
• participant-capture-status
• realtime-event
• compliance-message-status
• error

The existing Desktop SDK Upload continues to own the recording, artifacts, realtime endpoints, billing, and webhooks. Raw Media does not create a second customer-visible recording or bot resource.

Beta platform coverage

Raw Media is being rolled out one meeting platform and operating system at a time. Unsupported platforms continue using local recording.

Browser-specific setup

Google Meet automation is browser-specific. If the user changes their default browser or begins using a different supported browser, they may need to complete browser-automation setup again.

Frequently asked questions

Is a meeting bot visible?

No normal meeting-bot tile is added. Google Meet uses companion participation, and Teams uses the signed-in desktop meeting context.

Does Raw Media require Full Disk Access?

Raw Media does not require Full Disk Access for media capture. Teams Raw Media can also provide authoritative meeting URLs through meeting-updated without Full Disk Access.

If your application depends on legacy local Teams URL extraction or local fallback behavior, retain the existing Full Disk Access guidance for those paths.

What happens if the user does not grant automation access?

The SDK uses the existing local recording method, provided the standard local recording permissions are available.

Will the browser restart?

The supported browser may restart once while browser-automation is being configured. The SDK restores the browser session so users do not lose their open tabs or place.

The SDK will not restart the browser while a Google Meet call is active.

Can users record Google Meet in Safari?

Yes, Safari remains supported by the Desktop SDK's local recording method on macOS. Safari does not currently use Raw Media.

Does Raw Media work on Windows?

Not currently. Windows continues to use the existing local Desktop SDK recording method.