Introduction

Playwright for Python has rapidly become one of the most advanced tools for browser automation and end-to-end testing. It is designed to help developers and QA engineers script browser interactions, simulate user behavior, and even capture video recordings of test sessions. However, one common misconception is that Playwright can also record audio from the browser or microphone.

Here’s the truth: Playwright Python cannot record audio. It can only capture browser actions and visual recordings of sessions. To capture sound, developers must use dedicated Python audio libraries such as PyAudio, PvRecorder, or python-sounddevice.

This article provides a detailed explanation of what Playwright can and cannot record, how to record audio in Python, and how to combine both for complete video-plus-audio recording setups.

Understanding Playwright’s Recording Capabilities

When used effectively, Playwright is a powerhouse for automating modern web browsers such as Chromium, Firefox, and WebKit. But its recording capabilities focus on automation clarity, not multimedia capture.

What Playwright Can Record

User Actions (Codegen)

Playwright’s primary recording feature is codegen, a command-line tool that records your actions in a browser and converts them into a ready-to-run Python script. This lets developers generate automated scripts by simply interacting with a browser — no manual coding required.

Example command:

playwright codegen https://example.com --target python

When you run this, Playwright opens the specified page and records your clicks, typing, and navigations, generating clean automation code in real time. This is ideal for rapidly building robust test scripts without guesswork.

Session Videos (Visual Only)

Playwright also offers video recording of test sessions—an invaluable feature for debugging CI/CD pipelines and understanding test behavior. However, these recordings are purely visual. The generated videos contain no sound from the browser or system audio.

You can enable video capture in your test configuration or context options like so:

browser.new_context(record_video_dir="videos/")

This setting will save a silent video of each session, providing helpful playback for visual debugging.

What Playwright Cannot Record

Despite its video capabilities, Playwright cannot record audio. It doesn’t have any API for:

• Capturing browser sound (e.g., media playback within a webpage)
• Recording microphone input
• Accessing system-level audio streams

Playwright’s built-in functionality is limited to recording user actions and visual footage. If you need sound, you must use an audio recording library separately.

How to Record Audio in Python

Since Playwright doesn’t support audio recording, developers can turn to Python’s excellent ecosystem of audio processing libraries. These tools let you capture microphone input, system sound (with configurations), and even process or analyze recorded audio.

Popular Python Audio Libraries

Library	Description	Difficulty
PyAudio	Direct interface to the PortAudio library. Flexible but can be tricky on Windows.	Moderate
PvRecorder	Simple, cross-platform audio recorder built on modern frameworks.	Easy
python-sounddevice	Lightweight and user-friendly, ideal for quick tasks.	Easy

Each library provides different levels of control and setup complexity, depending on your environment and goals.

Example: Recording with PyAudio

Here’s how to capture a 5‑second audio clip using PyAudio and save it as a .wav file:

import pyaudio
import wave

CHUNK = 1024
FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 44100
RECORD_SECONDS = 5
OUTPUT_FILENAME = "output.wav"

p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
                channels=CHANNELS,
                rate=RATE,
                input=True,
                frames_per_buffer=CHUNK)

frames = []
print("Recording...")
for _ in range(int(RATE / CHUNK * RECORD_SECONDS)):
    data = stream.read(CHUNK)
    frames.append(data)
print("Finished recording.")

stream.stop_stream()
stream.close()
p.terminate()

wf = wave.open(OUTPUT_FILENAME, 'wb')
wf.setnchannels(CHANNELS)
wf.setsampwidth(p.get_sample_size(FORMAT))
wf.setframerate(RATE)
wf.writeframes(b''.join(frames))
wf.close()

How it works:
The code initializes an input audio stream, records 5 seconds of sound from your default microphone, and writes it to a standard WAV file. This approach is ideal for simple local recordings.

Example: Recording with PvRecorder

If you’re looking for a lightweight, cross-platform alternative, PvRecorder is exceptionally simple to use. Here’s a minimal example:

from pvrecorder import PvRecorder
import wave

recorder = PvRecorder(device_index=-1, frame_length=512)
recorder.start()
frames = []

for _ in range(0, int(16000 / 512 * 5)):  # 5 seconds
    frame = recorder.read()
    frames.append(frame)
recorder.stop()
recorder.delete()

wf = wave.open('output.wav', 'wb')
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(16000)
wf.writeframes(b''.join(frames))
wf.close()

With PvRecorder, you can easily define the frame length and sampling rate. It’s also well-suited for applications involving speech recognition or integration with frameworks like Picovoice.

Combining Playwright and Audio Recording

Why Combine Them?

There are scenarios where it makes sense to use both:

• Testing web applications that involve sound playback, such as music players or video conferencing tools.
• Automating audio-driven workflows, like voice recognition services.
• Recording commentary or voice notes while automation scripts execute.

How to Run Both Simultaneously

While Playwright and audio recorders don’t integrate natively, you can run them concurrently using Python’s threading or asynchronous programming features.

Example Workflow:

• Thread 1: Executes Playwright scripts — automating browser behavior and optionally recording a silent video.
• Thread 2: Uses PyAudio or PvRecorder to capture microphone or system sound.

By starting both threads at once, you can create a synchronized audio-video log of a test — though each stream remains separate.

Key Takeaway

There is no direct integration between Playwright’s browser sessions and your Python audio capture. To record both audio and visuals:

• Run the audio recording and Playwright browser automation side‑by‑side.
• Manually align the outputs in post‑processing (for example, using video editing tools).

Summary Table

Feature	Playwright Python	PyAudio / PvRecorder / Sounddevice
Record browser actions	✅ Yes	❌ No
Record browser session video	✅ Yes	❌ No
Record browser/system audio	❌ No	✅ Yes
Record microphone input	❌ No	✅ Yes
Save output to file	✅ (script/video)	✅ (audio file)

This comparison makes it clear: Playwright handles the visuals, and audio libraries handle the sound.

Important Limitations & Workarounds

While Playwright’s video recordings are helpful, the current version (as of 2024) provides no audio capture API. Here are some practical notes to consider:

• Recording browser playback sound (e.g., YouTube or Spotify test sessions) requires configuring your system audio input to a “loopback” or “Stereo Mix” device. This allows external libraries like PyAudio to capture output as input.
• Recording microphone input directly during a Playwright session must be done independently using audio libraries.
• These are environment-specific solutions, not limitations of Python itself—but they fall outside Playwright’s design scope.

If you need combined audiovisual testing output, you can use screen recording software at the OS level while Playwright runs your test suite.

Conclusion

Playwright for Python excels at browser automation — generating scripts, running tests, and capturing high-quality visual recordings of browser sessions. However, it does not support audio recording of any kind.

To include audio:

• Use dedicated Python libraries like PyAudio, PvRecorder, or python-sounddevice.
• Coordinate browser and sound recording using threading or asynchronous routines.

Together, these tools deliver a complete solution when you need both video evidence of automated browser tests and accompanying audio logs.

If your goal is full AV (audio‑visual) test recording, design your automation pipeline to use both tools independently. Playwright for visuals, Python audio libraries for sound capture — synchronized to create a holistic testing record.

FAQs

Can Playwright record sound from my browser or microphone?

No. Playwright can only record browser actions and video footage. It has no API support for audio capture from the browser or microphone.

How can I record browser audio during automated tests?

You’ll need external methods. System‑level tools such as Stereo Mix or virtual audio loopback devices let your Python audio recorder capture playback. Playwright itself cannot access browser sound.

What’s the easiest way to record audio in Python?

For beginners, python‑sounddevice or PvRecorder offer simple syntax and minimal setup. They allow quick microphone recording without complex configuration.

Can I integrate Playwright and PyAudio directly?

Not directly. You can run both processes simultaneously in a single Python program, but neither depends on the other. Synchronization must be handled manually.

Will future versions of Playwright support audio capture?

As of 2024, there’s no published roadmap mentioning browser or microphone audio recording in Playwright. Its team remains focused on browser automation and test visualization.

Can Playwright’s video recording replace audio‑video capture?

Only if you don’t need sound. Playwright videos are silent and best used for reviewing test interactions visually.

Key Takeaway:

Playwright for Python empowers developers to record browser actions and silent visual sessions, but not audio. For capturing sound, use PyAudio, PvRecorder, or python‑sounddevice, and coordinate them with Playwright scripts to produce synchronized automation recordings.

External Resource:
Learn more about Playwright’s media recording options at the official Microsoft Playwright documentation.