Diagnose getUserMedia "Requested device not found"

The short answer

"Requested device not found" is the message Chromium-based browsers attach to a getUserMedia rejection whose error name is NotFoundError. Older Chrome versions used the name DevicesNotFoundError. It means the browser could not find any input device of the kind you asked for. It is not a permission refusal and not a busy-device error. In most cases the page asked for audio, video or both, and at least one of those device types was not available to the browser when the call ran.

There is an important limitation when you capture speech through a webcam. A request for audio and video together fails completely if either kind is missing. A webcam whose built-in microphone is not exposed to the browser can therefore block the camera as well, even though the camera itself works.

How it differs from other getUserMedia errors

The error name tells you which branch of diagnosis to follow. Read the name property of the rejected error rather than its message, because message wording differs between browsers.

Error name | What it generally indicates | Where to look first

NotFoundError | No device of the requested kind is visible to the browser | Device connection, OS input list, OS privacy settings, the shape of the request

NotAllowedError | The user, browser policy or embedding page denied access | Site permission, iframe permissions policy, OS privacy prompt

NotReadableError | A device exists but could not be opened | Another app holding the device, driver or OS-level fault

OverconstrainedError | Devices exist, but none satisfy a required constraint | Exact deviceId, sampleRate, channelCount or similar required values

TypeError (or mediaDevices undefined) | The call itself is invalid or the API is unavailable | Empty constraints, or a page that is not a secure context (HTTPS or localhost)

Browsers have not always been consistent at the edges. A stale or nonexistent deviceId passed as an exact constraint is specified to produce OverconstrainedError, but some browser versions have reported NotFoundError instead. The same applies when an operating system privacy switch blocks microphone access: depending on the browser and OS, it can surface as a denial or as no devices found. If the name you see doesn't fit the table, check the neighbouring branches too.

Isolating the cause

Begin with the checks that change nothing permanently, and treat each suspected cause as a hypothesis until a result confirms it. The steps below run from the page code outward to the hardware.

1. Check what the page actually requested

Log the exact constraints object passed to getUserMedia. Three patterns account for many NotFoundError reports.

• audio and video both set to true on a machine that has only one of them, such as a webcam whose microphone is disabled or a laptop with no camera.
• A deviceId saved from an earlier session, for example in local storage, that no longer matches any device. Device IDs are specific to the origin and can change when site data is cleared or the device is reconnected.
• A required constraint such as an exact deviceId or groupId copied from another machine or another browser profile.

To test, request audio alone with audio set to true and no other constraints. If that succeeds, the microphone is reachable and the original request is the problem. If it still fails with NotFoundError, the browser cannot see any audio input, and you should continue to the next step.

2. List the devices the browser can see

navigator.mediaDevices.enumerateDevices() returns the inputs and outputs the browser exposes to the page. Until the site has been granted permission, labels are blank and the list may be reduced or anonymised. Run the check again after a successful grant to see the full picture. The snippet below is a minimal diagnostic you can paste into the developer console on the affected page.

const devices = await navigator.mediaDevices.enumerateDevices();
const mics = devices.filter(d => d.kind === 'audioinput');
const cams = devices.filter(d => d.kind === 'videoinput');
console.log('audio inputs:', mics.length, mics.map(d => d.label || '(no label)'));
console.log('video inputs:', cams.length, cams.map(d => d.label || '(no label)'));

try {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  console.log('audio OK:', stream.getAudioTracks()[0].label);
  stream.getTracks().forEach(t => t.stop());
} catch (err) {
  console.log('audio failed:', err.name, err.message);
}

• Zero audio inputs: the browser sees no microphone at all. The cause lies in the operating system, the connection or the hardware rather than the page.
• Audio inputs listed, but the webcam microphone is missing: the OS may be exposing a different default device, or the webcam's audio interface is not enumerating. Continue to step 4.
• Webcam microphone listed and an audio-only request succeeds: the device is fine. Fix the original constraints, for example by selecting a current deviceId from this list instead of a saved one.

On Chromium browsers on Windows you may also see entries with the IDs "default" and "communications". These follow the OS default and communications device settings, so they can point at a headset rather than the webcam. If the speech you capture comes from the wrong microphone, that is an input-selection issue, not this error, but the same device list is where you resolve it.

3. Rule out browser and environment factors

• Try another browser profile or a private window to exclude extensions and corrupted site data.
• Try a second browser. If one browser sees the microphone and another does not, the problem is browser-side rather than hardware.
• If the page runs inside an iframe, confirm the embedding page allows microphone and camera access. A block here usually produces NotAllowedError, but it is quick to rule out.
• Virtual machines, remote desktop sessions, containers and headless CI runners often have no audio input device unless one is passed through. For automated tests, Chromium's fake media device flags can supply a synthetic stream, but that only confirms the code path, not real hardware.

4. Check the operating system

The browser can only list devices the OS presents to it. Open the system sound input settings and look for the webcam microphone.

• Windows: check that microphone access is allowed for apps and for desktop apps in privacy settings, and that the device is not disabled in the Sound control panel's Recording tab. A disabled device is hidden from applications.
• macOS: check that the browser is allowed under Microphone in Privacy & Security settings. Restart the browser after changing it.
• Linux: confirm that the audio server (PipeWire or PulseAudio) lists the webcam as a source and that its profile is not set to Off.
• If a test recording in another application, such as the system voice recorder, picks up speech from the webcam microphone, the hardware and OS are working, and the cause lies between the OS and the browser.

5. Check the connection and hardware

If the OS does not list the webcam microphone at all, focus on the physical link. A USB webcam typically presents its microphone as a separate audio interface alongside the video interface. Because of this, the camera can appear while the microphone does not.

• Unplug the webcam, wait a moment and reconnect it. Then reload the page; pages can also listen for the devicechange event to pick up hot-plugged devices.
• Connect it directly to a computer port instead of a hub or dock, and try another port.
• Try a different cable if the webcam uses a detachable one.
• Connect the webcam to a second computer. If no system lists its microphone, the fault travels with the device.

When service or replacement is justified

Service or replacement is reasonable when the webcam microphone fails to appear as an input on more than one computer, across direct ports and cables, while other USB audio devices work on the same machines. Check the manufacturer's warranty terms and any driver or firmware updates they publish before replacing it. If the microphone appears in the OS and records in other apps but one browser still reports NotFoundError, the hardware is not the problem. Pursue a browser update, profile reset or the request changes described above instead.

Preventing the error in your own pages

• Request audio and video separately, or catch NotFoundError on a combined request and retry with only the available kind, so a missing microphone does not take the camera down with it.
• Treat saved deviceIds as preferences: pass them as ideal rather than exact, or check them against a fresh enumerateDevices() list before use.
• Show the user a device picker built from the current list, and refresh it on devicechange.
• Report the error name to the user in plain terms, for example: no microphone was found, check that it is connected and enabled.

Evidence gaps

This guide is based on documented API behaviour and general troubleshooting principles. It does not cover specific webcam models, version-by-version browser behaviour or measured failure rates. Exactly which error name a given browser, OS and privacy setting produces can vary, so confirm against the browser you are supporting rather than relying on the mapping above alone.