URL shortener tool
Shorten a URL
Paste a long link below. The short version appears instantly
- Works with any valid URL, including video links, shared documents, and long tracking links.
- Your history is saved locally in this browser only. Nothing is uploaded.
- Deleting a link from history disables its redirect permanently.
What happens, start to finish
Here's a realistic walkthrough with a tracked product link, the kind that usually looks the messiest once a marketing tool has added its parameters.
Starting point
A product page with tracking parameters attached: https://shop.example.com/products/trail-shoes?ref=newsletter&utm_source=email&utm_campaign=spring
Paste and shorten
Paste the full address into the field above and press Shorten URL. The tool checks the protocol, generates a short ID with the Web Crypto API, and saves the mapping locally, all in under a second.
Result
The output is a fixed-length link such as zitly.net/go/k7Hq2. The tracking parameters travel with the redirect, so the destination site's analytics keep working exactly as before.
Put it to use
Drop the short link into a newsletter, print it on a flyer, or turn it into a QR code. Every one of those formats benefits from the shorter, cleaner string.
How a short link gets built, under the hood
Most write-ups of URL shortener system design assume a server, a database, and a cache in front of it. Zitly's version answers the same four questions with everything running in the browser tab you already have open. Knowing the mechanics also explains the honest limits section further down this page.
Generate an ID
Your browser's Web Crypto API produces five cryptographically random bytes, mapped onto a 62-character set (a–z, A–Z, 0–9). That's roughly 916 million possible short IDs, so a collision is vanishingly unlikely even after thousands of saved links.
Check for a collision
Before saving, the new ID is checked against every ID already stored in this browser. On the rare chance it already exists, the tool quietly generates another and checks again, no visible retry, no wasted click.
Store the pair
The short ID and your original URL are written into a single JSON object under one localStorage key. This is the same browser storage mechanism a site uses to remember a login session or a theme preference, repurposed here to hold your link map.
Resolve the redirect
When someone opens the short link, a dedicated route reads the ID from the path, looks it up in that stored map, and sends the browser straight to the destination. No server round trip is involved in the lookup itself.
Where a short link earns its keep
The same short link behaves a little differently depending on where it's used. Here's what actually changes by channel.
Social posts
Character limits on X and link previews on LinkedIn both treat a long URL as dead weight. LinkedIn also auto-rewrites any link you paste into a post to its own lnkd.in domain, so the visible link changes regardless of which shortener you used to make it.
A short link stays a fixed, compact length no matter how long or parameter-heavy the original address was.
Email campaigns
A long query string sometimes wraps mid-URL in clients like Outlook, turning a clickable link into two lines of broken text. A short link wraps cleanly on any layout.
Use the Copy as HTML button to grab a ready anchor tag, so the visible text and the href stay separated when it's pasted into a template.
Print and physical goods
Nobody can type a 140-character link from a flyer, and a long URL also produces a denser, slower-scanning QR code.
Export a QR code straight from the short link, ready for a business card, a poster, or packaging.
Campaign tracking
If a destination's own analytics need to attribute traffic, UTM parameters have to be on the URL before it's shortened, not after.
Build the full URL with utm_source, utm_medium, and utm_campaign first, confirm it opens correctly, then shorten the finished address.
Zitly next to Bitly, Google, and the rest
Every URL shortener makes the same core trade: local privacy versus server-side features like custom domains and click analytics. Here's where Zitly actually sits on that line, stated plainly rather than as a sales pitch.
| Tool | How it's built | Custom names | The trade-off |
|---|---|---|---|
| Bitly | Server-backed. Links, click counts, and custom domains live in Bitly's account system. | Yes, on paid plans | Analytics and branded domains, in exchange for an account and a subscription for anything beyond the basics. |
| Google's shortener (goo.gl) | Discontinued. Google retired goo.gl in 2019 and migrated existing links to Firebase Dynamic Links, which Google has since wound down too. | No longer available | A cautionary example of what happens to links when a shortener depends on one company keeping a service running. |
| Canva / Adobe Express link tools | A small feature bundled inside a much larger design app, aimed at people already building a graphic there. | Limited or none | Convenient if you're already in that app for a design; not built as a standalone utility. |
| Zitly | Fully client-side. The ID and the mapping are generated and stored in your own browser, never on a server. | Not yet (see below) | Maximum privacy and zero account, in exchange for links that resolve only on the browser that created them and no click analytics. |
Microsoft's internal aka.ms links and browser extensions that wrap a shortener's API work on the same idea as Bitly: a server keeps the map so the alias can be memorable and consistent across devices. That consistency is exactly what a fully local tool like Zitly gives up.
Why there's no custom short link name yet
A URL shortener with a custom name, something like zitly.net/go/launch instead of a random string, needs one thing Zitly's design deliberately avoids: a shared server database that every visitor's browser checks against. Without it, there's no way to confirm that "launch" hasn't already been claimed by someone else.
That's the real reason a free custom-name shortener almost always runs on a server, the way Bitly's does. Zitly instead keeps every link private to the browser that made it, which rules out a shared namespace by design, not by accident.
It's a genuine trade-off, and it's one worth naming instead of hiding. An opt-in mode with custom aliases, backed by a server for that feature alone, is on the list of things being weighed for a future version.
Before you share a short link
A short checklist that prevents the handful of mistakes people actually run into.
- Click the short link once yourself to confirm it opens the right page before sharing it publicly
- Keep using the same browser and device if you'll need to manage or delete the link later
- Copy the link as HTML when pasting into an email template or a CMS that expects an anchor tag
- Generate the QR version early if the link is going on anything printed, so you can proof it before the print run
- Don't clear this browser's site data if you still need this link's history
- Don't expect the same short link to resolve from a history saved on a different device
- Don't shorten a URL that already points through another shortener — that stacks redirects and slows the final destination
What this tool doesn't do, and why that's often fine
Being upfront about the trade-offs of a browser-only shortener, so you can decide up front whether it fits what you're building.
A link is tied to the browser that made it
Because the redirect map lives in localStorage, a short link created on a laptop resolves only when it's opened in that same browser profile. The link can be clicked from anywhere; the lookup itself only succeeds where the mapping was stored.
No custom aliases in this version
A custom back-half (zitly.net/go/launch, for instance) requires checking a name against everyone else's links at once, which means a shared server database. Zitly deliberately skips that server so nothing about your links is visible outside your own browser. It's a genuine feature the fully local design trades away, not a bug.
No built-in click analytics
Nothing is logged server-side, so this tool can't report how many times a link was clicked or from where. If that matters, add UTM parameters to the original URL before shortening it, and read the numbers from the destination site's own analytics.
A practical storage ceiling, rarely reached
Browsers typically allow 5–10 MB of localStorage per site. At roughly 100–200 bytes per saved link, that's realistic room for tens of thousands of entries, though the visible history list is capped at the most recent 20 for readability.
Questions people ask before shortening a link
Direct answers on privacy, custom names, other tools, and how this one actually works.
Yes. There's one version of the tool and it's free: no account, no subscription, no per-link fee, and no daily cap on how many links you create.
A short link stays active for as long as it exists in your browser's local history. Deleting it disables the redirect permanently, and clearing your browser's site data removes every link at once.
No. The short ID comes from the Web Crypto API and the mapping is saved only in your browser's localStorage. The original URL you paste in never reaches a Zitly server, which is the opposite of how server-backed tools like Bitly are built.
Not in this version. Checking whether a custom alias is already taken requires a shared server-side namespace, and adding one would mean giving up the fully local, private design this tool is built around. It's a real trade-off we're weighing, not an oversight.
Bitly is server-backed and built around paid custom domains and click analytics. Google's goo.gl shortener was retired in 2019. Canva and Adobe Express bundle basic link-shortening as one small feature inside a much larger design app. Zitly is a single-purpose, browser-only tool: no analytics, no account, nothing leaves your device.
Not as a bulk file yet. Every link in your history can be copied individually with one click, and any short link can be turned into a downloadable QR code. A full history export is on the list of features being considered.
Not yet. Right now the tool lives on this page, which behaves the same in any browser without installing anything. A one-click extension for the current tab is a reasonable next step and it's noted for a future release.
Anyone can click it. But because the redirect map lives in the browser that created it, the lookup only succeeds on that specific browser and device. Opened elsewhere without that stored data, it will show a not-found page instead.
Yes, it behaves like any other URL. One LinkedIn-specific note: LinkedIn automatically rewrites links pasted into a post to its own lnkd.in domain, so your link displays as lnkd.in after posting even though the destination hasn't changed.
A dedicated redirect route reads the short ID from the URL path, looks it up in the map stored in localStorage, and forwards the browser straight to the matching destination. The lookup happens client-side and finishes in a fraction of a second.
Still curious how people weigh free versus paid shorteners? Threads on Reddit comparing them are worth a search, most land on the same account-and-analytics trade-off above.
Shorten your first link
No signup screen stands between you and this tool. Paste a URL and see the result.