JWT Token Payload Builder & Encoder
Build RFC 7519 JSON Web Tokens with standard registered claims (iss, sub, aud, exp, iat) and custom JSON payload structures.
Unlike conventional calculator sites that send your financial numbers, payload data, or code snippets across remote web servers, Affi-Chain processes all mathematical derivations, algorithms, and data parsing 100% locally within your browser sandbox. No tracking cookies, no server-side retention, and zero transmission lag.
What is an RFC 7519 JWT Payload Builder?
A JWT Payload Builder is an identity and security configuration tool designed to construct, format, and validate claims-based payloads compliant with the IETF RFC 7519 JSON Web Token (JWT) specification. In modern distributed cloud systems, Single Sign-On (SSO) gateways, microservice architectures, and OAuth 2.0 / OpenID Connect (OIDC) authentication flows, JWTs serve as the universal standard for exchanging verifiable identity assertions and authorization privileges.
A standard signed JWT comprises three distinct dot-separated Base64URL-encoded components:
$$\text{JWT} = \text{Base64URL}(\text{Header}) \mathbin{\Vert} \text{"."} \mathbin{\Vert} \text{Base64URL}(\text{Payload}) \mathbin{\Vert} \text{"."} \mathbin{\Vert} \text{Base64URL}(\text{Signature})$$
While the Header specifies the cryptographic algorithm (e.g., HS256, RS256, ES256) and the Signature guarantees tamper-resistance, the Payload contains the core business data—known as Claims. Authoring payloads manually frequently introduces bugs: developers accidentally format Unix expiration timestamps as millisecond strings instead of second integers, misspell standard claim keys (expire instead of exp), or inadvertently embed sensitive credentials inside unencrypted tokens.
The Affi-Chain JWT Payload Builder provides an interactive interface for configuring RFC-standard registered claims, adding custom application scopes, computing expiration time-to-live (TTL) timestamps, and outputting clean, validated JSON payloads directly in your browser with complete privacy.
RFC 7519 Registered Claims Architecture Matrix
The RFC 7519 specification reserves seven standardized, three-letter claim identifiers to ensure cross-platform interoperability:
| Claim Key | Claim Name | Expected Data Type | Architectural Purpose | Example Value |
|---|---|---|---|---|
iss | Issuer | String / URI | Identifies the identity provider or authority issuing the token | "https://auth.company.com/" |
sub | Subject | String | The unique identity identifier of the principal (user or service) | "usr_98412891" |
aud | Audience | String or Array of Strings | Identifies the target API or recipient resource the token is intended for | "https://api.company.com/v1" |
exp | Expiration Time | Numeric (Unix Seconds) | Mandatory deadline timestamp beyond which token must be rejected | 1763481600 |
nbf | Not Before | Numeric (Unix Seconds) | Timestamp before which the token must not be accepted for processing | 1763478000 |
iat | Issued At | Numeric (Unix Seconds) | Timestamp marking the exact moment the token was created | 1763478000 |
jti | JWT ID | String | Cryptographically unique nonce identifier preventing replay attacks | "b9a1d82f-48e1-4c91" |
Time Offset Mathematics & Expiration TTL Formulation
All temporal claims (exp, nbf, iat) in RFC 7519 are defined strictly in seconds since the Unix Epoch (January 1, 1970 00:00:00 UTC), not milliseconds:
$$\text{Current Timestamp (Seconds): } t_{\text{now}} = \left\lfloor \frac{\text{Date.now()}}{1000} \right\rfloor$$ $$\text{Expiration Claim: } \text{exp} = t_{\text{now}} + \Delta t_{\text{TTL}}$$
Where $\Delta t_{\text{TTL}}$ represents the token lifetime in seconds (e.g., $900 \text{ s}$ for 15 minutes, $3600 \text{ s}$ for 1 hour, or $86400 \text{ s}$ for 24 hours).
Step-by-Step Practical Transformation Example
Below is a complete, production-ready claims payload for an enterprise SaaS API authorization token:
Structured JWT Claims JSON:
{
"iss": "https://auth.affichain.com",
"sub": "auth0|65b8291f09e8",
"aud": "https://api.affichain.com/v1",
"iat": 1763478000,
"nbf": 1763478000,
"exp": 1763481600,
"jti": "7c9e4821-2a1f-4b92-8e12-4c91b8a729e0",
"user": {
"name": "Sarah Connor",
"email": "sarah.connor@cyberdyne.com",
"tenant_id": "org_enterprise_99"
},
"roles": [
"billing_admin",
"security_auditor"
],
"permissions": [
"invoices:read",
"invoices:write",
"users:manage"
]
}
Practical Code Implementation: In-Browser Payload Builder & Encoder
Below is a JavaScript utility demonstrating how to construct RFC 7519 compliant payloads and serialize them into Base64URL format:
/**
* In-Browser RFC 7519 JWT Payload Builder & Serializer.
*/
class JwtPayloadBuilder {
constructor(issuer, audience) {
this.claims = {
iss: issuer,
aud: audience,
iat: Math.floor(Date.now() / 1000)
};
}
setSubject(userId) {
this.claims.sub = String(userId);
return this;
}
setTtl(seconds) {
this.claims.exp = this.claims.iat + seconds;
return this;
}
setNotBefore(delaySeconds = 0) {
this.claims.nbf = this.claims.iat + delaySeconds;
return this;
}
setUniqueId(jti = crypto.randomUUID()) {
this.claims.jti = jti;
return this;
}
addCustomClaim(key, value) {
this.claims[key] = value;
return this;
}
buildJson() {
return JSON.stringify(this.claims, null, 2);
}
toBase64Url() {
const jsonStr = JSON.stringify(this.claims);
const base64 = btoa(unescape(encodeURIComponent(jsonStr)));
return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
}
}
// Verification Example (1-Hour Session Token):
const builder = new JwtPayloadBuilder("https://auth.example.com", "https://api.example.com")
.setSubject("usr_4821")
.setTtl(3600) // 1 Hour
.setUniqueId()
.addCustomClaim("roles", ["admin", "developer"]);
console.log("Validated Claims JSON:\n", builder.buildJson());
console.log("Base64URL Segment:\n", builder.toBase64Url());
Comparison Matrix: Token & Identity Architecture Standards
| Standard | State Location | Cryptographic Integrity | Encryption by Default? | Typical Use Case |
|---|---|---|---|---|
| Signed JWT (RFC 7519) | Stateless (Client) | Yes (Digital Signature) | No (Plain Base64URL) | Microservices, REST APIs, SPA auth |
| Encrypted JWE (RFC 7516) | Stateless (Client) | Yes (Authenticated Cipher) | Yes (AES-GCM / RSA) | Transmitting confidential PII data |
| Opaque Session Tokens | Stateful (Redis / DB) | Implicit via server lookup | N/A (Random pointer) | Traditional server-rendered web apps |
| SAML 2.0 Assertions | Stateless (XML) | Yes (XML-DSig) | Optional (XML-Enc) | Legacy enterprise B2B Single Sign-On |
Critical Security Edge Cases & Common JWT Traps
1. The Confidentiality Fallacy (JWTs Are NOT Encrypted!)
A dangerous misconception among novice developers is assuming that a JWT hides or encrypts sensitive data because the string looks scrambled.
- In reality, a signed JWT is merely Base64URL encoded—anyone who captures the token can decode the payload using
atob()or tools likejwt.ioin milliseconds. - Universal Rule: Never store sensitive data (such as passwords, credit card numbers, or Social Security Numbers) inside a signed JWT payload. For confidential data, use JSON Web Encryption (JWE) or server-side sessions.
2. The Inability to Revoke Stateless Tokens
Because signed JWTs are validated purely through mathematical signature verification on the API gateway without database lookups, a token remains valid until its exp timestamp arrives. If a user changes their password or is terminated, their token cannot be revoked immediately without implementing token revocation blocklists (such as in Redis).
- Best Practice: Keep access token lifespans short ($5 \text{ to } 15 \text{ minutes}$) and use long-lived, revokable refresh tokens.
3. Distributed Server Clock Skew
In distributed microservices, slight discrepancies in server system clocks ($1 \text{ to } 5 \text{ seconds}$) can cause an authentication server to issue a token whose nbf or iat appears to be in the future to an API gateway host, triggering premature TokenNotYetValidError exceptions.
- Solution: Always configure token verification middleware with a clock skew tolerance of at least $60 \text{ seconds}$.