API Key and .env Secret Generator
Generate secure local API keys, provider .env placeholders, JWT secrets, database passwords, webhook secrets, encryption keys, and ready-to-copy .env blocks in your browser.
Local AI Endpoint
Provider Variables
Select only the providers your app actually uses.
App Auth
Database URL
.env Output
20 variables in current selection
# Local OpenAI-Compatible API
OPENAI_COMPATIBLE_BASE_URL=http://localhost:1234/v1
OPENAI_COMPATIBLE_API_KEY=""
OPENAI_COMPATIBLE_MODEL=local-model
INTERNAL_API_KEY=""
# AI Provider Keys - Paste From Dashboard
HF_TOKEN=paste_huggingface_token_here
HUGGINGFACE_API_KEY=paste_huggingface_token_here
HUGGINGFACEHUB_API_TOKEN=paste_huggingface_token_here
OPENAI_API_KEY=paste_openai_api_key_here
ANTHROPIC_API_KEY=paste_anthropic_api_key_here
GOOGLE_API_KEY=paste_google_ai_studio_key_here
GEMINI_API_KEY=paste_google_ai_studio_key_here
# Auth and Tokens
JWT_SECRET=""
NEXTAUTH_SECRET=""
SESSION_SECRET=""
ENCRYPTION_KEY_HEX=""
WEBHOOK_SECRET=""
CRON_SECRET=""
APP_URL=http://localhost:3000
# Database
DATABASE_PASSWORD=""
DATABASE_URL=postgresql://app_user:password@localhost:5432/app_dbLocal OpenAI-Compatible API
4 variablesOPENAI_COMPATIBLE_BASE_URL
Base URL for LM Studio, Ollama proxy, vLLM, LocalAI, or any OpenAI-compatible local server.
OPENAI_COMPATIBLE_API_KEY
Local bearer token for your own OpenAI-compatible endpoint. This is not an official OpenAI key.
OPENAI_COMPATIBLE_MODEL
Default local model name used by your app.
INTERNAL_API_KEY
Internal service-to-service API key for local or private endpoints.
AI Provider Keys - Paste From Dashboard
7 variablesHF_TOKEN
Primary Hugging Face token used by Hugging Face Hub, Inference API, and many libraries.
HUGGINGFACE_API_KEY
Alias used by some apps for Hugging Face API access.
HUGGINGFACEHUB_API_TOKEN
Common LangChain/Hugging Face Hub variable name.
OPENAI_API_KEY
Official OpenAI key must be created in your OpenAI dashboard.
ANTHROPIC_API_KEY
Claude API key from Anthropic Console. This does not use OPENAI_BASE_URL.
GOOGLE_API_KEY
Google AI Studio / Gemini API key used by many SDKs.
GEMINI_API_KEY
Gemini-specific alias used by many templates.
Auth and Tokens
7 variablesJWT_SECRET
HMAC secret for signing and verifying JWTs.
NEXTAUTH_SECRET
NextAuth/Auth.js secret for encrypting cookies and tokens.
SESSION_SECRET
Generic session/cookie signing secret.
ENCRYPTION_KEY_HEX
32-byte hex key suitable for AES-256 style app encryption workflows.
WEBHOOK_SECRET
Secret for verifying webhook payloads in development or private apps.
CRON_SECRET
Secret for protecting scheduled job endpoints.
APP_URL
Local app origin used by auth callbacks and absolute URLs.
Database
2 variablesDATABASE_PASSWORD
Strong database password with URL-safe special characters.
DATABASE_URL
Ready connection string with the generated password URL-encoded.
The word “generate” means two different things on this page
This is the single most common point of confusion, so it is worth being blunt about it. The tool generates two kinds of values, and they are not interchangeable. The first kind is a secret you own outright: a JWT_SECRET, a session key, a database password, an encryption key, or a bearer token for your own local inference server. Those are created here, in your browser, and they are real and final the moment they appear. Nobody issued them to you; you are the authority.
The second kind is a placeholder for a secret that only a provider can mint. When you tick OpenAI, the tool does not produce a working OPENAI_API_KEY, because it cannot. That key is minted on OpenAI’s servers, tied to your billing account, and revocable by them. What the tool gives you is the exact variable name your SDK expects and a value that reads paste_openai_api_key_here so the slot is obvious. The value is doing you a favor by being useless: it will fail loudly if you forget to replace it, rather than silently authenticating as the wrong thing.
Getting the variable name right matters more than it sounds. Hugging Face libraries variously read HF_TOKEN, HUGGINGFACE_API_KEY, or HUGGINGFACEHUB_API_TOKENdepending on which one you import, which is why ticking Hugging Face emits all three aliases pointed at the same placeholder. A key pasted under the wrong name is invisible to the SDK, and the resulting “no credentials found” error sends people debugging their token when the token was fine.
Why a good password can arrive at your app broken
The database password alphabet includes #, %, @, and = on purpose, because a wider symbol set raises entropy per character. But the .env format has a rule that trips almost everyone: outside of quotes, a #begins an inline comment. So a line like DATABASE_PASSWORD=wY.GlB#4CdQ is parsed by dotenv as the value wY.GlB, with everything from the hash onward thrown away as a comment. The app boots, connects with a truncated six-character password, and the failure surfaces as an authentication error that looks nothing like a parsing bug.
This tool resolves it by inspecting every value before it writes the line. If the value is made entirely of characters that are safe unquoted — letters, digits, and a short list of punctuation that excludes #— it is emitted raw. Otherwise it is wrapped in double quotes, which dotenv unwraps back to the exact original string, hash included. That is why you will occasionally see one variable quoted and its neighbors bare: the tool quotes only when the value genuinely needs it.
The DATABASE_URLline sidesteps the problem a different way. A password sitting inside a connection string cannot rely on quoting, because the surrounding URL syntax has its own reserved characters — @ separates credentials from the host, : separates user from password and host from port. So there the password is percent-encoded: # becomes %23, @ becomes %40, and the driver decodes it back when it parses the URL. Same password, two encodings, because the two destinations have different escaping rules.
How much randomness is in each value
Every secret draws from crypto.getRandomValues, the browser’s cryptographically secure generator, not Math.random. The lengths are chosen so entropy is never the weak link:
- JWT_SECRET — 64 base64url characters, 384 bits. Comfortably above what HMAC-SHA256 signing needs.
- NEXTAUTH_SECRET / SESSION_SECRET — 48 characters, 288 bits.
- ENCRYPTION_KEY_HEX — a true 32-byte value, 256 bits, rendered as 64 hex characters and sized exactly for AES-256.
- DATABASE_PASSWORD — 32 characters from a 70-symbol alphabet, roughly 196 bits.
For scale: 128 bits is the threshold beyond which brute force is considered physically infeasible. Every value here clears it several times over, so lengthening them further buys nothing real.
What this tool deliberately does not do
A generator that overpromises is worse than one with honest limits:
- It does not mint provider keys. OpenAI, Anthropic, and Stripe keys come from their dashboards and are billed to your account.
- It does not store or sync anything. Reload the page and the secrets are gone; there is no history to recover a value from.
- It does not rotate secrets or push them anywhere. Getting a value into a secrets manager, and replacing it on a schedule, is on you.
- It does not validate that a value fits a specific framework’s exact key-length rule — it aims for generously safe lengths, not per-library minimums.
Where the real risk is once the file exists
A 384-bit secret does nothing for you if the .env file lands in a public repository, and that is the failure mode that actually happens. Before the first commit, add .env, .env.local, and .env.production to .gitignore. If a real key has ever been committed, deleting the line is not enough — it lives in the git history, so the only safe move is to rotate the key at the provider and treat the old one as burned.
These generated values are meant for local development and private infrastructure you control. Production secrets belong in a runtime secrets manager — the injected environment on your host, or a dedicated store like HashiCorp Vault, AWS Secrets Manager, or Google Secret Manager — not in a file checked into a repo, even a private one. The generator gets you a strong starting value in seconds; deciding where it lives, who can read it, and how often it changes is the part no tool can do for you.
Note: This is a developer utility for generating local placeholders and configuration. You are responsible for verifying the suitability, storage, and rotation of any value used in staging or production. Treat every generated secret as sensitive from the moment it appears.
How to Use
Choose a preset for local AI endpoints, provider placeholders, auth secrets, database variables, or a full-stack .env.
Tick only the AI providers your app uses, then adjust endpoint, app URL, database name, user, host, and port if needed.
Click Regenerate to create fresh Web Crypto powered secrets.
Copy the full .env block or copy individual variables into your project.
Features
Common Questions
About API Key and .env Secret Generator
Create strong local-development secrets in the browser: a 384-bit JWT_SECRET, NextAuth and session keys, a true 256-bit AES encryption key, a URL-safe database password, and a ready DATABASE_URL with the password percent-encoded. Provider rows (Hugging Face, OpenAI, Anthropic, Gemini, OpenRouter, Groq, Mistral, Azure OpenAI, and more) emit the correct variable names with clearly-marked dashboard placeholders, since real provider keys can only be minted by the provider. Every value comes from the Web Crypto API, and any secret containing a hash is quoted so dotenv does not silently truncate it at the inline comment.
Also known as: generate secret key, api key generator, env secret, random secret generator, jwt secret, dotenv generator, nextauth secret generator, session secret generator, database password generator, database url builder, encryption key generator, aes 256 key generator, webhook secret generator, huggingface env variables, openai env template, secure random token.
Processing Note
API Key and .env Secret Generator runs in your browser, so the input you enter is processed locally on this page and is not uploaded to a ToolMintX account.
Tool Limits
IT tools provide quick diagnostics and transformations. They cannot see every private network, deployment setting, proxy, firewall, or production edge case.
Explore More
AI VRAM Calculator
Estimate GPU VRAM for LLM inference and training using model, quantization, users, and context length.
Client-sideAI API Cost Calculator
Compare and estimate AI API costs across OpenAI, Claude, Gemini, DeepSeek and more for text, image, video, and embeddings.
Client-sideSubnet Calculator
IPv4 subnet calculator: network and broadcast address, subnet and wildcard mask, usable host range, and host count from any IP and CIDR prefix.
Client-sideIPv4 to IPv6 Converter
Convert an IPv4 address into its IPv4-mapped IPv6 form, 6to4 prefix, and mixed notation, in canonical RFC 5952 hex.
Client-side