🎭 UA Randomizer

A lightweight, zero-dependency Node.js library for generating realistic browser user agents across different systems and browsers.

✨ Features

🚀 Zero dependencies - Lightweight and fast
🎲 Random generation - Generate random or specific user agents
🌐 Multi-browser support - Chrome, Firefox, Safari, Edge, Samsung Internet
💻 Multi-platform - Windows, macOS, Linux, iOS, Android
📱 Mobile & Tablet support - iPhone, iPad, Android phones & tablets
🏗️ Well-structured - Modular architecture for easy maintenance
📦 Easy to use - Simple API with sensible defaults
🔒 TypeScript support - Full type definitions included
⚡ Up-to-date - Uses recent browser versions
✅ Fully tested - Comprehensive test suite with 100% pass rate

📦 Installation

npm install ua-randomizer

or with yarn:

yarn add ua-randomizer

🚀 Quick Start

const ua = require('ua-randomizer');

// Generate a random desktop user agent
const randomUA = ua.generate();
console.log(randomUA);
// => Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36...

// Generate a mobile user agent
const mobileUA = ua.generate({ deviceType: 'mobile' });
console.log(mobileUA);
// => Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X)...

Try it:

npm test          # Run 87 comprehensive tests
npm run example   # View detailed examples

📖 Usage

Generate Random User Agent

const ua = require('ua-randomizer');

// Generate random desktop user agent (default)
const userAgent = ua.generate();

// Generate random user agent from any device type
const anyDevice = ua.generate({ deviceType: 'random' });

Device Types

// Desktop (default)
const desktop = ua.generate({ deviceType: 'desktop' });

// Mobile phone
const mobile = ua.generate({ deviceType: 'mobile' });

// Tablet
const tablet = ua.generate({ deviceType: 'tablet' });

Specify Browser

// Generate Chrome user agent
const chrome = ua.generate({ browser: 'chrome' });

// Generate Firefox user agent
const firefox = ua.generate({ browser: 'firefox' });

// Generate Safari user agent
const safari = ua.generate({ browser: 'safari' });

// Generate Edge user agent
const edge = ua.generate({ browser: 'edge' });

Specify Operating System

// Generate user agent for Windows
const windowsUA = ua.generate({ os: 'windows' });

// Generate user agent for macOS
const macUA = ua.generate({ os: 'mac' });

// Generate user agent for Linux
const linuxUA = ua.generate({ os: 'linux' });

Combine Browser and OS

// Chrome on Windows
const chromeWindows = ua.generate({
  deviceType: 'desktop',
  browser: 'chrome',
  os: 'windows'
});

// Firefox on Linux
const firefoxLinux = ua.generate({
  deviceType: 'desktop',
  browser: 'firefox',
  os: 'linux'
});

// Safari on Mac (Safari is macOS only)
const safariMac = ua.generate({
  deviceType: 'desktop',
  browser: 'safari'
});

Mobile & Tablet Devices

// iPhone
const iphone = ua.generateIPhone();
// => Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X)...

// iPad
const ipad = ua.generateIPad();
// => Mozilla/5.0 (iPad; CPU OS 17_4 like Mac OS X)...

// Android Phone
const androidPhone = ua.generateAndroidPhone();
// => Mozilla/5.0 (Linux; Android 13; Pixel 7)...

// Android Tablet
const androidTablet = ua.generateAndroidTablet();
// => Mozilla/5.0 (Linux; Android 13; SM-X900)...

// Firefox Mobile
const firefoxMobile = ua.generateFirefoxMobile();

// Samsung Internet
const samsungBrowser = ua.generateSamsungInternet();

Specific Mobile/Tablet OS

// iOS mobile
const iosPhone = ua.generate({
  deviceType: 'mobile',
  os: 'ios'
});

// Android mobile with specific browser
const androidChrome = ua.generate({
  deviceType: 'mobile',
  os: 'android',
  browser: 'chrome'
});

// Android mobile with Firefox
const androidFirefox = ua.generate({
  deviceType: 'mobile',
  os: 'android',
  browser: 'firefox'
});

// iPad
const ipadUA = ua.generate({
  deviceType: 'tablet',
  os: 'ios'
});

// Android tablet
const androidTabletUA = ua.generate({
  deviceType: 'tablet',
  os: 'android'
});

Generate Multiple User Agents

// Generate 5 random user agents
const userAgents = ua.generateMultiple(5);

// Generate 3 Chrome user agents on Windows
const chromeUAs = ua.generateMultiple(3, {
  browser: 'chrome',
  os: 'windows'
});

Direct Browser Generation

// Generate specific browser user agents directly
const chrome = ua.generateChrome();
const firefox = ua.generateFirefox();
const safari = ua.generateSafari();
const edge = ua.generateEdge();

// With OS specification
const chromeWindows = ua.generateChrome('windows');
const firefoxMac = ua.generateFirefox('mac');
const edgeLinux = ua.generateEdge('linux');

Get Available Options

// Get list of supported browsers
const browsers = ua.getBrowsers();
console.log(browsers); // => ['chrome', 'firefox', 'safari', 'edge']

// Get list of supported operating systems
const systems = ua.getOperatingSystems();
console.log(systems); // => ['windows', 'mac', 'linux']

🔧 API Reference

`generate(options)`

Generate a user agent string.

Parameters:

options (Object, optional)
- deviceType (string): Device type - 'desktop', 'mobile', 'tablet', or 'random' (default: 'desktop')
- browser (string): Browser type - 'chrome', 'firefox', 'safari', 'edge', 'samsung', or 'random' (default: 'random')
- os (string): Operating system - 'windows', 'mac', 'linux', 'ios', 'android', or 'random' (default: 'random')

Returns: string - User agent string

`generateMultiple(count, options)`

Generate multiple user agent strings.

Parameters:

count (number): Number of user agents to generate
options (Object, optional): Same as generate() options

Returns: string[] - Array of user agent strings

`generateChrome(os)`

Generate a Chrome user agent.

Parameters:

os (string, optional): Operating system - 'windows', 'mac', 'linux', or 'random' (default: 'random')

Returns: string - Chrome user agent string

`generateFirefox(os)`

Generate a Firefox user agent.

Parameters:

os (string, optional): Operating system - 'windows', 'mac', 'linux', or 'random' (default: 'random')

Returns: string - Firefox user agent string

`generateSafari()`

Generate a Safari user agent (macOS only).

Returns: string - Safari user agent string

`generateEdge(os)`

Generate an Edge user agent.

Parameters:

os (string, optional): Operating system - 'windows', 'mac', or 'random' (default: 'random')

Returns: string - Edge user agent string

`getBrowsers()`

Get list of supported browsers.

Returns: string[] - Array of browser names

`getOperatingSystems()`

Get list of supported operating systems.

Returns: string[] - Array of OS names

Mobile Device Functions

`generateIPhone()`

Generate an iPhone user agent (Safari).

Returns: string - iPhone user agent string

`generateIPad()`

Generate an iPad user agent (Safari).

Returns: string - iPad user agent string

`generateAndroidPhone()`

Generate an Android phone user agent with Chrome.

Returns: string - Android phone user agent string

`generateAndroidTablet()`

Generate an Android tablet user agent with Chrome.

Returns: string - Android tablet user agent string

`generateFirefoxMobile()`

Generate a mobile Firefox user agent (Android).

Returns: string - Mobile Firefox user agent string

`generateSamsungInternet()`

Generate a Samsung Internet user agent.

Returns: string - Samsung Internet user agent string

`generateMobile(options)`

Generate a random mobile user agent.

Parameters:

options (Object, optional)
- device (string): Device type - 'iphone', 'ios', 'android', or 'random' (default: 'random')

Returns: string - Random mobile user agent string

`generateTablet(options)`

Generate a random tablet user agent.

Parameters:

options (Object, optional)
- device (string): Device type - 'ipad', 'ios', 'android', or 'random' (default: 'random')

Returns: string - Random tablet user agent string

`getDeviceTypes()`

Get list of supported device types.

Returns: string[] - Array of device type names (['desktop', 'mobile', 'tablet'])

💡 Use Cases

Web Scraping

const axios = require('axios');
const ua = require('ua-randomizer');

async function scrape(url) {
  const response = await axios.get(url, {
    headers: {
      'User-Agent': ua.generate()
    }
  });
  return response.data;
}

Testing

const puppeteer = require('puppeteer');
const ua = require('ua-randomizer');

async function test() {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  // Set random user agent
  await page.setUserAgent(ua.generate());

  await page.goto('https://example.com');
  // ... rest of your test
}

API Requests

const fetch = require('node-fetch');
const ua = require('ua-randomizer');

fetch('https://api.example.com/data', {
  headers: {
    'User-Agent': ua.generate({ browser: 'chrome', os: 'windows' })
  }
})
  .then(response => response.json())
  .then(data => console.log(data));

🎯 TypeScript Support

This package includes TypeScript definitions out of the box:

import * as ua from 'ua-randomizer';

const userAgent: string = ua.generate({
  browser: 'chrome',
  os: 'windows'
});

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📄 License

🔗 Links

📊 Browser & Device Support

The library generates user agents with latest versions (Updated Oct 2025):

Desktop Browsers

Chrome - Versions 127-141 ⚡ (Latest!)
Firefox - Versions 128-137
Safari - Versions 17.2-18.2 (macOS only)
Edge - Versions 127-141

Mobile Browsers

Chrome Mobile - Versions 127-141 ⚡ (Latest!)
Firefox Mobile - Versions 128-135
Safari Mobile - iOS 16.6-18.2
Samsung Internet - Versions 23-26

Operating Systems

Windows - Windows 10 & 11
macOS - Versions 10.15.7 (Catalina) to 15.1 (Sequoia)
Linux - Ubuntu, Fedora, and generic distributions
iOS - Versions 16.6 - 18.2 (iPhone & iPad)
Android - Versions 11-14

Devices

Desktop - Windows, Mac, Linux computers
iPhone - All recent models with iOS 16.6-18.2
iPad - All recent models with iPadOS 16.6-18.2
Android Phones - Samsung Galaxy, Google Pixel, Xiaomi, and more
Android Tablets - Samsung Galaxy Tab, Google Pixel Tablet, and more

⚡ Performance

Zero dependencies means:

✅ Tiny package size
✅ Fast installation
✅ No security vulnerabilities from dependencies
✅ Works in any Node.js environment (v12+)

Made with ❤️ for the Node.js community

Name		Name	Last commit message	Last commit date
Latest commit History 4 Commits
.github/workflows		.github/workflows
src		src
test		test
.gitignore		.gitignore
.npmignore		.npmignore
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md
package.json		package.json

License

ranbot-ai/ua-randomizer

Folders and files

Latest commit

History

Repository files navigation

🎭 UA Randomizer

✨ Features

📦 Installation

🚀 Quick Start

📖 Usage

Generate Random User Agent

Device Types

Specify Browser

Specify Operating System

Combine Browser and OS

Mobile & Tablet Devices

Specific Mobile/Tablet OS

Generate Multiple User Agents

Direct Browser Generation

Get Available Options

🔧 API Reference

generate(options)

generateMultiple(count, options)

generateChrome(os)

generateFirefox(os)

generateSafari()

generateEdge(os)

getBrowsers()

getOperatingSystems()

Mobile Device Functions

generateIPhone()

generateIPad()

generateAndroidPhone()

generateAndroidTablet()

generateFirefoxMobile()

generateSamsungInternet()

generateMobile(options)

generateTablet(options)

getDeviceTypes()

💡 Use Cases

Web Scraping

Testing

API Requests

🎯 TypeScript Support

🤝 Contributing

📄 License

🔗 Links

📊 Browser & Device Support

Desktop Browsers

Mobile Browsers

Operating Systems

Devices

⚡ Performance

About

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

`generate(options)`

`generateMultiple(count, options)`

`generateChrome(os)`

`generateFirefox(os)`

`generateSafari()`

`generateEdge(os)`

`getBrowsers()`

`getOperatingSystems()`

`generateIPhone()`

`generateIPad()`

`generateAndroidPhone()`

`generateAndroidTablet()`

`generateFirefoxMobile()`

`generateSamsungInternet()`

`generateMobile(options)`

`generateTablet(options)`

`getDeviceTypes()`

Packages