AWS Lambda API
Browse all Amazonaws APIs✓ Official Vendor SpecCloud InfrastructureServerlessapiKey50 EndpointsREST
For Agents
Create, update, invoke, and configure AWS Lambda functions, manage versions and aliases, attach layers, and wire event source mappings to streams and queues so an agent can deploy and run serverless code on demand.
Use for: I need to deploy a new Lambda function from a zip file, Update the code of an existing Lambda function, Invoke a Lambda function and get its response, Set up an SQS queue to trigger a Lambda function
Not supported: Does not run long-lived servers, host containers without per-request scaling, or manage VM fleets. Use for serverless function execution and configuration only.
AWS Lambda runs code in response to events without requiring you to provision or manage servers. The Lambda API gives full control over functions, including creating and updating function code from zip archives or container images, configuring memory and timeout, attaching layers, managing aliases and versions, and wiring event source mappings to streams from Kinesis, DynamoDB, SQS, MSK, and self-managed Kafka. It also supports synchronous, asynchronous, and streaming invocation, plus URL-based public endpoints via Lambda function URLs.
Install Jentic One Beta
Connect the AWS Lambda API to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the AWS Lambda API, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL https://raw.githubusercontent.com/jentic/jentic-one/main/tools/install.sh | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with AWS Lambda API.
Create and update Lambda functions from a zip deployment package or a container image stored in Amazon ECR
Invoke a function synchronously, asynchronously, or with response streaming for long-lived outputs
Manage published versions and weighted aliases for blue/green and canary traffic shifting
Attach Lambda layers to share code, dependencies, or runtimes across multiple functions
Wire event source mappings from Kinesis, DynamoDB streams, Amazon SQS, Amazon MSK, and self-managed Kafka to drive functions automatically
Configure function URL endpoints with IAM or none auth for HTTP-triggered serverless apps
Tune concurrency, memory, ephemeral storage, and reserved or provisioned concurrency per function
Use Cases
Patterns agents use AWS Lambda API for, with concrete tasks.
★ Event-Driven SQS Processing
Run a Lambda function for every message that lands on an SQS queue without writing a poller. Create the function with createFunction, then create an event source mapping that points at the queue ARN with a configured batch size and reporting on partial batch failures. Lambda scales the function up to the queue's concurrency limit, retries failed messages, and routes poison messages to a dead-letter queue. Setup takes around an hour including IAM permissions.
Create a Lambda function order-processor (Python 3.12, 512 MB, 30s timeout) from a zip in S3, then create an event source mapping pointing at queue arn:aws:sqs:eu-west-1:...:orders with BatchSize=10 and FunctionResponseTypes=ReportBatchItemFailures.
Canary Deploys via Aliases
Roll out a new function version to a small percentage of production traffic and ramp up if metrics stay healthy. Use publishVersion to snapshot the current function, then updateAlias on the production alias with a routing config that sends 10 percent of invokes to the new version. Cut over to 100 percent or roll back by editing the alias. This is the standard pattern for AWS SAM and AWS CodeDeploy traffic shifting.
Call publishVersion on function checkout-api, then updateAlias prod with FunctionVersion set to the previous live version and RoutingConfig.AdditionalVersionWeights set to {newVersion: 0.1}.
Container Image Function for Heavy Dependencies
Package a Lambda function as a container image when the deployment exceeds the 250 MB unzipped zip limit or needs custom runtimes, common for ML inference, headless browsers, or large native libraries. Build and push the image to Amazon ECR, then create a function with PackageType=Image pointing at the ECR URI. Lambda runs the image with up to 10 GB memory and 15-minute timeouts.
Create function pdf-renderer with PackageType=Image, ImageUri=123456789012.dkr.ecr.eu-west-1.amazonaws.com/pdf-renderer:v3, MemorySize=3008, Timeout=120, and Architectures=['arm64'].
Agent-Triggered Serverless Tasks
Let an AI agent execute one-off serverless work, such as reformatting a document, fetching a fresh report, or running a price calculation, by invoking pre-deployed Lambda functions through Jentic. The agent picks the right function from Jentic's intent search, passes structured input, and receives the function response. Long-lived AWS credentials stay in the Jentic vault; the agent only ever calls Jentic with a scoped key.
Search Jentic for 'invoke a lambda function and get the response', load the invoke schema, and execute it with FunctionName=customer-summary, Payload=JSON of {customerId: 'cus_42'}.
Key Endpoints
50 endpoints — aws lambda runs code in response to events without requiring you to provision or manage servers.
METHOD
PATH
DESCRIPTION
POST
/2015-03-31/functions
Create a Lambda function
GET
/2015-03-31/functions
List functions in this region
GET
/2015-03-31/functions/{FunctionName}
Get a function and its configuration
PUT
/2015-03-31/functions/{FunctionName}/code
Update function code
PUT
/2015-03-31/functions/{FunctionName}/configuration
Update function memory, timeout, env, and other config
POST
/2015-03-31/functions/{FunctionName}/invocations
Invoke a function synchronously or asynchronously
POST
/2015-03-31/functions/{FunctionName}/invoke-with-response-stream
Invoke a function and stream the response
POST
/2015-03-31/functions/{FunctionName}/aliases
Create an alias for traffic routing
POST
/2015-03-31/functions
Create a Lambda function
GET
/2015-03-31/functions
List functions in this region
GET
/2015-03-31/functions/{FunctionName}
Get a function and its configuration
PUT
/2015-03-31/functions/{FunctionName}/code
Update function code
PUT
/2015-03-31/functions/{FunctionName}/configuration
Update function memory, timeout, env, and other config
POST
/2015-03-31/functions/{FunctionName}/invocations
Invoke a function synchronously or asynchronously
POST
/2015-03-31/functions/{FunctionName}/invoke-with-response-stream
Invoke a function and stream the response
POST
/2015-03-31/functions/{FunctionName}/aliases
Create an alias for traffic routing
Why Jentic?
Three things that make agents converge on Jentic-routed access.
Credential isolation
AWS access key ID and secret access key for AWS Lambda API are stored encrypted in the Jentic vault. Agents receive scoped, short-lived signing credentials and the raw IAM secrets never enter the agent context. Jentic computes the AWS Signature Version 4 signature server-side for every request.
Intent-based discovery
Agents search Jentic by intent (for example, 'invoke a Lambda function') and Jentic returns matching AWS Lambda API operations with their input schemas, the correct AWS service endpoint, and the required IAM action, so the agent can invoke the right call without crawling the AWS docs.
Time to first call
Direct AWS Lambda API integration: 1-3 days for AWS SDK setup, IAM role configuration, Sigv4 signing, and error handling. Through Jentic: under 1 hour, search, load schema, execute.
Related APIs
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using AWS Lambda API through Jentic.
What authentication does the AWS Lambda API use?
All requests are signed with AWS Signature Version 4 using an AWS access key ID and secret access key. Through Jentic, the keys live encrypted in the Jentic vault and signing is performed server-side; the agent only sees a scoped Jentic credential reference.
Can I deploy a Lambda function from a container image with this API?
Yes. Call createFunction with PackageType=Image and an ImageUri pointing at an Amazon ECR repository in the same region. Container image functions support up to 10 GB memory, 15-minute timeouts, and arm64 or x86_64 architectures.
What are the rate limits for the AWS Lambda API?
Lambda enforces account-level concurrent execution limits (default 1,000) and per-function reserved or provisioned concurrency that you set explicitly. The control-plane API operations (createFunction, updateFunctionCode, etc.) are subject to standard AWS request throttling and return ThrottlingException with retry guidance.
How do I invoke a Lambda function and get the response through Jentic?
Search Jentic for 'invoke a Lambda function' and execute the returned operation with FunctionName and a JSON Payload. The operation maps to POST /2015-03-31/functions/{FunctionName}/invocations and returns the function's payload synchronously when InvocationType is RequestResponse.
Does the API support streaming responses?
Yes. Use POST /2015-03-31/functions/{FunctionName}/invoke-with-response-stream to receive a chunked response from a function configured with response streaming. This is suitable for LLM-style outputs and large file generation that should not buffer in memory.
Is AWS Lambda free to use?
Lambda has an always-free tier of 1 million requests and 400,000 GB-seconds of compute per month. Beyond that, you pay per request and per GB-second of memory consumed at the duration billed in 1 ms increments.
GET STARTED