fastify.dev Open in urlscan Pro
2606:50c0:8003::153  Public Scan

Form analysis
0 forms found in the DOM

Text Content

Skip to main content

HomeDocsEcosystemBenchmarksAdoptersContribute
latest (v4.20.x)
 * latest (v4.20.x)
 * v4.20.x
 * v4.19.x
 * v4.18.x
 * v4.17.x
 * v4.16.x
 * v4.15.x
 * v4.14.x
 * v4.13.x
 * v4.12.x
 * v4.11.x
 * v4.10.x
 * v4.9.x
 * v4.8.x
 * v4.7.x
 * v4.6.x
 * v4.5.x
 * v4.4.x
 * v4.3.x
 * v4.2.x
 * v4.1.x
 * v4.0.x
 * v3.29.x
 * v2.15.x
 * v1.14.x


⌘K
Search ...

⌘K



FAST AND LOW OVERHEAD WEB FRAMEWORK, FOR NODE.JS

   


WHY

An efficient server implies a lower cost of the infrastructure, a better
responsiveness under load and happy users. How can you efficiently handle the
resources of your server, knowing that you are serving the highest number of
requests possible, without sacrificing security validations and handy
development?

Enter Fastify. Fastify is a web framework highly focused on providing the best
developer experience with the least overhead and a powerful plugin architecture.
It is inspired by Hapi and Express and as far as we know, it is one of the
fastest web frameworks in town.


WHO IS USING FASTIFY?

Fastify is proudly powering a large ecosystem of organisations and products out
there.

Discover more organisations using Fastify. Do you want your organisation to be
featured here?

 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 
 * 


CORE FEATURES

These are the main features and principles on which Fastify has been built:

 * Highly performant: as far as we know, Fastify is one of the fastest web
   frameworks in town, depending on the code complexity we can serve up to 30
   thousand requests per second.
 * Extensible: Fastify is fully extensible via its hooks, plugins and
   decorators.
 * Schema based: even if it is not mandatory we recommend to use JSON Schema to
   validate your routes and serialize your outputs, internally Fastify compiles
   the schema in a highly performant function.
 * Logging: logs are extremely important but are costly; we chose the best
   logger to almost remove this cost, Pino!
 * Developer friendly: the framework is built to be very expressive and to help
   developers in their daily use, without sacrificing performance and security.
 * TypeScript ready: we work hard to maintain a TypeScript type declaration file
   so we can support the growing TypeScript community.


QUICK START

Get Fastify with NPM:

npm install fastify




Then create server.js and add the following content:

 * ESM
 * CJS

// Import the framework and instantiate it
import Fastify from 'fastify'
const fastify = Fastify({
  logger: true
})

// Declare a route
fastify.get('/', async function handler (request, reply) {
  return { hello: 'world' }
})

// Run the server!
try {
  await fastify.listen({ port: 3000 })
} catch (err) {
  fastify.log.error(err)
  process.exit(1)
}




// Require the framework and instantiate it
const fastify = require('fastify')({ logger: true })

// Declare a route
fastify.get('/', function handler (request, reply) {
  reply.send({ hello: 'world' })
})

// Run the server!
fastify.listen({ port: 3000 }, (err) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})




Finally, launch the server with:

node server




and test it with:

curl http://localhost:3000





USING CLI

Get the fastify-cli to create a new scaffolding project:

npm install --global fastify-cli
fastify generate myproject


REQUEST/RESPONSE VALIDATION AND HOOKS

Fastify can do much more than this. For example, you can easily provide input
and output validation using JSON Schema and perform specific operations before
the handler is executed:

 * ESM
 * CJS

import Fastify from 'fastify'
const fastify = Fastify({
  logger: true
})

fastify.route({
  method: 'GET',
  url: '/',
  schema: {
    // request needs to have a querystring with a `name` parameter
    querystring: {
      type: 'object',
      properties: {
          name: { type: 'string'}
      },
      required: ['name'],
    },
    // the response needs to be an object with an `hello` property of type 'string'
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  },
  // this function is executed for every request before the handler is executed
  preHandler: async (request, reply) => {
    // E.g. check authentication
  },
  handler: async (request, reply) => {
    return { hello: 'world' }
  }
})

try {
  await fastify.listen({ port: 3000 })
} catch (err) {
  fastify.log.error(err)
  process.exit(1)
}




const fastify = require('fastify')({ logger: true })

fastify.route({
  method: 'GET',
  url: '/',
  schema: {
    // request needs to have a querystring with a `name` parameter
    querystring: {
      type: 'object',
      properties: {
          name: { type: 'string'}
      },
      required: ['name'],
    },
    // the response needs to be an object with an `hello` property of type 'string'
    response: {
      200: {
        type: 'object',
        properties: {
          hello: { type: 'string' }
        }
      }
    }
  },
  // this function is executed for every request before the handler is executed
  preHandler: (request, reply, done) => {
    // E.g. check authentication
    done()
  },
  handler: (request, reply) => {
    reply.send({ hello: 'world' })
  }
})

fastify.listen({ port: 3000 }, (err) => {
  if (err) {
    fastify.log.error(err)
    process.exit(1)
  }
})





TYPESCRIPT SUPPORT

Fastify is shipped with a typings file, but you may need to install @types/node,
depending on the Node.js version you are using.
The following example creates a http server.
We pass the relevant typings for our http version used. By passing types we get
correctly typed access to the underlying http objects in routes.
If using http2 we would pass <http2.Http2Server, http2.Http2ServerRequest,
http2.Http2ServerResponse>.
For https pass http2.Http2SecureServer or http.SecureServer instead of Server.
This ensures within the server handler we also get http.ServerResponse with
correct typings on reply.res.

 * TypeScript

import Fastify, { FastifyInstance, RouteShorthandOptions } from 'fastify'
import { Server, IncomingMessage, ServerResponse } from 'http'

const server: FastifyInstance = Fastify({})

const opts: RouteShorthandOptions = {
  schema: {
    response: {
      200: {
        type: 'object',
        properties: {
          pong: {
            type: 'string'
          }
        }
      }
    }
  }
}

server.get('/ping', opts, async (request, reply) => {
  return { pong: 'it worked!' }
})

const start = async () => {
  try {
    await server.listen({ port: 3000 })

    const address = server.server.address()
    const port = typeof address === 'string' ? address : address?.port

  } catch (err) {
    server.log.error(err)
    process.exit(1)
  }
}

start()




Visit the Documentation to learn more about all the features that Fastify has to
offer.


A FAST WEB FRAMEWORK

Leveraging our experience with Node.js performance, Fastify has been built from
the ground up to be as fast as possible. Have a look at our benchmarks section
to compare Fastify performance to other common web frameworks.

Check out our benchmarks


ECOSYSTEM

Fastify has an ever-growing ecosystem of plugins. Probably there is already a
plugin for your favourite database or template language. Have a look at the
Ecosystem page to navigate through the currently available plugins. Can't you
find the plugin you are looking for? No problem, it's very easy to write one!

Explore 270 plugins


MEET THE TEAM

In alphabetical order


LEAD MAINTAINERS

Matteo Collina



Tomas Della Vedova




COLLABORATORS

Tommaso Allevi



Ayoub El Khattabi



David Clements



Dustin Deus



Carlos Fuentes



Rafael Gonzaga



Vincent Le Goff



Luciano Mammino



Salman Mitha



Igor Savin



Evan Shortiss



Maksim Sinik



Frazer Smith



Manuel Spigolon



James Sumners




PAST COLLABORATORS

Ethan Arrowood



Çağatay Çalı



Cemre Mengu



Trivikram Kamat



Nathan Woltman




ACKNOWLEDGMENTS

This project is kindly sponsored by:

 * NearForm
 * Platformatic

Past Sponsors:

 * LetzDoIt
 * Microsoft

Also thanks to:

 * The amazing Fastify community


HOSTED BY

We are an At Large project at the OpenJS Foundation




Docs
 * Getting Started

Community
 * Stack Overflow
 * Discord
 * Twitter

More
 * GitHub

Fastify, Copyright © 2016-2023 OpenJS Foundation and The Fastify team, Licensed
under MIT