These Nodes perform cryptographic, encoding, and time-based operations essential for secure authentication flows and data transformation.

• Current Unix Time: Returns the current timestamp in Unix epoch format (milliseconds since January 1, 1970 UTC).
• Encode URI Component: Performs URL encoding to make strings safe for use in URL query parameters.
• Generate Code Challenge: Generates a PKCE code challenge for OAuth 2.0 authorization flows.
• Generate Random String: Generates a cryptographically random string with configurable length and character set.
• Sha256 Hash: Computes the SHA-256 cryptographic hash of an input string.

Current Unix Time

This Node returns the current timestamp in Unix epoch format (milliseconds since January 1, 1970 UTC). This timestamp format is commonly used for API requests, logging, and date calculations.

Common Use Cases:

• Adding timestamps to API requests that require temporal validation
• Logging when specific Flow actions occurred
• Calculating time differences or expiration times
• Generating unique identifiers by combining timestamps with other values

📍📍📍 Note 📍📍📍

The Current Unix Time Node returns the timestamp in milliseconds. Some APIs expect timestamps in seconds—divide the result by 1000 if needed.

Encode URI Component

This Node performs URL encoding on a string, making it safe for use in URL query parameters by converting special characters into percent-encoded format.

To configure Encode URI Component, select the Node on the Canvas and then open the Settings cog in the Right Sidebar.

• Value: The string to encode. This can be a static value or data from previous Nodes in your Flow.

Common Use Cases:

• Encoding search queries before adding them to API URLs
• Ensuring user-generated content is URL-safe
• Encoding parameter values that contain special characters (spaces, &, =, etc.)
• Preparing data for OAuth redirect URLs

💡💡💡 Tip 💡💡💡

Use Encode URI Component when constructing query parameters manually. If using the Network Request Node's Params section, encoding is handled automatically.

Generate Code Challenge

This Node generates a PKCE (Proof Key for Code Exchange) code challenge for OAuth 2.0 authorization flows. PKCE is a security extension that protects authorization codes from interception attacks, particularly important for mobile and single-page applications.

To configure Generate Code Challenge, select the Node on the Canvas and then open the Settings cog in the Right Sidebar.

• Code Verifier: A cryptographically random string (typically 43-128 characters) used as the base for generating the challenge. Use the Generate Random String Node to create this value.
• Method: The transformation method applied to the code verifier:
• • S256 (Recommended): Applies SHA-256 hashing and base64url encoding to the verifier
  • Plain: Uses the verifier directly without transformation (less secure, only use if S256 is not supported)

Common Use Cases:

• Implementing secure OAuth 2.0 flows in native applications
• Protecting authorization codes in single-page applications
• Building custom authentication flows that require PKCE

💡💡💡 Tip 💡💡�💡

A complete PKCE flow typically requires three Nodes: Generate Random String (for the verifier), Generate Code Challenge (for the challenge), and Sha256 Hash (if additional hashing is needed). Store the verifier using Set State with Secure storage so it can be retrieved during the token exchange step.

Generate Random String

This Node generates a cryptographically random string with configurable length and character set. This is essential for creating secure tokens, identifiers, and cryptographic values.

To configure Generate Random String, select the Node on the Canvas and then open the Settings cog in the Right Sidebar.

• Length: The number of characters in the generated string. For security-sensitive uses like OAuth verifiers, use at least 43 characters.
• Character Set: The pool of characters to use when generating the string:
• • Alphanumeric: Letters (a-z, A-Z) and numbers (0-9)
  • Alphabetic: Letters only (a-z, A-Z)
  • Numeric: Numbers only (0-9)
  • Hex: Hexadecimal characters (0-9, a-f)
  • Custom: Specify your own character set

Common Use Cases:

• Generating OAuth 2.0 PKCE code verifiers (use 43-128 alphanumeric characters)
• Creating unique session identifiers
• Generating secure temporary tokens
• Creating random test data

📍📍📍 Note 📍📍📍

This Node uses cryptographically secure random generation, making it suitable for security-sensitive operations. Do not use this for non-security purposes that require predictable or reproducible randomness.

Sha256 Hash

This Node computes the SHA-256 cryptographic hash of an input string. SHA-256 is a widely-used hashing algorithm that produces a fixed-size 256-bit (32-byte) hash value, commonly represented as a 64-character hexadecimal string.

To configure Sha256 Hash, select the Node on the Canvas and then open the Settings cog in the Right Sidebar.

• Input: The string to hash. This can be a static value or data from previous Nodes in your Flow.
• Encoding: The output format for the hash:
• • Hex (Default): Returns the hash as a hexadecimal string (64 characters)
  • Base64: Returns the hash as a base64-encoded string (44 characters)
  • Base64url: Returns the hash as a base64url-encoded string (43 characters, URL-safe)

Common Use Cases:

• Generating OAuth 2.0 PKCE code challenges from verifiers
• Creating content fingerprints for cache invalidation
• Hashing data for integrity verification
• Generating deterministic identifiers from input data

💡💡💡 Tip 💡💡💡

For OAuth 2.0 PKCE flows using the S256 method, hash the code verifier with base64url encoding. The complete flow: Generate Random String → Sha256 Hash (base64url) → use result as code challenge.

📍📍📍 Note 📍📍📍

SHA-256 is a one-way hash function—you cannot reverse the hash to retrieve the original input. Do not use this for encrypting data that needs to be decrypted later.