Google UULE Generator & Decoder

A UULE is an encoded URL query parameter (&uule=) utilized by Google's search infrastructure to determine the exact geographical location of a search request. Originally engineered for Google Ads testing and localized search quality validation, UULE overrides client-side IP geolocation, Wi-Fi triangulation, and device GPS sensors.

For search engine optimization (SEO) agencies, rank tracking software engineers, and digital advertisers, the UULE parameter allows deterministic simulation of hyper-local search engine results pages (SERPs), embedded Google Maps Local 3-Packs, and local organic rankings from any village, city, or postal centroid globally—without needing residential proxies or commercial VPNs.

Standard canonical Google UULE tokens adhere to a strict structural blueprint consisting of three sequential parts:

1. Protocol Prefix: The static 9-character string w+CAIQICI.
2. Secret Length Key: A single character denoting the string length of the canonical location name, calculated via an undocumented 64-character lookup table.
3. Base64 Payload: The standard RFC 4648 Base64 encoding of the canonical location string (UTF-8).

The secret 64-character lookup table maps character count (modulo 64) as follows:

Concrete Example: Consider the location Chicago,Illinois,United States. The string contains exactly 30 characters. In our lookup table, index 30 corresponds to lowercase e. The Base64 encoding of Chicago,Illinois,United States is Q2hpY2FnbyxJbGxpbm9pcyxVbml0ZWQgU3RhdGVz. The resulting token is w+CAIQICIeQ2hpY2FnbyxJbGxpbm9pcyxVbml0ZWQgU3RhdGVz.

Google supports two distinct UULE parameter variants:

• Type 1: Canonical Geo Name (Prefix: w+CAIQICI): The standard format used throughout SEO and PPC. It maps directly to Google's official AdWords/Google Ads geographical criteria database (e.g. City,State,Country). This is 100% deterministic, human-readable upon decoding, and accepted across all Google search endpoints worldwide.
• Type 2: Protocol Buffer GPS Coordinates (Prefix: a+): An encoded binary Protocol Buffer (Protobuf) containing hardware GPS attributes: timestamp (in microseconds), latitude (multiplied by 10^7 as a 32-bit integer), longitude (multiplied by 10^7), accuracy radius in meters, and location producer source code. Because Google frequently deprecates or alters internal Protobuf schemas, w+ canonical strings are universally preferred for automated rank tracking and audit reproducibility.

You can generate thousands of UULE parameters directly in Google Sheets without third-party add-ons. Follow this simple setup:

1. In your Google Sheet, click Extensions > Apps Script.
2. Delete any existing template code and paste the script below.
3. Click Save (Ctrl+S) and return to your sheet.
4. Use the formula =UULE(A2) where cell A2 contains the target city (e.g. Austin,Texas,United States).

/**
 * Generates a Google UULE parameter from a canonical location string.
 * @param {string} location Target location (e.g. "Seattle,Washington,United States")
 * @return {string} Canonical Google UULE parameter string
 * @customfunction
 */
function UULE(location) {
  if (!location || typeof location !== 'string') return "";
  var table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
  var clean = location.trim();
  var key = table.charAt(clean.length % 64);
  var encoded = Utilities.base64Encode(clean, Utilities.Charset.UTF_8);
  return "w+CAIQICI" + key + encoded;
}

/**
 * Builds a complete depersonalized Google search URL with UULE and pws=0.
 * @param {string} keyword Search query (e.g. "personal injury lawyer")
 * @param {string} location Target city/region
 * @return {string} Clickable Google Search URL
 * @customfunction
 */
function GOOGLE_LOCAL_SEARCH(keyword, location) {
  if (!keyword) return "";
  var base = "https://www.google.com/search?q=" + encodeURIComponent(keyword) + "&pws=0";
  if (location) {
    base += "&uule=" + UULE(location);
  }
  return base;
}

Integrate UULE generation directly into your automated rank checking scripts, Puppeteer/Playwright scrapers, and data pipelines.

import base64
import urllib.parse

def generate_uule(location: str) -> str:
    """Generate exact length-keyed Base64 Google UULE parameter."""
    lookup = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
    clean_loc = location.strip()
    key = lookup[len(clean_loc) % 64]
    b64_payload = base64.b64encode(clean_loc.encode('utf-8')).decode('utf-8')
    return f"w+CAIQICI{key}{b64_payload}"

def build_google_url(query: str, location: str, gl: str = "us", hl: str = "en") -> str:
    """Builds a complete depersonalized localized Google URL."""
    uule = generate_uule(location)
    params = {
        "q": query,
        "uule": uule,
        "gl": gl,
        "hl": hl,
        "pws": "0",
        "nord": "1"
    }
    return f"https://www.google.com/search?{urllib.parse.urlencode(params)}"

# Example Usage:
target_city = "Munich,Bavaria,Germany"
search_url = build_google_url("steuerberater", target_city, gl="de", hl="de")
print("Target URL:", search_url)

function generateUule(location) {
  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
  const target = location.trim();
  const key = chars[target.length % 64];
  const b64 = Buffer.from(target, 'utf-8').toString('base64');
  return 'w+CAIQICI' + key + b64;
}

function decodeUule(uuleToken) {
  if (!uuleToken || !uuleToken.startsWith('w+CAIQICI')) {
    throw new Error('Invalid UULE format: missing w+CAIQICI prefix');
  }
  const base64Payload = uuleToken.slice(10);
  return Buffer.from(base64Payload, 'base64').toString('utf-8');
}

// Example Verification:
const token = generateUule('Austin,Texas,United States');
console.log('Encoded:', token);
console.log('Decoded:', decodeUule(token));

Digital marketing agencies frequently waste substantial budgets on commercial VPN subscriptions or expensive residential proxy networks. The table below details why UULE is mathematically superior for search audits:

Google's search engine parses UULE canonical strings against its official Geographical Targeting Database. To ensure 100% compatibility:

• Always format strings in hierarchical order: City,Region/State,Country (e.g. Aarhus,Central Denmark Region,Denmark).
• For postal codes, append the metropolitan area: 90210,Los Angeles,California,United States.
• Avoid colloquial abbreviations like NYC or SF; use official canonical names (New York,New York,United States). Impersonal.me's built-in autocomplete automatically normalizes your search into Google's official canonical nomenclature.

If you encounter a UULE token in a client report, scraping log, or competitor URL, you can reverse engineer it in two seconds:

1. Identify and strip the static 9-character prefix: w+CAIQICI.
2. Discard the 10th character (the secret length key).
3. Pass the remaining substring through standard Base64 decoding (using atob() in browsers, Buffer.from(payload, 'base64') in Node.js, or base64.b64decode() in Python).

Alternatively, use our interactive Reverse Google UULE Decoder located directly above this guide to paste and inspect tokens instantly.