How to Capture Desktop Screen with DXcam in Python

DXcam is built specifically for high-performance screen capture on Windows. It uses the DirectX Desktop Duplication API to achieve capture speeds that other libraries can’t match. If you search for a cross-platform alternative, it is Python MSS.

At the moment of publishing the guide, the library was last updated in 2023. In case you are going to use desktop screen capture for production-ready projects, check out our guide on Python MSS, it is still actively maintained.

If because of any reason you decide to use DXcam or because of its specific features, continue reading the guide.

Installation and Basic Usage

Install the library using pip:

1
pip install dxcam

Then run the following code to capture a single frame to test the library works:

1
import dxcam
2

3
# Create a camera
4
camera = dxcam.create()
5

6
# Capture a single frame
7
frame = camera.grab()
8

9
if frame is not None:
10
    print(f"Captured frame: {frame.shape}")

The returned frame is a NumPy array ready for processing.

Saving Screenshots

1
import dxcam
2
import cv2
3

4
camera = dxcam.create(output_color="BGR")  # BGR for OpenCV
5
frame = camera.grab()
6

7
if frame is not None:
8
    cv2.imwrite('screenshot.png', frame)

Or with PIL:

1
import dxcam
2
from PIL import Image
3

4
camera = dxcam.create(output_color="RGB")
5
frame = camera.grab()
6

7
if frame is not None:
8
    img = Image.fromarray(frame)
9
    img.save('screenshot.png')

Video Mode (Continuous Capture)

For high-FPS continuous capture:

1
import dxcam
2
import time
3

4
camera = dxcam.create()
5
camera.start(target_fps=60)
6

7
# Capture for 5 seconds
8
frames = []
9
start = time.time()
10

11
while time.time() - start < 5:
12
    frame = camera.get_latest_frame()
13
    if frame is not None:
14
        frames.append(frame.copy())
15

16
camera.stop()
17

18
print(f"Captured {len(frames)} frames in 5 seconds")
19
print(f"Effective FPS: {len(frames) / 5:.1f}")

Capture Specific Region

1
import dxcam
2

3
camera = dxcam.create()
4

5
# Region: (left, top, right, bottom)
6
frame = camera.grab(region=(0, 0, 500, 500))
7

8
if frame is not None:
9
    print(f"Region shape: {frame.shape}")

Capture Specific Monitor

1
import dxcam
2

3
# List available devices
4
devices = dxcam.device_info()
5
print("Available devices:", devices)
6

7
# Create camera for specific output (monitor)
8
camera = dxcam.create(output_idx=0)  # First monitor
9
# camera = dxcam.create(output_idx=1)  # Second monitor

Lower Resolution Capture

For faster processing, capture at lower resolution:

1
import dxcam
2

3
# Standard capture
4
camera = dxcam.create()
5
frame = camera.grab()
6
print(f"Full resolution: {frame.shape}")
7

8
# Capture region at lower resolution
9
region = (0, 0, 960, 540)  # Half of 1920x1080
10
frame = camera.grab(region=region)
11
print(f"Lower resolution: {frame.shape}")

Output Color Formats

1
import dxcam
2

3
# RGB format (default)
4
camera_rgb = dxcam.create(output_color="RGB")
5

6
# BGR format (for OpenCV)
7
camera_bgr = dxcam.create(output_color="BGR")
8

9
# BGRA format (with alpha channel)
10
camera_bgra = dxcam.create(output_color="BGRA")

Performance Benchmarking

1
import dxcam
2
import time
3

4
camera = dxcam.create()
5

6
# Single frame benchmark
7
start = time.time()
8
for _ in range(100):
9
    camera.grab()
10
elapsed = time.time() - start
11
print(f"Single grab FPS: {100 / elapsed:.1f}")
12

13
# Video mode benchmark
14
camera.start(target_fps=240)
15
time.sleep(2)
16

17
frames_captured = 0
18
start = time.time()
19
while time.time() - start < 5:
20
    frame = camera.get_latest_frame()
21
    if frame is not None:
22
        frames_captured += 1
23

24
camera.stop()
25
print(f"Video mode FPS: {frames_captured / 5:.1f}")

Typical results on a modern system: 240+ FPS

Full Screen Recording Example

1
import dxcam
2
import cv2
3
import time
4
from collections import deque
5

6
def record_screen(duration=5, fps=30, output='recording.mp4'):
7
    camera = dxcam.create(output_color="BGR")
8

9
    # Get first frame to determine dimensions
10
    first_frame = camera.grab()
11
    height, width = first_frame.shape[:2]
12

13
    # Set up video writer
14
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
15
    out = cv2.VideoWriter(output, fourcc, fps, (width, height))
16

17
    # Start capture
18
    camera.start(target_fps=fps)
19

20
    start = time.time()
21
    frames_written = 0
22

23
    while time.time() - start < duration:
24
        frame = camera.get_latest_frame()
25
        if frame is not None:
26
            out.write(frame)
27
            frames_written += 1
28

29
    camera.stop()
30
    out.release()
31

32
    print(f"Recorded {frames_written} frames to {output}")
33

34
record_screen(duration=5, fps=30)

Real-Time Processing Example

1
import dxcam
2
import cv2
3

4
def live_preview():
5
    """Display live screen capture with FPS counter."""
6
    camera = dxcam.create(output_color="BGR")
7
    camera.start(target_fps=60)
8

9
    frame_count = 0
10
    start_time = cv2.getTickCount()
11

12
    while True:
13
        frame = camera.get_latest_frame()
14
        if frame is None:
15
            continue
16

17
        # Calculate FPS
18
        frame_count += 1
19
        elapsed = (cv2.getTickCount() - start_time) / cv2.getTickFrequency()
20
        fps = frame_count / elapsed
21

22
        # Add FPS text
23
        cv2.putText(frame, f'FPS: {fps:.1f}', (10, 30),
24
                    cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
25

26
        # Display (resize for preview)
27
        preview = cv2.resize(frame, (960, 540))
28
        cv2.imshow('Screen Capture', preview)
29

30
        if cv2.waitKey(1) & 0xFF == ord('q'):
31
            break
32

33
    camera.stop()
34
    cv2.destroyAllWindows()
35

36
live_preview()

Common Issues

No Frame Returned

1
import dxcam
2

3
camera = dxcam.create()
4
frame = camera.grab()
5

6
if frame is None:
7
    print("No frame captured - screen might not have changed")
8
    # dxcam only captures when screen changes
9
    # Use video mode for continuous capture

Multiple Cameras

1
import dxcam
2

3
# Only one camera per output at a time
4
camera1 = dxcam.create(output_idx=0)
5

6
# This will fail:
7
# camera2 = dxcam.create(output_idx=0)  # Error!
8

9
# Delete first camera before creating another for same output
10
del camera1
11
camera2 = dxcam.create(output_idx=0)  # OK

When to Use DXcam

Use DXcam when:

You need maximum FPS (gaming, streaming).
You’re on Windows.
Real-time processing is required.
You don’t need cross-platform support and don’t care about the maintenance of the library.

Use Python MSS when:

You need cross-platform support.
30-60 FPS is sufficient.
Simpler API is preferred.
And you want to rely on a maintained library.

In case you need to render website screenshots, check out our guide on websites screenshots with Python. The guide only consider website screenshot automation.

DXcam vs Python MSS Performance

In general:

Metric	DXcam	Python MSS
Max FPS (1080p)	240+	30-60
Platform	Windows only	Cross-platform
API	NumPy native	Custom format
Best for	Gaming/streaming	General purpose

Kyle Fu also confirms in his performance comparison that DXcam is faster than Python MSS:

DXcam vs Python MSS performance comparison

Summary

DXcam might be the fastest screen capture option for Python on Windows, but it is not actively maintained at the moment of writing the guide, however:

It might achieve 240+ FPS capture using DirectX.
Supports Video mode for continuous capture.
Native NumPy output.
Region and multi-monitor support.

For cross-platform needs, use Python MSS. For website screenshots, check out our website screenshot automation guide with Python.

Frequently Asked Questions

If you read the article, but still have questions. Please, check the most frequently asked. And if you still have questions, feel free reach out at support@screenshotone.com.

Is DXcam fast for screen capture?

Yes, DXcam is the fastest Python screen capture library, achieving 240+ FPS on modern systems. It uses DirectX Desktop Duplication API for maximum performance.

What is the difference between DXcam and Python MSS?

DXcam is faster (240+ FPS vs 30-60 FPS) but only works on Windows. Python MSS is cross-platform but slower. Use DXcam for gaming/streaming on Windows, Python MSS for cross-platform needs.

Is Windows Graphics Capture faster than DXcam?

They're comparable in performance. DXcam uses Desktop Duplication API and is easier to use in Python. Windows.Graphics.Capture requires more setup but offers some additional features.