1. Home
  2. Developer tools
  3. WireGuard Config Generator

WireGuard Config Generator

Create a WireGuard private and public key pair and the two configuration files for a server and a client. The keys are made in your browser and are never sent or saved.

Free, no sign-up. Runs in your browser: nothing is uploaded.

How to use WireGuard Config Generator

  1. Fill in the endpoint, addresses and DNS.
  2. Click Generate.
  3. Download the server and client files.

Features

  • Curve25519 key pairs created locally
  • Preshared key option
  • Server and client files that match
  • Editable allowed IPs, DNS and keepalive
  • Public key from an existing private key
  • Keys never leave the page

Supported formats

Input

  • Peers, addresses and ports

You get

  • Key pairs
  • Interface and peer configs

Private by design

Everything you enter is processed by your browser on this device. Nothing is sent to openWorkstand or anyone else, so the WireGuard Config Generator is safe for private and work data. After you have used it once while online, it also works without an internet connection. How local processing works

Good to know

  • Keys are generated in your browser with the Web Crypto API; for high-security uses generate keys on the device that will hold them.
  • Routing, firewall and NAT rules on the server are not created.

Guide

Generating WireGuard keys and matching server and client files

WireGuard is a small, fast VPN built into current Linux kernels and available for Windows, macOS, iOS and Android. Setting it up means generating key pairs and writing two configuration files whose keys refer to each other. The page does the arithmetic in your browser and fills in the files, so you only copy them to the right machines.

Keys without a command line

A WireGuard key pair uses Curve25519. The private key is 32 random bytes in which a few bits are fixed (clamped) as RFC 7748 requires; the public key is the private key multiplied by the curve’s base point. Both are written in Base64, 44 characters long. The usual command line tool does exactly this with wg genkey and wg pubkey. The page uses the browser’s secure random generator for the private key and its own implementation of the curve arithmetic, checked against the test vectors in RFC 7748.

Filling in the form

Enter the server’s endpoint (host and port), the listen port (51820 by default), the tunnel addresses of server and client, the DNS server to give the client, the allowed IPs for the client and an optional persistent keepalive. Tick the preshared key option for the extra symmetric secret. Generate new keys and files creates both files and shows the two public keys, which are safe to share, for checking.

What the files contain

The server file has an [Interface] section with the tunnel address, listen port and the server’s private key, and a [Peer] section with the client’s public key and the single address it may use (AllowedIPs = 10.8.0.2/32). The client file has an [Interface] with its own address, private key and DNS, and a [Peer] section naming the server’s public key, the endpoint, the routed networks and the keepalive. A keepalive of 25 seconds keeps a client behind NAT reachable. If you enabled the preshared key, both peers get the same PresharedKey line.

Keeping the keys safe

Anyone who holds a private key can act as that peer. The page generates keys locally and does not store them, so copy each file straight to the device that needs it, for example by a secure transfer, and do not paste them into chat tools or tickets. For a high-value server, generate the key pair on the server itself instead of in any web page. The second panel, which shows the public key for a private key, is meant for a throwaway key to see how derivation works.

A worked example

With the defaults, the server gets the tunnel address 10.8.0.1/24 and listens on 51820. The client gets 10.8.0.2/32 and DNS 1.1.1.1, with the endpoint vpn.example.com:51820, AllowedIPs 0.0.0.0/0, ::/0 and a PersistentKeepalive of 25. The two public keys, 44 characters each, appear in both files. Because the keys are random, they differ on every run.

Limits

The page writes the WireGuard files only. The server still needs IP forwarding, firewall rules and NAT for clients to reach the Internet through it, and the UDP port must be open. It generates one server and one client; for more peers repeat the process and add further [Peer] sections by hand. Choose a safe MTU for the tunnel with the MTU and MSS Calculator.

Checked against the current version of the WireGuard Config Generator on .

Frequently asked questions

What is the preshared key for?

It adds a symmetric secret on top of the public-key exchange, so traffic recorded today stays protected even if the Curve25519 exchange is broken by a future quantum computer. It must be the same on both sides and kept secret.

Why does the client file use AllowedIPs 0.0.0.0/0, ::/0?

On the client, AllowedIPs lists the destinations to send through the tunnel. The two ranges cover all IPv4 and IPv6 traffic, so the whole connection is routed through the VPN; a narrower list sends only those networks.

Is it safe to generate keys in a browser?

The keys come from your browser’s secure random generator and stay on the page. For production keys it is better to generate them on the machine that will use them.

What do the allowed IPs do?

On the client they choose which traffic enters the tunnel: 0.0.0.0/0 and ::/0 send everything, a smaller range sends only that network. On the server they limit which source addresses the peer may use.

Keep working with the result

openWorkstand also includes a free workspace with documents, spreadsheets, tasks, projects and a calendar that save to a folder on your computer.