This package provides an R runtime for the AWS Lambda serverless compute service. It is intended to be used to create containers that can run on AWS Lambda. lambdr provides the necessary functionality for handling the various endpoints required for accepting new input and sending responses.

This package is unofficial. Its creators are not affiliated with Amazon Web Services, nor is its content endorsed by Amazon Web Services. Lambda, API Gateway, EventBridge, CloudWatch, and SNS are services of Amazon Web Services.

The default behaviour is to convert the body of the received event from JSON into arguments for the handler function using the jsonlite package. For example, a raw event body of {"number": 9} will be converted to list(number = 9). The handler function will then receive the arguments directly after unlisting, eg. number = 9. This works for direct invocations, as well as situations where the user wishes to implement behaviour specific to a trigger.

Some invocation types have their own logic for converting the event body into an R object. This is useful for say, using an R function in a Lambda behind an API Gateway, so that the R function does not need to deal with the HTML elements of the invocation. The below invocation types have custom logic implemented. Refer to the vignettes or the package website for more information.

Alternatively, user-defined functions can be provided for parsing event content and serialising results. The user can also use the identity function as a deserialiser to pass the raw event content — as a string — to the handler function. Refer to ?lambda_config for more information.

invocation type implementation stage
API Gateway (REST)
API Gateway (HTML)


When the package is made available on CRAN it can be installed with:

The development version is available with:



In a runtime.R file, source all functions needed and then run:


This runtime.R file should be executed by the Docker image containing your Lambda code.

The lambdr::start_lambda() function relies on environment variables configured by AWS. It will fail if run locally. In particular, the handler as configured by the user through AWS will determine which function handles the Lambda events. For debugging and testing, values can be provided to the function in the absence of environment variables. See ?lambdr::lambda_config for details.


Consider the following runtime.R file:

parity <- function(number) {
  list(parity = if (as.integer(number) %% 2 == 0) "even" else "odd")


The parity function accepts a number argument and returns its parity as a named list, for example:

# $parity
# [1] "odd"

# $parity
# [1] "even"

This function can then be placed into a Docker image. An example is provided below, but the key components are:

  • Start from the parent image, which provides the basic components necessary to serve a Lambda
  • Install R and dependencies, both system dependencies and R packages, including the lambdr package
  • Copy across runtime.R and any other necessary files
  • Generate a simple bootstrap which runs runtime.R with R
  • Set the handler as the CMD. The lambdr package interprets the handler as the name of the function to use, in this case, “parity”. The CMD can also be set (or overriden) when setting up the Lambda in AWS.

The image is built and uploaded to AWS Elastic Container Registry (ECR). First, a repository is created:

This provides a URI, the resource identifier of the created repository. The image can now be pushed:

In either the AWS console or the command line, a Lambda can be created from this image. Call the Lambda “parity” to match the function name. Tests can be executed within the console. Alternatively the Lambda can be invoked from the CLI:

The output is now available in the generated file:

Hex logo by Phizz Leeder