shortid

Short id generator. Url-friendly. Non-predictable. Cluster-compatible.

5,739

257

5,739

View on GitHub View on NPM

Top Related Projects

nanoid

24,296

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

cuid

3,421

Collision-resistant ids optimized for horizontal scaling and performance.

Quick Overview

ShortId is a simple, non-sequential, and URL-friendly unique ID generator for JavaScript. It creates short, unique ids that are perfect for URL shorteners, MongoDB and Redis ids, and any other id generation needs in your applications.

Pros

Generates short, unique, and non-sequential ids
URL-friendly (uses URL-safe characters)
Highly customizable (length, alphabet, etc.)
Works in both Node.js and browser environments

Cons

Not cryptographically secure
Potential for collisions in extremely large datasets
No built-in support for distributed systems
Maintenance of the project has slowed down in recent years

Code Examples

Generate a simple shortid:

const shortid = require('shortid');
const id = shortid.generate();
console.log(id); // Output: something like 'Ny8yGnbV'

Customize the id length:

shortid.characters('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$@');
shortid.length(10);
const customId = shortid.generate();
console.log(customId); // Output: a 10-character id using the custom alphabet

Check if a string is a valid shortid:

const isValid = shortid.isValid('B1bqVNXdx');
console.log(isValid); // Output: true or false

Getting Started

To use ShortId in your project, follow these steps:

Install the package:
```
npm install shortid
```

Import and use in your JavaScript file:

const shortid = require('shortid');

// Generate a new id
const id = shortid.generate();
console.log(id);

// Customize if needed
shortid.characters('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$@');
shortid.length(8);

// Generate a custom id
const customId = shortid.generate();
console.log(customId);

That's it! You can now generate short, unique ids in your application.

Competitor Comparisons

nanoid

24,296

A tiny (124 bytes), secure, URL-friendly, unique string ID generator for JavaScript

Pros of nanoid

Significantly faster performance, especially for generating multiple IDs
Smaller package size and no dependencies
More secure with better random number generation

Cons of nanoid

Less customizable ID format
No built-in collision detection (though collisions are extremely unlikely)

Code Comparison

shortid:

import shortid from 'shortid';

const id = shortid.generate();
console.log(id); // Output: "Uakgb_J5m9g-0JDMbcJqLJ"

nanoid:

import { nanoid } from 'nanoid';

const id = nanoid();
console.log(id); // Output: "V1StGXR8_Z5jdHi6B-myT"

Both libraries generate short, unique identifiers, but nanoid offers better performance and security. shortid provides more customization options but is no longer actively maintained. nanoid is generally recommended for new projects due to its speed, security, and ongoing development.

ksuid

4,889

K-Sortable Globally Unique IDs

Pros of KSUID

Sortable and time-ordered, allowing for efficient database indexing and chronological sorting
Longer length (27 characters) provides higher uniqueness guarantee
Includes a timestamp component, useful for auditing and tracking

Cons of KSUID

Longer ID length may be less user-friendly for URLs or visible identifiers
More complex implementation compared to shortid's simplicity
Requires more storage space due to longer length

Code Comparison

shortid:

const shortid = require('shortid');
const id = shortid.generate();
console.log(id); // Output: "Uakgb_J5m9g-0JDMbcJqLJ"

KSUID:

import "github.com/segmentio/ksuid"

id := ksuid.New()
fmt.Println(id.String()) // Output: "0ujtsYcgvSTl8PAuAdqWYSMnLOv"

Summary

KSUID offers better sortability and includes timestamps, making it suitable for database operations and auditing. However, shortid provides shorter, more user-friendly IDs at the cost of reduced uniqueness guarantees. The choice between the two depends on specific project requirements, such as ID length preferences, sorting needs, and timestamp inclusion.

cuid

3,421

Collision-resistant ids optimized for horizontal scaling and performance.

Pros of cuid

Generates collision-resistant IDs suitable for distributed systems
Provides better performance and scalability for high-volume ID generation
Offers more flexibility with custom fingerprints and additional entropy

Cons of cuid

Produces longer IDs (25 characters) compared to shortid's shorter output
May require additional setup for custom fingerprints or entropy sources
Less widespread adoption compared to shortid

Code Comparison

shortid:

const shortid = require('shortid');
const id = shortid.generate();
console.log(id); // Output: "Uakgb_J5m9g-0JDMbcJqLJ"

cuid:

const cuid = require('cuid');
const id = cuid();
console.log(id); // Output: "ck0pqm8te0000udocop8ov7bm"

Both libraries provide simple ways to generate unique identifiers, but cuid focuses on collision resistance and distributed systems, while shortid prioritizes shorter ID length. cuid is better suited for large-scale applications with high concurrency, whereas shortid may be preferred for scenarios where ID length is a primary concern. The choice between the two depends on specific project requirements and scalability needs.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

shortid

Amazingly short non-sequential url-friendly unique id generator.

shortid is deprecated, because the architecture is unsafe. we instead recommend Nano ID, which has the advantage of also being significantly faster than shortid

ShortId creates amazingly short non-sequential url-friendly unique ids. Perfect for url shorteners, MongoDB and Redis ids, and any other id users might see.

By default 7-14 url-friendly characters: A-Z, a-z, 0-9, _-
Supports cluster (automatically), custom seeds, custom alphabet.
Can generate any number of ids without duplicates, even millions per day.
Perfect for games, especially if you are concerned about cheating so you don't want an easily guessable id.
Apps can be restarted any number of times without any chance of repeating an id.
Popular replacement for Mongo ID/Mongoose ID.
Works in Node, io.js, and web browsers.
Includes Mocha tests.

ShortId does not generate cryptographically secure ids, so don't rely on it to make IDs which are impossible to guess.

Usage

const shortid = require('shortid');

console.log(shortid.generate());
// PPBqWA9

Mongoose Unique Id

_id: {
  'type': String,
  'default': shortid.generate
},

Browser Compatibility

The best way to use shortid in the browser is via browserify or webpack.

These tools will automatically only include the files necessary for browser compatibility.

All tests will run in the browser as well:

## build the bundle, then open Mocha in a browser to see the tests run.
$ grunt build open

Example

~/projects/shortid â¯ node examples/examples.js
eWRhpRV
23TplPdS
46Juzcyx
dBvJIh-H
2WEKaVNO
7oet_d9Z
dogPzIz8
nYrnfYEv
a4vhAoFG
hwX6aOr7

Real World Examples

shortId was created for Node Knockout 2011 winner for Most Fun Doodle Or Die. Millions of doodles have been saved with shortId filenames. Every log message gets a shortId to make it easy for us to look up later.

Here are some other projects that use shortId:

bevy - A simple server to manage multiple Node services.
capre - Cross-Server Data Replication.
cordova-build - an alternative to phonegap build that runs on your servers/agents.
couchdb-tools - A library of handy functions for use when working with CouchDB documents.
CleverStack/clever-email - E-mail system for CleverStack.
CloudTypes - JavaScript end2end implementation of the Cloud Types model for Eventual Consistency programming.
dnode-tarantula - an asynchronous rpc and event system for node.js based on dnode-protocol and TCP sockets.
mongoose-url-shortener - A simple URL Shortening library for NodeJS using Promises/A+ results.
mozilla/smokejumper - The Smoke Jumper project is an effort to bring dead simple, secure, P2P file sharing to Firefox.
shortness - Node based URL shortener that uses SQLite.
file-db - Document database that uses directories and files to store its data, supporting nested key-value objects in named collections.
resume-generator - Resume Generator.
riffmint - Collaboration in musical space.
rap1ds/dippa - Dippa Editor â A web-based LaTeX editor

API

var shortid = require('shortid');

`shortid.generate()`

Returns string non-sequential unique id.

Example

users.insert({
  _id: shortid.generate(),
  name: '...',
  email: '...'
});

`shortid.characters(string)`

Default: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_'

Returns new alphabet as a string

Recommendation: If you don't like _ or -, you can to set new characters to use.

Optional

Change the characters used.

You must provide a string of all 64 unique characters. Order is not important.

The default characters provided were selected because they are url safe.

Example

// use $ and @ instead of - and _
shortid.characters('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$@');

// any 64 unicode characters work, but I wouldn't recommend this.
shortid.characters('â¶â·â¸â¹âºâ»â¼â½â¾â¿âââââââââââââââââââââââââââââââââ â¡â¢â£â¤â¥â¦â§â¨â©â â¡â¢â£â¤â¥â¦â§â¨â©âªâ«');

`shortid.isValid(id)`

Returns boolean

Check to see if an id is a valid shortid. Note: This only means the id could have been generated by shortid, it doesn't guarantee it.

Example

shortid.isValid('41XTDbE');
// true

shortid.isValid('i have spaces');
// false

`shortid.worker(integer)`

Default: process.env.NODE_UNIQUE_ID || 0

Recommendation: You typically won't want to change this.

Optional

If you are running multiple server processes then you should make sure every one has a unique worker id. Should be an integer between 0 and 16. If you do not do this there is very little chance of two servers generating the same id, but it is theoretically possible if both are generated in the exact same second and are generating the same number of ids that second and a half-dozen random numbers are all exactly the same.

Example

shortid.worker(1);

`shortid.seed(integer)`

Default: 1

Recommendation: You typically won't want to change this.

Optional

Choose a unique value that will seed the random number generator so users won't be able to figure out the pattern of the unique ids. Call it just once in your application before using shortId and always use the same value in your application.

Most developers won't need to use this, it's mainly for testing ShortId.

If you are worried about users somehow decrypting the id then use it as a secret value for increased encryption.

Example

shortid.seed(1000);

About the Author

Hi! Thanks for checking out this project! My name is Dylan Greene. When not overwhelmed with my two young kids I enjoy contributing to the open source community. I'm also a tech lead at Opower.

Here's some of my other Node projects:

Name	Description	npm Downloads
`npmâcheck`	Check for outdated, incorrect, and unused dependencies.
`gruntânotify`	Automatic desktop notifications for Grunt errors and warnings. Supports OS X, Windows, Linux.
`spaceâhogs`	Discover surprisingly large directories from the command line.
`rss`	RSS feed generator. Add RSS feeds to any project. Supports enclosures and GeoRSS.
`gruntâprompt`	Interactive prompt for your Grunt config using console checkboxes, text input with filtering, password fields.
`xml`	Fast and simple xml generator. Supports attributes, CDATA, etc. Includes tests and examples.
`changelog`	Command line tool (and Node module) that generates a changelog in color output, markdown, or json for modules in npmjs.org's registry as well as any public github.com repo.
`gruntâattention`	Display attention-grabbing messages in the terminal
`observatory`	Beautiful UI for showing tasks running on the command line.
`anthology`	Module information and stats for any @npmjs user
`gruntâcat`	Echo a file to the terminal. Works with text, figlets, ascii art, and full-color ansi.