Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including honeybadger with all npm packages installed. Try it out:

var honeybadger = require("honeybadger")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

honeybadger v1.4.0

A node.js notifier for

Honeybadger for NodeJS

Node.js CI npm version

This is the Node.js module for integrating apps with the :zap: Honeybadger Exception Notifier for JavaScript and Node.

When an uncaught exception occurs, Honeybadger will POST the relevant data to the Honeybadger service, and we'll alert you to the problem.

Upgrading from 0.x

We made some breaking changes in 1.0, so if you currently use 0.x, you will need to update your usage. In most cases you should be able to replace the old hb.send() function with hb.notify(). Instead of configuring the client as an instance, you can require the global singleton instead:

var hb = require('honeybadger');

  apiKey: '[ YOUR API KEY HERE ]'

# Change:
# hb.send(err, opts);
# To:
hb.notify(err, opts);

We also stopped emitting the remoteError event and now emit error for all failures to notify Honeybadger.

Getting Started

In this section, we'll cover the basics. More advanced installations are covered later.

1. Install the npm package

npm install honeybadger --save

2. Require the honeybadger module

var Honeybadger = require('honeybadger');

3. Set your API key

  apiKey: '[ YOUR API KEY HERE ]'

You can also place your API key in the HONEYBADGER_API_KEY environment variable if you prefer the 12-factor app configuration style.

4. Set up your code

By default Honeybadger will be notified automatically of all unhandled errors which crash your node processes. Many applications catch errors, however, so you may want to set up some additional framework integrations:

Express or Connect Framework

Errors which happen in Express or Connect apps can be automatically reported to Honeybadger by installing our middleware.

In order to function properly our middleware must be added before and after your normal app middleware, but before any other error handling middleware:

app.use(Honeybadger.requestHandler); // Use *before* all other app middleware.
// app.use(myMiddleware);
app.use(Honeybadger.errorHandler);  // Use *after* all other app middleware.
// app.use(myErrorMiddleware);

Note: If you use the connect-domain middleware, you do not need to use Honeybadger.requestHandler because they are essentially the same.

AWS Lambda

Honeybadger can automatically report errors which happen on AWS Lambda:

// Your handler function.
function handler(event, context) {
  console.log('Event:', event);
  console.log('Context:', context);
  throw(new Error('Something went wrong.'));
  console.log("Shouldn't make it here.");

// Build and export the function.
exports.handler = Honeybadger.lambdaHandler(handler);

Check out our example Lambda project for a complete example.

Note: Async Handlers are not supported by Honeybadger.lambdaHandler. See this issue for status.

Manually reporting exceptions

To catch exceptions and report them manually:

try {
  throw(new Error('Badgers!'));
} catch(err) {

Note that re-throwing the exceptions will cause them to be reported by any additional error handlers that may catch them.

Sample Application

If you'd like to see the library in action before you integrate it with your apps, check out our sample Node.js/Express application.

You can deploy the sample app to your Heroku account by clicking this button:


Don't forget to destroy the Heroku app after you're done so that you aren't charged for usage.

The code for the sample app is available on Github, in case you'd like to read through it, or run it locally.

Advanced Configuration

There are a few ways to configure the Honeybadger module. You can use #configure() at runtime. You can use environment variables. Or you can use a combination of the two.

Note that the only configuration option you have to provide is apiKey.

  // The API key of your Honeybadger project. (env: HONEYBADGER_API_KEY)
  apiKey: 'your api key goes here',

  // The API endpoint to use. Must be a valid URL with no trailing slash. (env: HONEYBADGER_ENDPOINT)
  endpoint: '',

  // Defaults to the server's hostname. (env: HONEYBADGER_HOSTNAME)
  hostname: 'badger01',

  // Defaults to the current node environment. (env: HONEYBADGER_ENVIRONMENT)
  environment: 'staging',

  // Defaults to the node process's current working directory. (env: HONEYBADGER_PROJECT_ROOT)
  projectRoot: '/var/www',

  // An object with `info` and `error` methods.
  logger: console,

  // Environments which will not report data.
  developmentEnvironments: ['dev', 'development', 'test'],

  // Key values to filter from request data. Matches are partial, so "password"
  // and "password_confirmation" will both be filtered.
  filters: ['creditcard', 'password']

Configuring the default logger

Honeybadger provides a default logger which reports info and error level logs to stdout/stderr (basically a proxy to console). The default level is "error" ("info" logs will be silenced). To configure the log level you can set Honeybadger.logger.level = 'info' or set the HONEYBADGER_LOG_LEVEL=info environment variable before executing your program.

Public Interface

Honeybadger.notify(): Report an error to Honeybadger

This is the only function you need. Give it an Error object, and some optional metadata and it reports the error to Honeybadger.


// You can report an error without any metadata

// Metadata is provided via a second or third argument.
Honeybadger.notify(error, {
  context: {
    user: 'jane',
    email: ''
  session: { user_token: "asdf" },
  headers: req.headers,
  params: {},
  cgiData: {
    'server-software': 'Node ' + process.version

You can send the following metadata:

name(String) The error's type/class name.
message(String) The error message.
context(Object) The context object is for app-specific data that will make error followup easier, like user ids
session(Object) The session data as defined by whatever session manager you use
headers(Object) HTTP headers for the current request
params(Object) GET or POST params for the current request
cgiData(Object) Information about the application environment.
url(String) The URL associated with the request, if any.
component(String) The software component (displayed in Honeybadger as: component#action).
action(String) The action within the component.
fingerprint(String) An optional grouping fingerprint.

JavaScript often uses generic class names -- such as Error -- which are uninformative and also cause unrelated errors to be grouped together. To get around this issue it's a good practice to send a custom error class when notifying Honeybadger:

Honeybadger.notify(error, 'DescriptiveClass');
Honeybadger.notify(error, 'DescriptiveClass', { ... });

You can notify Honeybadger of anything, even if you don't have an error object. We'll automatically generate a stacktrace for you:

Honeybadger.notify('Badgers!', { ... });
Honeybadger.notify('Badgers!', 'CustomClass');
Honeybadger.notify('Badgers!', 'CustomClass', { ... });
  message: 'Badgers!',
  name: 'CustomClass',

Finally, you can provide an optional callback as the last argument to any call to Honeybadger.notify(). The callback will always be called regardless of the result of the notification:

Honeybadger.notify(err, function notifyCallback(err, notice) {
  if (err) {
    return console.error(err);
  // If there was no error, log the notice:
  console.log(notice); // { id: 'uuid' }

Honeybadger.setContext(): Set metadata to be sent if an exception occurs

Javascript exceptions are pretty bare-bones. You probably have some additional data that could make them a lot easier to understand - perhaps the name of the current controller/view, or the id of the current user. This function lets you set context data that will be sent if an error should occur.

You can call setContext as many times as you like. New context data will be merged with the existing data.


// On load
  user_id: 123

// Later
  controller_name: 'posts'

// The context now contains { user_id: 123, controller_name: 'posts' }

Honeybadger.resetContext(): Clear context metadata

If you've used Honeybadger.setContext to store context data, you can clear it with Honeybadger.resetContext.


// Set the context to {}

// Clear the context, then set it to `{ user_id: 123 }`
  user_id: 123

Honeybadger.configure(): Set configuration values

The configure method takes an object containing config values. Its return value is unspecified.


Honeybadger.configure({apiKey: "adlkjfljk"});

Honeybadger.factory(): create a new client instance

The factory method returns a new instance of Honeybadger which can be configured differently than the global/singleton instance.


var other_hb = Honeybadger.factory({apiKey: "zxcvbnm"});
other_hb.notify("This will go to an alternate project.");

Honeybadger.errorHandler(): error handling middleware for Express and Connect

The errorHandler method is an error reporting middleware for Express and Connect apps. Use the middleware in your app to report all errors which happen during the request. Request data such as params, session, and cookies will be automatically reported.



Honeybadger.lambdaHandler(): handler for AWS Lambda

The lambdaHandler method is a wrapper for AWS Lambda. You pass it your Lambda function and it returns a new function which reports errors to Honeybadger.


// Your handler function.
function handler(event, context) {
  console.log('Event:', event);
  console.log('Context:', context);
  throw(new Error('Something went wrong.'));
  console.log("Shouldn't make it here.");

// Build and export the function.
exports.handler = Honeybadger.lambdaHandler(handler);

Note: Async Handlers are not supported by Honeybadger.lambdaHandler. See this issue for status.

Honeybadger.onUncaughtException(): configure the uncaught exception handler

Honeybadger's default uncaught exception handler logs the error and exits the process after notifying Honeybadger of the uncaught exception. You can change the default handler by calling Honeybadger.onUncaughtException() with a new handler function. Honeybadger will still be notified before your handler is invoked. Note that it's important to exit the process cleanly if you replace the handler; see Warning: using 'uncaughtException' correctly for additional information.


Honeybadger.onUncaughtException(function(err) {


Instances of honeybadger-node can emit the following events:

sentThis is emitted when returns a 201 successfully. The response body, containing metadata about the submitted error, is emitted as data.
errorEmitted in the case of any error while trying to connect to Will not be emitted unless a listener is present.




If you're adding a new feature, please submit an issue as a preliminary step; that way you can be (moderately) sure that your pull request will be accepted.

To contribute your code:

  1. Fork it.
  2. Create a topic branch git checkout -b my_branch
  3. Commit your changes git commit -am "Boom"
  4. Push to your branch git push origin my_branch
  5. Send a pull request


Clone the repo, and then npm install. Now you should be able to run npm test.


Releasing is done with two commands: npm version and npm publish. Both commands should be used with care. The npm publish command publishes to NPM.

To perform a full release:

  1. With a clean working tree, use npm version [new version] to bump the version, commit the changes, tag the release, and push to GitHub. See npm help version for documentation.

  2. To publish the release, use npm publish. See npm help publish for documentation.


The Honeybadger gem is MIT licensed. See the LICENSE file in this repository for details.

RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free