Das Keyboard X50Q

World’s First Smart Gaming Keyboard

Receive notifications on your keyboard

Das Keyboard X50 animation

Customize keyboard to your needs

Download applets from Q marketplace

Q marketplace

Stay informed

Keep an eye on what important

X50Q keyboard with applets from the Q marketplace
X50Q huge side view

The most advanced software

Real time notification display

All your notifications in one place
Gama Zulu RGB Switches

With the Dashboard view, quickly visualize the state of the keyboard.
Mouseover each individual key to see which notifications are streaming through.

Performance meets design

Whether on your desk at work or at home, the X50Q looks stunning and delivers fast precision keystrokes that help you get the job done.

Das Keyboard X50 RGB Side View
Das Keyboard X50 RGB Mechanical Keyboard Gamma Zulu Switch Badge
Das Keyboard X50 RGB Mechanical Keyboard Color Badge
2x ultra
Das Keyboard X50 RGB Mechanical Keyboard Aluminum Badge
top panel

Ultra-fast & comfortable Gamma Zulu mechanical key switches

Made by Omron (Japan) for Das Keyboard, the Gamma Zulu is a modern best-in-class, fast, soft tactile key switch. It lasts forever with its unequalled 100 million life cycle. The feel is amazing and allows effortless typing and gaming sessions.

Standard mechanical switches* Das Keyboard Gamma Zulu by Omron
Actuation point 2.0 mm 1.5 mm
Total travel 4.0 mm 3.5 mm
Life span 50 Million 100 Million
Contact type Single cross point Double cross point
*Based on manufacturer specifications

Learn more about the Gamma Zulu switch

Gamma Zulu switches withstand 100 million actuations. It is up to 100% more durable than most competitor’s switches. They require 45 grams to actuate at 1.5 mm — that’s for speed. The full travel is 3.5mm — that’s for comfort.

Gamma Zulu RGB LED Switches

Gamma Zulu technical specifications

Gamma Zulu Mechanical Switches Characteristics
Gamma Zulu mechanicals switch characteristics
Gamma Zulu Switch Diagram
Gamma Zulu force curves

A REST API for hackers

Do you have Code Fu?

# This script colorize a key of the Q Keyboard
# by sending a JSON signal to the its public API
# located at http://localhost:27301
set -e # quit on first error.
# Q desktop public API port #
PID="DK5QPID" # product ID
ZONEID="KEY_A" # Key to colorize
# Q desktop public API url
# important NOTE: if field "name" and "message" are empty then the signal is
# only displayed on the devices LEDs, not in the signal center
echo "Sending signal to zoneId: $ZONEID at $URL"
# sending the signal to colorize the key A in red
curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' -d '{
    "pid": "'$PID'",
    "zoneId": "'"$ZONEID"'",
    "color": "#F00",
    "effect": "SET_COLOR",
    "name": "Hello message for '$ZONEID'",
    "message": "Message sent by script '$0'",
    "shouldNotify": true 
}' $URL

# checking the response
if [ "$result" -eq "0" ]; then
    echo OK
    exit 0
    echo ERROR
    exit 1
// This script colorize a key of a Q Keyboard
// by sending a JSON signal to the its public API
// located at http://localhost:27301

package main

import (
// A Signal represents a message to be sent to a Q device.
type Signal struct {
    ID           int64  `json:"id"`           // Not used when creating a signal
    Pid          string `json:"pid"`          // DK5QPID
    ZoneID       string `json:"zoneId"`       // KEY_A, KEY_B, etc...
    Name         string `json:"name"`         // message title
    Message      string `json:"message"`      // message body
    Effect       string `json:"effect"`       // e.g. SET_COLOR, BLINK, etc...
    Color        string `json:"color"`        // color in hex format. E.g.: "#FF0044"
    ShouldNotify bool   `json:"shouldNotify"` // whether to show a OS notification
func main() {
    // Q desktop public API port #.
    port := "27301"

    // creating the signal
    oneSignal := Signal{0, "DK5QPID", "KEY_A", "Hello oneSignal", "Signal sent from a go program on a key...", "SET_COLOR", "#F00", true}

    // Encode to JSON
    signalJSON := new(bytes.Buffer)

    // Construct API URL
    url := "http://localhost:" + port + "/api/1.0/signals"

    // sending the signal to colorize the key A in red
    resp, err := http.Post(url, "application/json; charset=utf-8", signalJSON)

    if err != nil {

    // checking the response
    if resp.StatusCode == 200 {
    } else {
        fmt.Println("Error: ", resp.StatusCode)
// This script colorize a key of a Q Keyboard
// by sending a JSON signal to the its public API
// located at http://localhost:27301
import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import javax.swing.plaf.InputMapUIResource;

class create_one_signal {
    public static void main(String[] args) {
        // creating the signal as a string
        String signalJson = "{\"pid\": \"DK5QPID\", \"zoneId\": \"KEY_A\", \"name\": \"Hello oneSignal\", \"message\": \"signal sent from a java script (haha) to a key\", \"effect\": \"SET_COLOR\", \"color\": \"#F00\", \"shouldNotify\": false}";
        // Q desktop public API port #
        String port = "27301";

        // sending the signal to colorize the key A in red
        try {
            URL urlObj = new URL("http://localhost:" + port + "/api/1.0/signals");
            HttpURLConnection urlConnection = (HttpURLConnection) urlObj.openConnection();
            urlConnection.setRequestProperty("Content-Type", "application/json; charset=UTF-8");

            OutputStream os = urlConnection.getOutputStream();
            // reading the response
            InputStream in = new BufferedInputStream(urlConnection.getInputStream());
            BufferedReader r = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
            // checking the response
        } catch (IOException e) {
            System.out.println("Error while sending the signal: " + e.getMessage());
// This script colorize a key of a Q Keyboard
// by sending a JSON signal to the its public API
// located at http://localhost:27301
"use strict";

var request = require('request');
// Q desktop public API url
let apiUrl = "http://localhost:27301/api/1.0/signals";
// creating the signal to colorize the key A in red
let signal = {
    "pid": "DK5QPID",
    "zoneId": "KEY_A",
    "color": "#F00",
    "effect": "SET_COLOR",
    "name": "Hello message title",
    "message": "Message body goes here...",
    "shouldNotify": true 
// sending the signal
    url: apiUrl,
    headers: {
        "Content-Type": "application/json"
    body: signal,
}, function(error, response, body){
    // checking the response
    if(response.statusCode == 200){
    } else {
        console.log("ERROR: ", body);
// This script colorize a key of a Q Keyboard
// by sending a JSON signal to the its public API
// located at http://localhost:27301
// Q desktop public API port #
$port = "27301";

$url = "http://localhost:".$port."/api/1.0/signals";
// if curl_init is undefined, run: sudo apt-get install php-curl
$ch = curl_init($url);

// construction of the signal object
$signal = new \stdClass();
$signal->pid = "DK5QPID";
$signal->zoneId = "KEY_A";
$signal->color = "#F00";
$signal->effect = "SET_COLOR";
$signal->name = "Hello oneSignal";
$signal->message = "signal sent from a php script to a key";
$signal->shouldNotify = false;

// encoding to json
$signalJson = json_encode($signal);

curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $signalJson);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Content-Type: application/json'));
// sending the signal to colorize the key A in red
$result = curl_exec($ch);

// checking the response
if ($result == "OK") {
    echo $result."\n";
} else {
    echo "Error while sending the signal: ".$result."\n";
# This script colorize a key of a Q Keyboard
# by sending a JSON signal to the its public API
# located at http://localhost:27301
import json
from os.path import expanduser
import requests

HOME = expanduser("~")

# creating the signal
    "pid": "DK5QPID",
    "zoneId": "KEY_A",
    "color": "#F00",
    "effect": "SET_COLOR",
    "name": "Hello oneSignal",
    "message": "signal sent from a python script to a key",
    "shouldNotify": False

    "content-type": "application/json"
# encoding the signal to json
SIGNAL_JSON = json.dumps(SIGNAL)
# Q desktop public API port #
PORT_NUMBER = "27301"
# Q desktop public API url
URL = 'http://localhost:'+PORT_NUMBER+'/api/1.0/signals'
# sending the signal to colorize the key A in red
R = requests.post(URL, data=SIGNAL_JSON, headers=HEADERS)

# checking the response
if R.ok:
    print R.text
    print "Error while sending the signal: " + R.text
#!/usr/bin/env ruby
# This script colorize a key of a Q Keyboard
# by sending a JSON signal to the its public API
# located at http://localhost:27301
require 'json'
require 'net/http'

# Q desktop public API port #.
port = "27301"
# Q desktop public API url
url = 'http://localhost:'+port+'/api/1.0/signals'

# sending the signal to colorize the key A in red
uri = URI(url)
req = Net::HTTP::Post.new(uri, 'Content-type' => 'application/json')
req.body = { pid: "DK5QPID",
            zoneId: "KEY_A",
            color: "#F00",
            effect: "SET_COLOR",
            name: "Hello oneSignal",
            message: "signal sent from a ruby script to a key",
            shouldNotify: false }.to_json

res = Net::HTTP.start(uri.hostname, uri.port) do |http|

# checking the response
if res.body == "OK"
    puts res.body
    puts "Error while sending the signal: " + res.body
If this does not turn you on, you have no emotions.

Intense RGB colors in broad daylight

16.8 Million ultra bright colors

At work or in your cave, the X50Q RGB shines everywhere

Due to its enhanced brightness mode(*) and its modern switch design, the X50Q delivers intense colors that are not washed out by daylight - a problem that most RGB keyboards suffer from.

(*) requires an USB 3.0 connection.

Gamma Zulu colored LED Switches

Premium materials throughout

Durable aluminium panel

Built to Last for Years

Das Keyboard X50Q sports a slick anodized black aluminum top panel. Its hex-screws allow users to easily customize it.(*)

(*) Available in the future.

X50 RGB Mechanical Keyboard with a Durable Aluminium Panel

Quick access media controls

Simple Control at Your Fingertips

Das Keyboard X50Q provides direct controls to quickly set sound level, play or pause songs, and adjust RGB brightness while gaming or working.

X50 RGB Mechanical Keyboard with a Media Control

Full N-key rollover

Register all key presses

With 100% anti-ghosting with full n-key rollover, no matter how many keys you press simultaneously, all of them will be reliably registered. Whether you type super fast or your gameplay finger dexterity is amazing, the X50Q NKRO is able to deliver the spanking your opponent deserve.

X50 RGB Mechanical Keyboard with N-Key

Energy-saving sleep function

Protect the environment

A small details that makes a big difference: The X50Q has a function control to put the computer to sleep instantly. It saves energy and helps the environment.

The Earth

Extra long braided cable

Keep your desk tidy

Long dog with long braided cable
The X50Q sports an extra-long 2-meter (6.5ft) braided USB cable that goes through desk grommets to keep the desk clean.

Inside the beast belly

Dual Layer Black PCB

Nothing beats looking under the hood of a performance car. Same for the X50Q. The Das Keyboard team wanted the inside to match the outside so we chose a black PCB layout to add a dose of badassness.

Soft touch palm rest

Friction free

Das Keyboard X50Q includes a frictionless detachable palm rest that helps typists rest their palms comfortably.

Soft Touch Palm Rest

WASD keycaps included

Included in the box: a textured WASD keycap set that makes a statement on your desk and shows who’s boss. Key puller included as well.

WASD Keycaps


  • Backlighting: RGB
  • Connection Type: USB 2.0
  • Keycap Material: ABS
  • Aluminum top panel: Yes
  • USB Ports (Built-in): No
  • Dedicated Media Controls: Volume Knob, Play/Pause, Track Forward/Backward
  • Easy Access Media Controls: Yes
  • Firmware Updatable: Yes
  • Windows® 10, Windows 8.1, Windows 8, Windows 7, Linux (Beta).
  • One 2.0 USB port, Optional 3.0 USB port for Enhanced Brightness Mode
  • Internet connection for software download
  • 1-Year Limited Hardware Warranty
  • Keyboard
  • Palm rest
  • WASD two-tone keycaps
  • Keycap puller
  • User documentation
  • Height: 1.28 in (3.2 cm)
  • Width: 9.21 in (23.3 cm)
  • Length: 17.77 in (45.1 cm)
  • Weight: 3.5 lbs (1.55 kg)
  • Cable: 6.5 ft (2 m)
  • Feel: Soft tactile
  • Gold Cross Point Contacts: 2
  • Durability: 100 million actuations
  • Actuation distance: 0.06 in (1.5 mm)
  • Actuation force: 1.6 oz (45 g)
  • Total travel distance: 0.14 in (3.5 mm)
  • 104 US
  • 105 UK
  • 105 DE
  • 105 NO
Additional language keycaps are available as an add-on. (See accessories below.)


  • Without inscriptions for 104 and 105 key layouts.
  • With inscriptions for US, UK, German, French, Nordic, Spanish, and Russian.
  • With inscriptions for Dvorak Layout
  • With inscriptions, available only in US