List of User Agents for Scraping

Versions: Chrome 156 stable (156.0.8078.47 in Chrome for Testing), Edge 156 (Microsoft Edge release notes), Firefox 158.0.1 (Mozilla product details) and Safari 27 (Safari release notes; Version/27.0 strings appear in Microlink's list). Formats follow MDN's User-Agent reference.

Three things look odd and are correct:

• Windows NT 10.0 on Windows 11. Browsers don't put Windows 11 in the string; it stays 10.0.
• Intel Mac OS X 10_15_7 on every Mac, including Apple silicon and new macOS versions. Chrome and Safari froze it; Firefox freezes it at 10.15.
• Chrome/156.0.0.0. Since user-agent reduction, Chromium browsers send only the major version; the full version goes into client hints (Chromium: user-agent reduction).

Because of that last point, a Chrome string alone isn't a complete identity: real Chrome also sends Sec-CH-UA, Sec-CH-UA-Mobile and Sec-CH-UA-Platform. Which headers to send with each string, and how to set them in each tool, is in HTTP headers for web scraping.

Four tokens here look wrong and are not:

• Android 10; K. Reduced Chrome on Android sends that fixed value instead of the real Android version and device model; a tablet drops Mobile. Samsung Internet does the same, with its own token and an older Chromium base (Chrome/143).
• iPhone OS 18_7 with Safari 27. Safari no longer tracks the iOS version in this token: MDN's Safari 26 example shows 18_6, and the Safari 27 strings in Microlink's list show 18_7.
• CriOS/155.0.8059.37. Chrome on iPhone runs on WebKit, adds CriOS with a full version and reports the real iOS version (26_6_2). The string in the table is the newest one in Microlink's list on 2026-10-27.
• Firefox on Android reports the real Android version and uses Gecko/<version> instead of the desktop Gecko/20100101.

Send a mobile string only with a mobile-sized viewport, touch support and, ideally, a mobile IP; a phone user agent from a desktop-sized browser on a data-center IP is a contradiction. Mobile proxies give you IPs on 5G, 4G and LTE carrier networks.

The same 15 strings as one Python list. In JavaScript, the same brackets are a valid array:

USER_AGENTS = {
    "desktop": [
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36 Edg/156.0.0.0",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36 Edg/156.0.0.0",
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:158.0) Gecko/20100101 Firefox/158.0",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:158.0) Gecko/20100101 Firefox/158.0",
        "Mozilla/5.0 (X11; Linux x86_64; rv:158.0) Gecko/20100101 Firefox/158.0",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/27.0 Safari/605.1.15",
    ],
    "mobile": [
        "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Mobile Safari/537.36",
        "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/156.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Android 15; Mobile; rv:158.0) Gecko/158.0 Firefox/158.0",
        "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) SamsungBrowser/30.0 Chrome/143.0.0.0 Mobile Safari/537.36",
        "Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/27.0 Mobile/15E148 Safari/604.1",
        "Mozilla/5.0 (iPhone; CPU iPhone OS 26_6_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) CriOS/155.0.8059.37 Mobile/15E148 Safari/604.1",
    ],
}

Four maintained sources.

To check the string your own browser sends, open https://httpbin.org/user-agent or MDN's reference above. Whatever source you use, run the filter in Keep the list current before the strings go into a scraper.

These are what tools send when you don't set a user agent. Sites block several of them by name, so replace them in production:

curl's -A "" removes the header entirely, which some servers refuse.

Search engine crawlers announce themselves, for example Googlebot's classic string Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html) (listed on MDN) and Bing's Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm). Don't send them from a scraper. Sites can verify a real Googlebot with a reverse DNS lookup of the IP, as Google documents (verifying Googlebot), so a fake one from any other IP is easy to catch, and pretending to be a search engine is a misrepresentation many sites' terms forbid. If you run your own crawler and want to be identified, use an honest string with a contact URL, such as MyCrawler/1.0 (+https://example.com/bot).

1. Use current versions only. Chrome, Edge and Firefox update themselves, so a string several versions old stands out.
2. Keep one user agent per session. Tie it to the cookies and the sticky IP of that session, and don't change it mid-session.
3. Send the full header set of the browser you claim, including client hints for Chrome and Edge.
4. Match the platform. A Windows string should come with Windows-like screen sizes and fonts in a browser; browser fingerprinting in web scraping explains the checks.
5. Rotate between a few strings, not thousands. A small set of real, current browsers looks like real traffic; a random string per request does not.

This Python sketch gives each session one user agent from a short list and sends it through the ProxyField gateway; as written, each request gets a new IP until you add a session id (below):

import random
import requests

USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:158.0) Gecko/20100101 Firefox/158.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:158.0) Gecko/20100101 Firefox/158.0",
    "Mozilla/5.0 (X11; Linux x86_64; rv:158.0) Gecko/20100101 Firefox/158.0",
]

def new_session():
    s = requests.Session()
    s.headers.update({
        "User-Agent": random.choice(USER_AGENTS),   # one per session, not per request
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.5",
    })
    proxy = "http://<login>-country-us-city-new_york:<password>@gate.proxyfield.io:7000"  # add a sticky session id: see below
    s.proxies = {"http": proxy, "https": proxy}
    return s

s = new_session()
print(s.get("https://httpbin.org/user-agent", timeout=30).json())

The list uses Firefox strings on purpose: plain requests sends no client hints, and Firefox doesn't send them either, so the headers stay consistent. Keeping the same IP for the whole session needs a sticky session: -region-<region>, -session-<id> and -ttl-<seconds> (30 to 129,600 seconds, 20 minutes by default) after the location, as in <login>-country-us-region-new_york-city-new_york-session-he9f2qga-ttl-600. ProxyField sticky sessions last from 30 s to 36 h.

Chrome, Edge and Firefox ship a major version about every two weeks. Rather than copying strings from old lists, read the current versions from the vendors' own feeds, build the strings from the formats above, and drop anything more than two major versions behind from a downloaded list:

import json, re, urllib.request

chrome = json.load(urllib.request.urlopen(
    "https://googlechromelabs.github.io/chrome-for-testing/last-known-good-versions.json"))
firefox = json.load(urllib.request.urlopen(
    "https://product-details.mozilla.org/1.0/firefox_versions.json"))
CURRENT = {
    "Chrome": int(chrome["channels"]["Stable"]["version"].split(".")[0]),      # 156 on 2026-10-27
    "Firefox": int(firefox["LATEST_FIREFOX_VERSION"].split(".")[0]),           # 158
}
print(f"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/{CURRENT['Chrome']}.0.0.0 Safari/537.36")
print(f"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:{CURRENT['Firefox']}.0) Gecko/20100101 Firefox/{CURRENT['Firefox']}.0")

def fresh(ua, lag=2):
    for name, major in CURRENT.items():
        m = re.search(rf"\b{name}/(\d+)", ua)
        if m:
            return int(m.group(1)) >= major - lag
    return False          # no Chrome or Firefox token (Safari, CriOS, bots): check those by hand

req = urllib.request.Request("https://microlink.io/user-agents.json",
                             headers={"User-Agent": "ua-list-check/1.0"})   # Python's default "Python-urllib/3.x" gets a 403
downloaded = json.load(urllib.request.urlopen(req))["user"]
current = [ua for ua in downloaded if fresh(ua)]
print(len(downloaded), len(current))      # 100 23 on 2026-10-27

On 2026-10-27 the filter kept 23 of Microlink's 100 browser strings (Chrome 154 to 156, Firefox 157 and 158); 19 strings had no Chrome or Firefox token and need a look by hand, and Samsung Internet's Chrome/143 base fails the test even when the browser is current. What a user agent is, how to read one and why sites care is in what is a user agent.

The right string, from the right place. ProxyField residential proxies with country, region and city targeting and sticky sessions up to 36 h, from $1.95/GB with no subscription. Start with the Easy Trial (1 GB for $2.95); traffic never expires, and all purchases are final.