Device Detection in Node.js: express-device vs node-device-detector vs ua-parser-js

Parsing User-Agent strings to detect devices, browsers, and operating systems is a common need in web applications—for analytics, responsive rendering, or compatibility checks. But not all detection libraries are created equal. Let’s compare express-device, node-device-detector, and ua-parser-js from a practical engineering standpoint.

🧩 Core Philosophy: Middleware vs Parser vs Detector

express-device is Express-specific middleware. It hooks into your Express app and automatically adds a req.device property so you can check device type inside route handlers.

// express-device: automatic injection into req
const express = require('express');
const device = require('express-device');

const app = express();
app.use(device.capture());

app.get('/', (req, res) => {
  // req.device.type is 'phone', 'tablet', or 'desktop'
  res.send(`You're on a ${req.device.type}`);
});

ua-parser-js is a pure parser with no framework dependencies. You pass it a User-Agent string and get back structured data about browser, OS, and device.

// ua-parser-js: manual parsing, works anywhere
const UAParser = require('ua-parser-js');

const ua = 'Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) ...';
const parser = new UAParser(ua);

const result = parser.getResult();
// { browser: { name: 'Mobile Safari', version: '16.5' },
//   os: { name: 'iOS', version: '16.5' },
//   device: { vendor: 'Apple', model: 'iPhone', type: 'mobile' } }

node-device-detector is a full-featured detector that goes beyond basic parsing. It uses an extensive internal database and additional heuristics to identify exact device models.

// node-device-detector: detailed device identification
const DeviceDetector = require('node-device-detector');
const detector = new DeviceDetector();

const ua = 'Mozilla/5.0 (Linux; Android 13; SM-S908B) ...';
const result = detector.detect(ua);
// { os: { name: 'Android', version: '13' },
//   client: { type: 'browser', name: 'Chrome' },
//   device: { type: 'smartphone', brand: 'Samsung', model: 'Galaxy S22+' } }

📱 Accuracy and Detail Level

The level of detail varies significantly:

• express-device only tells you if the device is a phone, tablet, or desktop. It doesn’t identify brands, models, or even distinguish between iOS and Android.

// express-device output example
req.device.type; // 'phone' — that’s it

• ua-parser-js provides vendor, model, and device type, but its device detection is limited to what’s inferable from the User-Agent alone. Many Android devices appear as generic "Generic Smartphone".

// ua-parser-js may return:
result.device; // { vendor: 'Samsung', model: 'SM-G975F', type: 'mobile' }
// But often:
result.device; // { vendor: undefined, model: undefined, type: 'mobile' }

• node-device-detector maintains a large, frequently updated regex-based device database (similar to what commercial services use). It reliably identifies specific models like iPhone 14 Pro or Xiaomi Redmi Note 12.

// node-device-detector output
result.device; // { type: 'smartphone', brand: 'Apple', model: 'iPhone 14 Pro' }

If your use case depends on knowing whether a user is on an iPhone 12 vs iPhone 13, only node-device-detector delivers consistently.

⚙️ Integration and Flexibility

express-device is tightly coupled to Express. You can’t use it in Koa, Fastify, or frontend code. It also runs on every request, which may be unnecessary overhead if you only need device info on certain routes.

ua-parser-js works everywhere — browser, Node.js, Deno, or even React Native. You decide when and where to parse, and you can cache parsers for performance.

// Reuse parser instance for better performance
const parser = new UAParser();
function handleRequest(ua) {
  parser.setUA(ua);
  return parser.getDevice();
}

node-device-detector is Node.js-only (due to its large internal database), but it’s framework-agnostic. You can use it in any server environment by manually passing the User-Agent header.

// Works in any Node.js HTTP server
app.get('/', (req, res) => {
  const device = detector.detect(req.headers['user-agent']);
  // ...
});

🛠️ Maintenance and Reliability

As of 2024, express-device shows signs of abandonment: its last meaningful update was years ago, and it relies on outdated detection logic. New devices often get misclassified or fall back to generic categories.

In contrast, both ua-parser-js and node-device-detector are actively maintained. ua-parser-js syncs regularly with the official UAParser community regexes. node-device-detector updates its internal database frequently and supports modern detection patterns beyond raw User-Agent parsing (like client hints, though that requires additional setup).

⚠️ Important: Because express-device is effectively unmaintained and lacks accuracy, it should not be used in new projects. Even for simple Express apps, calling ua-parser-js manually inside middleware gives you better results with minimal extra code.

🌐 Real-World Usage Scenarios

Scenario 1: Basic Mobile Redirect in Express

You want to redirect mobile users to /m.

• ❌ Avoid express-device — too unreliable.
• ✅ Use ua-parser-js with custom middleware:

const UAParser = require('ua-parser-js');

app.use((req, res, next) => {
  const parser = new UAParser(req.headers['user-agent']);
  const deviceType = parser.getDevice().type;
  if (deviceType === 'mobile' && !req.url.startsWith('/m')) {
    return res.redirect('/m' + req.url);
  }
  next();
});

Scenario 2: Analytics Dashboard Showing Device Models

You’re building an internal tool that displays which phone models your users have.

• ✅ Best choice: node-device-detector
• Why? Only it provides consistent, model-level accuracy needed for meaningful metrics.

const detector = new DeviceDetector();
const { device } = detector.detect(userAgent);
// Log: { brand: 'Google', model: 'Pixel 7' }

Scenario 3: Feature Detection for Legacy Browser Support

You need to warn users on old browsers.

• ✅ Best choice: ua-parser-js
• Why? It gives precise browser name and version, works in the browser too (for client-side fallbacks), and is lightweight.

const parser = new UAParser(navigator.userAgent);
const browser = parser.getBrowser();
if (browser.name === 'IE' || (browser.name === 'Chrome' && parseFloat(browser.version) < 80)) {
  showUpgradeWarning();
}

📊 Summary Table

💡 Final Recommendation

• Avoid express-device in new code. Its convenience isn’t worth the technical debt.
• Use ua-parser-js for most general-purpose User-Agent parsing — it’s reliable, lightweight, and works everywhere.
• Reach for node-device-detector only when you truly need high-fidelity device identification and are operating in a Node.js backend context.

Remember: User-Agent parsing is inherently imperfect. For critical functionality, always combine it with progressive enhancement and feature detection (e.g., using @mdn/browser-compat-data or runtime checks) rather than relying solely on device labels.