Skip to content

ranbot-ai/ua-randomizer

Folders and files

NameName
Last commit message
Last commit date

Latest commit

Β 

History

4 Commits
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 
Β 

Repository files navigation

🎭 UA Randomizer

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

npm version License: MIT

✨ 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

MIT Β© [Your Name]

πŸ”— 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

About

An always up-to-date list of the top HTTP user-agents most used over the Internet.

Resources

License

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published