Open-source project
restify/node-restify avatar
restify/node-restify

restify: the Node framework that would not become Express

The future of Node.js REST development

10,691 stars977 forksJavaScriptMIT

At a glance

What is it?
A connect-style REST framework with API versioning in its examples, a DTrace example and a v12.1.0 release on 2026-10-22.
Who is it for?
restify is a good fit when you are publishing an API that other teams build against, because versioning and response headers are part of the design rather than bolted on. It is a poor fit for a general-purpose web application, where Express's middleware ecosystem is simply larger.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 30 days ago.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • restify/node-restify10,691 ★ · +4
Star history
Repository2026-10-072026-11-21
restify/node-restify10.7k10.7k

4 Stars in the last 45 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Building a server the way Connect taught people to

The README's server example is short enough to memorise. You create a server with a name and version, register three parser plugins, define a route with a path parameter, and listen. There is no application object separate from the server, no global middleware stack to configure.

javascript
var restify = require('restify');

const server = restify.createServer({
  name: 'myapp',
  version: '1.0.0'
});

server.use(restify.plugins.acceptParser(server.acceptable));
server.use(restify.plugins.queryParser());
server.use(restify.plugins.bodyParser());

server.get('/echo/:name', function (req, res, next) {
  res.send(req.params);
  return next();
});

Three points are worth noticing. `acceptParser` is what makes that negotiation possible, since it parses the incoming Accept header and rejects an unsupported media type rather than silently sending JSON to a client that cannot read it. And the handler signature ends in `next`, which is the Connect convention restify adopted wholesale, described in the README as using connect style middleware.

What API versioning actually does for a consumer

The README's server example passes a version to `createServer`, and its client example asks for version '~1.0'.

This is the feature that most distinguishes restify from a generic Connect-style framework. The trade-off is that it is only useful if your clients are as disciplined as your server. A public API consumed by browser JavaScript that ignores versioning headers gains nothing from the machinery, and pays the small complexity cost of maintaining it. An API consumed by three internal mobile teams that each pinned a version is exactly where the machinery pays for itself, because a breaking change becomes a negotiated response rather than an outage.

The client half of the package is a separate module, `restify-clients`, and the README pairs the two. The client negotiates against a version range rather than a fixed string:

javascript
var clients = require('restify-clients');

var client = clients.createJsonClient({
  url: 'http://localhost:8080',
  version: '~1.0'
});

The tilde prefix is semver range syntax, asking for any 1.0.x release rather than exactly 1.0.0.

Two and a half years between major releases

The release list shows v12.0.0 on 2026-08-25, then v12.1.0-rc and v12.1.0 on 2026-10-22, and package.json declares version 12.1.0.

The tree includes an `examples/http2/` directory. The `benchmark/` directory and a `Makefile` target for running it are also present, so performance comparisons the project has run are reproducible if you want them.

Node support, observability and the parts of the tree that explain the design

The README states that restify currently works on Node.js v22.x, v24.x and v26.x. That is a narrow, current support window rather than an open-ended compatibility claim, and it is worth treating as a hard constraint in your deployment target. The supported list reaching Node.js 26 suggests the project tracks current Node releases.

The repository tree has a few directories that explain where the project's personality comes from. `benchmark/` holds performance harnesses, and `examples/` contains six entries including dtrace, http2, jsonp, sockio and a todoapp. The `DTrace` keyword appears in the package.json keyword list, and the Makefile carries a 2012 Joyent copyright header.

Documentation lives in `docs/` with a build step wired through `tools/docsBuild.js` in the Makefile, and `test/` is split so that plugin tests run under Mocha while the main suite runs under nodeunit. That dual-runner setup is a fossil: it reflects a codebase assembled over years rather than rewritten, and it is the kind of detail that tells you the test suite predates the current tooling preferences of the maintainers.

Why this exists instead of just using Express

The comparison everybody reaches for is Express, and it is the right one. Both use Connect-style middleware, both have been in Node since before the async era, and both are MIT licensed with large install counts. The difference is intent. Express minimised everything, on the theory that a web framework should stay out of the way. restify narrowed in on a specific shape of problem, HTTP APIs consumed by programs rather than by browsers, and accepted some opinionation in exchange.

What you get for that opinionation is the versioning machinery described above, plus plugins such as acceptParser, queryParser and bodyParser. What you give up is the size of the ecosystem. Express's middleware ecosystem is the reason most teams end up there, and the probability that a package you already use ships an Express integration but not a restify one is high.

There is also a simpler reason to choose Express that has nothing to do with features: most Node developers already know its error handling and its middleware ordering. restify's `next()` convention is correct and explicit, but it is a different thing to hold in your head while debugging at midnight. The project is 10,687 stars with 975 forks and 132 open issues, so it is not abandoned, and the last push was 2026-10-23. It is a maintained alternative, not a growth story.

Editorial conclusion

restify is a good fit when you are publishing an API that other teams build against, because versioning and response headers are part of the design rather than bolted on. It is a poor fit for a general-purpose web application, where Express's middleware ecosystem is simply larger. The thing to verify before adopting it is your Node version, since the README says restify currently works on Node.js v22.x, v24.x and v26.x.

Frequently asked questions

What is the Node.js REST framework?

Several Node frameworks describe themselves that way, and the most widely used is Express. restify is another, built around Connect-style middleware and aimed specifically at HTTP APIs consumed by programs rather than browsers. Its distinguishing feature is first-class API versioning, with a version passed to createServer on the server and a version range such as '~1.0' on the client.

How do you install restify?

Through npm, with npm install restify. The README states that restify currently works on Node.js v22.x, v24.x and v26.x, so check your runtime version against that window before installing. The client half of the package is a separate module called restify-clients.

What are the main differences between restify and Express?

Both use Connect-style middleware and both are MIT licensed. restify is opinionated toward versioned HTTP APIs and ships plugins such as acceptParser, queryParser and bodyParser. Express is deliberately minimal and has a far larger middleware ecosystem, so the practical difference for many teams is package availability rather than capability.

Which Node.js versions does restify support?

The README says v22.x, v24.x and v26.x. The latest release listed is v12.1.0, from 2026-10-22.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. restify/node-restify on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/restify-node-restify.svg)](https://hysenlabs.com/projects/restify-node-restify)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/restify-node-restify.svg)](https://hysenlabs.com/projects/restify-node-restify)

Was this useful?