What it is

Middy middleware engine AWS Lambda Node.js. Handler focus business logic. Attach reusable steps parsing, validation, auth, observability, error handling, AWS service integration. Ecosystem JavaScript TypeScript serverless. Official packages cover Lambda event sources and HTTP services. Project MIT licensed. Homepage middy.js.org. Docs cover getting started, official middlewares, event types, routers, custom middlewares, recipes, FAQ. GitHub metadata lists 3904 stars, 399 forks, 9 open issues, 9 year repo age, and last push 2026-09-12T15:33:46Z.

Middy solves repeated non-functional code in Lambda handlers. Production handlers need same input validation, structured logging, error mapping, secret retrieval, CORS handling, response shaping, partial-batch failure logic. Teams compose middleware around one handler, not copy steps into every handler. README says use Middy for every production Lambda.

Key capabilities

• 52 official packages cover API Gateway, SQS, S3, DynamoDB, SNS, EventBridge, Kinesis, Kafka, WebSockets, and more.
• Tiny core uses only @middy/util, plus optional peer dependency for durable functions, and no AWS SDK in core.
• Built-in TypeScript types, Node.js >= 22, ESM.
• Routers for HTTP, WebSocket, CloudFormation custom resources.
• First-class support AWS Lambda response streaming and durable functions.
• README example uses @middy/http-json-body-parser, @middy/http-error-handler, @middy/validator.
• Middleware supports input validation, structured logging, mapped HTTP errors, secrets and config with caching and cold-start prefetch, CORS, security headers, response shaping, authentication, partial-batch failure handling, graceful pre-timeout responses.

Who uses it and how

• Serverless teams use Middy when AWS Lambda handlers validate HTTP bodies, headers, query parameters, event-source payloads at trust boundaries.
• API teams attach authentication, CORS, security headers, mapped HTTP error responses around business logic handler.
• Event-driven teams use SQS, Kinesis, DynamoDB Streams, Kafka, S3 Batch workflows needing partial-batch failure handling.
• Operations teams add structured logging, consistent error reporting, secrets retrieval, cold-start prefetch to production Lambda functions.
• Framework builders use Middy routers for HTTP, WebSocket, CloudFormation custom resource handlers instead of separate dispatch code.

Getting started

Install @middy/core with npm, then add only needed middleware packages, such as @middy/http-json-body-parser, @middy/http-error-handler, @middy/validator. No Docker image or hosted option mentioned.

When to use it — and when not to

Middy fits production AWS Lambda handlers on Node.js needing reusable validation, logging, error mapping, auth, event-source handling. Less suitable projects not AWS Lambda, or teams wanting single handler without middleware composition. Tiny core means teams select and maintain extra packages for AWS service integration and optional durable functions.

npm install --save @middy/core
# add only the middlewares you need
npm install --save @middy/http-json-body-parser @middy/http-error-handler @middy/validator

import middy from '@middy/core'
import httpJsonBodyParser from '@middy/http-json-body-parser'
import httpErrorHandler from '@middy/http-error-handler'
import validator from '@middy/validator'
import { transpileSchema } from '@middy/validator/transpile'

const schema = {
  type: 'object',
  properties: {
    body: {
      type: 'object',
      properties: {
        amount: { type: 'number' },
        currency: { type: 'string' }
      },
      required: ['amount', 'currency']
    }
  }
}

const lambdaHandler = async (event) => {
  const { amount, currency } = event.body
  // ... business logic
  return { statusCode: 200, body: JSON.stringify({ ok: true, amount, currency }) }
}

export const handler = middy()
  .use(httpJsonBodyParser())
  .use(validator({ eventSchema: transpileSchema(schema) }))
  .use(httpErrorHandler())
  .handler(lambdaHandler)