RSA Key Pair Generator Online — 2048/3072/4096, PEM & JWK

What is RSA Key Generator?

An RSA Key Generator produces an asymmetric key pair used for signing (JWT RS256/PS256, SSH keys, TLS certs) or encryption (RSA-OAEP for data at rest, hybrid schemes for envelopes). The private key stays on the machine that signs or decrypts; the public key is safe to publish. Modern production systems use 2048 bits at minimum, 3072 for medium-term (10+ years), 4096 for regulated / long-lived roots.

How to generate an RSA key pair

1. 1Choose a key size — 2048 for most APIs, 3072 for stronger long-term signing, 4096 for CA roots and compliance-sensitive workloads.
2. 2Click Generate. `crypto.subtle.generateKey` runs in your browser; larger keys take a few seconds.
3. 3Copy or download the private key in PEM (PKCS#8, `-----BEGIN PRIVATE KEY-----`), JWK, or DER format.
4. 4Copy the public key in SPKI PEM (`-----BEGIN PUBLIC KEY-----`), JWK, or DER — this is the safe half to share.
5. 5For JWT signing, feed the private key into your signer and publish the public key at `/.well-known/jwks.json` (use our JWKS Generator to assemble the endpoint).

Use Cases

Code Examples

# 2048-bit RSA, PKCS#8 private key + SPKI public key
openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:2048 -out private.pem
openssl pkey -in private.pem -pubout -out public.pem

import { generateKeyPair } from "node:crypto";
import { promisify } from "node:util";

const { publicKey, privateKey } = await promisify(generateKeyPair)("rsa", {
  modulusLength: 2048,
  publicKeyEncoding: { type: "spki", format: "pem" },
  privateKeyEncoding: { type: "pkcs8", format: "pem" },
});

from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
pem = key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption(),
)

import (
    "crypto/rand"
    "crypto/rsa"
)

key, err := rsa.GenerateKey(rand.Reader, 2048)

Key Concepts

PKCS#8 vs. PKCS#1

PKCS#8 (`-----BEGIN PRIVATE KEY-----`) is the modern envelope for any private key type. PKCS#1 (`-----BEGIN RSA PRIVATE KEY-----`) is the older RSA-only format. Web Crypto and most modern libraries produce PKCS#8; convert with `openssl pkcs8 -topk8 -in pkcs1.pem -out pkcs8.pem -nocrypt`.

SPKI

SubjectPublicKeyInfo — the standard container for public keys (`-----BEGIN PUBLIC KEY-----`). Contains the key type identifier plus the raw key bits, so a single format works for RSA, EC, Ed25519, etc.

Key size trade-offs

2048 bits is the current baseline (roughly 112 bits of security, safe through ~2030). 3072 gives 128-bit security, matching AES-128. 4096 is ~144-bit, useful for CA roots that must remain safe for decades. Doubling key size ~8x's signing cost.

Public exponent

Almost always 65537 (0x010001). It's a Fermat prime, making key generation fast and eliminating known low-exponent attacks. If a library asks, keep the default.

Tips & Best Practices

• ▸For JWT signing, prefer RS256 (widely supported) or PS256 (RSA-PSS, side-channel-safer signatures). Both use the same key pair.
• ▸Never commit private keys to git. Even 'test' keys — attackers scan public repos for `BEGIN PRIVATE KEY` in seconds.
• ▸If you need faster / smaller keys, switch to ECDSA (ES256 / P-256). 256-bit EC ≈ 3072-bit RSA in strength, but signatures are ~8x smaller.
• ▸PEM files must have exactly `-----BEGIN X-----`, a newline, base64 wrapped at 64 chars, a newline, and `-----END X-----`. Reformatting can silently break parsers.