• .code(statusCode) - Sets the status code.
    • .status(statusCode) - An alias for .code(statusCode).
    • .statusCode - Read and set the HTTP status code.
    • .header(name, value) - Sets a response header.
    • .headers(object) - Sets all the keys of the object as a response headers.
    • .getHeader(name) - Retrieve value of already set header.
    • .getHeaders() - Gets a shallow copy of all current response headers.
    • .removeHeader(key) - Remove the value of a previously set header.
    • .hasHeader(name) - Determine if a header has been set.
    • .type(value) - Sets the header Content-Type.
    • .redirect([code,] dest) - Redirect to the specified url, the status code is optional (default to 302).
    • .callNotFound() - Invokes the custom not found handler.
    • .serializer(function) - Sets a custom serializer for the payload.
    • .send(payload) - Sends the payload to the user, could be a plain text, a buffer, JSON, stream, or an Error object.
    • .sent - A boolean value that you can use if you need to know if send has already been called.
    • .raw - The http.ServerResponse from Node core.
    • .res (deprecated, use .raw instead) - The from Node core.
    • .log - The logger instance of the incoming request.
    • .request - The incoming request.

    Additionally, Reply provides access to the context of the request:

    1. fastify.get('/', {config: {foo: 'bar'}}, function (request, reply) {
    2.   reply.send('handler config.foo = ' + reply.context.config.foo)
    3. })

    .code(statusCode)

    If not set via reply.code, the resulting statusCode will be 200.

    .statusCode

    This property reads and sets the HTTP status code. It is an alias for reply.code() when used as a setter.

    1. if (reply.statusCode >= 299) {
    2.   reply.statusCode = 500
    3. }

    .header(key, value)

    Sets a response header. If the value is omitted or undefined it is coerced to ''.

    For more information, see .

    .headers(object)

    Sets all the keys of the object as response headers. will be called under the hood.

    1. reply.headers({
    2.   'x-foo': 'foo',
    3.   'x-bar': 'bar'
    4. })

    .getHeader(key)

    Retrieves the value of a previously set header.

    1. reply.header('x-foo', 'foo') // setHeader: key, value
    2. reply.getHeader('x-foo') // 'foo'

    Gets a shallow copy of all current response headers, including those set via the raw http.ServerResponse. Note that headers set via Fastify take precedence over those set via http.ServerResponse.

    1. reply.header('x-foo', 'foo')
    2. reply.header('x-bar', 'bar')
    3. reply.raw.setHeader('x-foo', 'foo2')
    4. reply.getHeaders() // { 'x-foo': 'foo', 'x-bar': 'bar' }

    .removeHeader(key)

    Remove the value of a previously set header.

    1. reply.header('x-foo', 'foo')
    2. reply.removeHeader('x-foo')
    3. reply.getHeader('x-foo') // undefined

    .hasHeader(key)

    Returns a boolean indicating if the specified header has been set.

    .redirect([code ,] dest)

    Redirects a request to the specified url, the status code is optional, default to 302 (if status code is not already set by calling code).

    Example (no reply.code() call) sets status code to 302 and redirects to /home

    1. reply.redirect('/home')

    Example (no reply.code() call) sets status code to 303 and redirects to /home

    1. reply.redirect(303, '/home')

    Example (reply.code() call) sets status code to 303 and redirects to /home

    Example (reply.code() call) sets status code to 302 and redirects to /home

    1. reply.code(303).redirect(302, '/home')

    .callNotFound()

    Invokes the custom not found handler. Note that it will only call preHandler hook specified in .

    1. reply.callNotFound()

    .getResponseTime()

    Note that unless this function is called in the it will always return 0.

    1. const milliseconds = reply.getResponseTime()

    Sets the content type for the response. This is a shortcut for reply.header('Content-Type', 'the/type').

    1. reply.type('text/html')

    .serializer(func)

    .send() will by default JSON-serialize any value that is not one of: Buffer, stream, string, undefined, Error. If you need to replace the default serializer with a custom serializer for a particular request, you can do so with the .serializer() utility. Be aware that if you are using a custom serializer, you must set a custom 'Content-Type' header.

    1. reply
    2.   .header('Content-Type', 'application/x-protobuf')
    3.   .serializer(protoBuf.serialize)

    Note that you don’t need to use this utility inside a handler because Buffers, streams, and strings (unless a serializer is set) are considered to already be serialized.

    1. reply
    2.   .header('Content-Type', 'application/x-protobuf')
    3.   .send(protoBuf.serialize(data))

    See for more information on sending different types of values.

    .raw

    This is the from Node core. While you’re using the fastify Reply object, the use of Reply.raw functions is at your own risk as you’re skipping all the fastify logic of handling the http response. eg:

    1. app.get('/cookie-2', (req, reply) => {
    2.   reply.setCookie('session', 'value', { secure: false }) // this will not be used
    4.   // in this case we are using only the nodejs http server response object
    5.   reply.raw.writeHead(200, { 'Content-Type': 'text/plain' })
    6.   reply.raw.write('ok')
    7.   reply.raw.end()
    8. })

    Another example of the misuse of Reply.raw is explained in Reply.

    .sent

    As the name suggests, .sent is a property to indicate if a response has been sent via reply.send().

    In case a route handler is defined as an async function or it returns a promise, it is possible to set reply.sent = true to indicate that the automatic invocation of reply.send() once the handler promise resolve should be skipped. By setting reply.sent = true, an application claims full responsibility of the low-level request and response. Moreover, hooks will not be invoked.

    As an example:

    1. app.get('/', (req, reply) => {
    2.   reply.sent = true
    3.   reply.raw.end('hello world')
    5.   return Promise.resolve('this will be skipped')
    6. })

    If the handler rejects, the error will be logged.

    .hijack()

    Sometimes you might need to halt the execution of the normal request lifecycle and handle sending the response manually.

    To achieve this, fastify provides the method reply.hijack() that can be called during the request lifecycle (At any point before reply.send() is called), and allows you to prevent fastify from sending the response, and from running the remaining hooks (and user handler if the reply was hijacked before).

    NB (*): If reply.raw is used to send a response back to the user, onResponse hooks will still be executed

    .send(data)

    As the name suggests, .send() is the function that sends the payload to the end user.

    Objects

    As noted above, if you are sending JSON objects, send will serialize the object with if you set an output schema, otherwise JSON.stringify() will be used.

    Strings

    1. fastify.get('/json', options, function (request, reply) {
    2.   reply.send('plain string')
    3. })

    Streams

    send can also handle streams out of the box, internally uses pump to avoid leaks of file descriptors. If you are sending a stream and you have not set a 'Content-Type' header, send will set it at 'application/octet-stream'.

    1. fastify.get('/streams', function (request, reply) {
    2.   const fs = require('fs')
    3.   const stream = fs.createReadStream('some-file', 'utf8')
    4.   reply.send(stream)
    5. })

    Buffers

    If you are sending a buffer and you have not set a 'Content-Type' header, send will set it to 'application/octet-stream'.

    1. const fs = require('fs')
    2. fastify.get('/streams', function (request, reply) {
    3.   fs.readFile('some-file', (err, fileBuffer) => {
    4.     reply.send(err || fileBuffer)
    5.   })

    Errors

    If you pass to send an object that is an instance of Error, Fastify will automatically create an error structured as the following:

    1. {
    3.   code: String         // the Fastify error code
    4.   message: String      // the user error message
    5.   statusCode: Number   // the http status code
    6. }

    You can add some custom property to the Error object, such as headers, that will be used to enhance the http response.
    Note: If you are passing an error to send and the statusCode is less than 400, Fastify will automatically set it at 500.

    Tip: you can simplify errors by using the module or fastify-sensible plugin to generate errors:

    1. fastify.get('/', function (request, reply) {
    2.   reply.send(httpErrors.Gone())
    3. })

    To customize the JSON error output you can do it by:

    • setting a response JSON schema for the status code you need
    • add the additional properties to the Error instance

    Notice that if the returned status code is not in the response schema list, the default behaviour will be applied.

    1. fastify.get('/', {
    2.   schema: {
    3.     response: {
    4.       501: {
    5.         type: 'object',
    6.         properties: {
    7.           statusCode: { type: 'number' },
    8.           code: { type: 'string' },
    9.           error: { type: 'string' },
    10.           message: { type: 'string' },
    11.           time: { type: 'string' }
    12.         }
    13.       }
    14.     }
    15.   }
    16. }, function (request, reply) {
    17.   const error = new Error('This endpoint has not been implemented')
    18.   error.time = 'it will be implemented in two weeks'
    19.   reply.code(501).send(error)
    20. })

    If you want to completely customize the error handling, checkout API.
    Note: you are responsible for logging when customizing the error handler

    API:

    1. fastify.setErrorHandler(function (error, request, reply) {
    2.   request.log.warn(error)
    3.   var statusCode = error.statusCode >= 400 ? error.statusCode : 500
    4.   reply
    5.     .code(statusCode)
    6.     .type('text/plain')
    7.     .send(statusCode >= 500 ? 'Internal server error' : error.message)
    8. })

    The not found errors generated by the router will use the setNotFoundHandler

    API:

    1. fastify.setNotFoundHandler(function (request, reply) {
    2.   reply
    3.     .code(404)
    4.     .type('text/plain')
    5.     .send('a custom not found')
    6. })

    Type of the final payload

    The type of the sent payload (after serialization and going through any onSend hooks) must be one of the following types, otherwise an error will be thrown:

    • string
    • Buffer
    • stream
    • undefined
    • null

    Async-Await and Promises

    Fastify natively handles promises and supports async-await.
    Note that in the following examples we are not using reply.send.

    Rejected promises default to a 500 HTTP status code. Reject the promise, or throw in an async function, with an object that has statusCode (or status) and message properties to modify the reply.

    1. fastify.get('/teapot', async function (request, reply) {
    2.   const err = new Error()
    3.   err.statusCode = 418
    4.   err.message = 'short and stout'
    5.   throw err
    6. })
    8. fastify.get('/botnet', async function (request, reply) {
    9.   throw { statusCode: 418, message: 'short and stout' }
    10.   // will return to the client the same json
    11. })

    If you want to know more please review Routes#async-await.

    As the name suggests, a Reply object can be awaited upon, i.e. await reply will wait until the reply is sent. The await syntax calls the reply.then().

    • will be called when a response has been fully sent,
    • rejected will be called if the underlying stream had an error, e.g. the socket has been destroyed.

    For more details, see: