What Is a UUID? Complete Guide to Generating & Using Unique Identifiers

550e8400-e29b-41d4-a716-446655440000

import uuid

        # UUID v4 — recommended, random
        v4 = uuid.uuid4()

        print(v4)
        # 550e8400-e29b-41d4-a716-446655440000

        print(str(v4))
        # same, as string

        print(v4.hex)
        # 550e8400e29b41d4a716446655440000 (no dashes)

        print(v4.int)
        # 113059749145936325402354257176981405696 (integer)

        print(v4.bytes)
        # raw bytes (16 bytes)

        # UUID v1 — time-based
        v1 = uuid.uuid1()

        print(v1)
        # 6ba7b810-9dad-11d1-80b4-00c04fd430c8

        # UUID v5 — name-based (SHA-1)
        v5 = uuid.uuid5(
            uuid.NAMESPACE_URL,
            'https://quicktexttools.in'
        )

        print(v5)
        # deterministic — same output every time for same input

        # Nil UUID
        nil = uuid.UUID(int=0)

        print(nil)
        # 00000000-0000-0000-0000-000000000000

import uuid

        def generate_uuids(
            count: int,
            uppercase: bool = False,
            no_dashes: bool = False
        ) -> list[str]:

            results = []

            for _ in range(count):
                u = str(uuid.uuid4())

                if no_dashes:
                    u = u.replace('-', '')

                if uppercase:
                    u = u.upper()

                results.append(u)

            return results

        # Generate 1000 UUIDs and save to file
        uuids = generate_uuids(1000)

        with open('uuids.txt', 'w') as f:
            f.write('\n'.join(uuids))

        print(f"Saved {len(uuids)} UUIDs to uuids.txt")

import uuid

        def is_valid_uuid(value: str) -> bool:
            try:
                uuid.UUID(str(value))
                return True

            except ValueError:
                return False

        print(
            is_valid_uuid(
                "550e8400-e29b-41d4-a716-446655440000"
            )
        )
        # True

        print(
            is_valid_uuid("not-a-uuid")
        )
        # False

        print(
            is_valid_uuid(
                "550e8400e29b41d4a716446655440000"
            )
        )
        # True (no dashes OK)

        # Validate and get version
        def get_uuid_version(value: str) -> int | None:
            try:
                return uuid.UUID(str(value)).version

            except ValueError:
                return None

// Native — works in modern browsers and Node.js 19+
        const uuid = crypto.randomUUID();

        console.log(uuid);
        // '550e8400-e29b-41d4-a716-446655440000'

        // Bulk generation
        function generateUuids(
          count,
          { uppercase = false, noDashes = false } = {}
        ) {
          return Array.from(
            { length: count },
            () => {
              let u = crypto.randomUUID();

              if (noDashes) {
                u = u.replace(/-/g, '');
              }

              if (uppercase) {
                u = u.toUpperCase();
              }

              return u;
            }
          );
        }

        const uuids = generateUuids(
          100,
          { uppercase: true }
        );

        console.log(uuids.length);
        // 100

// npm install uuid

        import {
          v4 as uuidv4,
          v1 as uuidv1,
          v5 as uuidv5,
          NIL,
          validate,
          version,
        } from 'uuid';

        // v4 — random
        console.log(uuidv4());
        // 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'

        // v1 — time-based
        console.log(uuidv1());
        // time-ordered UUID

        // v5 — name-based
        const NAMESPACE =
          '6ba7b810-9dad-11d1-80b4-00c04fd430c8';

        console.log(
          uuidv5('hello', NAMESPACE)
        );
        // deterministic

        // nil UUID
        console.log(NIL);
        // '00000000-0000-0000-0000-000000000000'

        // Validation
        console.log(
          validate(
            '550e8400-e29b-41d4-a716-446655440000'
          )
        );
        // true

        console.log(
          version(
            '550e8400-e29b-41d4-a716-446655440000'
          )
        );
        // 4

function generateUUIDv4() {   if (typeof crypto !== 'undefined' && crypto.randomUUID) {     return crypto.randomUUID();   }   // Fallback using Math.random (less secure — use only if crypto unavailable)   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {     const r = Math.random() * 16 | 0;     const v = c === 'x' ? r : (r & 0x3 | 0x8);     return v.toString(16);   }); }