Azure Functions triggers and bindings concepts

In this article, you learn the high-level concepts surrounding functions triggers and bindings.

Triggers cause a function to run. A trigger defines how a function is invoked and a function must have exactly one trigger. Triggers can also pass data into your function, as you would with method calls.

Binding to a function is a way of declaratively connecting your functions to other resources; bindings either pass data into your function (an input binding) or enable you to write data out from your function (an output binding) using binding parameters. Your function trigger is essentially a special type of input binding.

You can mix and match different bindings to suit your function's specific scenario. Bindings are optional and a function might have one or multiple input and/or output bindings.

Triggers and bindings let you avoid hardcoding access to other services. Your function receives data (for example, the content of a queue message) in function parameters. You send data (for example, to create a queue message) by using the return value of the function.

Consider the following examples of how you could implement different functions.

Example scenario	Trigger	Input binding	Output binding
A new queue message arrives which runs a function to write to another queue.	Queue*	None	Queue*
A scheduled job reads Blob Storage contents and creates a new Azure Cosmos DB document.	Timer	Blob Storage	Azure Cosmos DB
The Event Grid is used to read an image from Blob Storage and a document from Azure Cosmos DB to send an email.	Event Grid	Blob Storage and Azure Cosmos DB	SendGrid

^* Represents different queues

These examples aren't meant to be exhaustive, but are provided to illustrate how you can use triggers and bindings together. For a more comprehensive set of scenarios, see Azure Functions scenarios.

Tip

Functions doesn't require you to use input and output bindings to connect to Azure services. You can always create an Azure SDK client in your code and use it instead for your data transfers. For more information, see Connect to services.

Trigger and binding definitions

A function has a single trigger and one or more bindings. The type of binding is either input or output. Not all services support both input and output bindings. See your specific binding extension for specific bindings code examples.

Triggers and bindings are defined differently depending on the development language. Make sure to select your language at the top of the article.

This example shows an HTTP triggered function with an output binding that writes a message to an Azure Storage queue.

For C# class library functions, triggers and bindings are configured by decorating methods and parameters with C# attributes, where the specific attribute applied might depend on the C# runtime model:

Isolated process

The HTTP trigger (HttpTrigger) is defined on the Run method for a function named HttpExample that returns a MultiResponse object:

[Function("HttpExample")]
public static MultiResponse Run([HttpTrigger(AuthorizationLevel.Function, "get", "post")] HttpRequestData req,
    FunctionContext executionContext)
{

This example shows the MultiResponse object definition which both returns an HttpResponse to the HTTP request and also writes a message to a storage queue using a QueueOutput binding:

public class MultiResponse
{
    [QueueOutput("outqueue",Connection = "AzureWebJobsStorage")]
    public string[] Messages { get; set; }
    public HttpResponseData HttpResponse { get; set; }
}

For more information, see the C# isolated worker model guide.

In-process

The HTTP trigger (HttpTrigger) is defined on the Run method for a function named HttpExample that writes to a storage queue defined by the Queue and StorageAccount attributes on the msg parameter:

[FunctionName("HttpExample")]
public static async Task<IActionResult> Run(
    [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, 
    [Queue("outqueue"),StorageAccount("AzureWebJobsStorage")] ICollector<string> msg, 
    ILogger log)
{

For more information, see the C# in-process model guide.

Legacy C# Script functions use a function.json definition file. For more information, see the Azure Functions C# script (.csx) developer reference.

For Java functions, triggers and bindings are configured by annotating specific methods and parameters. This HTTP trigger (@HttpTrigger) is defined on the run method for a function named HttpTriggerQueueOutput, which writes to a storage queue defined by the @QueueOutput annotation on the message parameter:

@FunctionName("HttpExample")
public HttpResponseMessage run(
        @HttpTrigger(name = "req", methods = {HttpMethod.GET, HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) 
        HttpRequestMessage<Optional<String>> request, 
        @QueueOutput(name = "msg", queueName = "outqueue", 
        connection = "AzureWebJobsStorage") OutputBinding<String> msg, 
        final ExecutionContext context) {
    context.getLogger().info("Java HTTP trigger processed a request.");

For more information, see the Java developer guide.

The way that triggers and binding are defined for Node.js functions depends on the specific version of Node.js for Functions:

v4

In Node.js for Functions version 4, you configure triggers and bindings using objects exported from the @azure/functions module. For more information, see the Node.js developer guide.

v3

In Node.js for Functions version 3, you configure triggers and bindings in a function-specific function.json file in the same folder as your code. For more information, see the Node.js developer guide.

This example is an HTTP triggered function that creates a queue item for each HTTP request received.

v4

The http method on the exported app object defines an HTTP trigger, and the storageQueue method on output defines an output binding on this trigger.

const { app, output } = require('@azure/functions');

const queueOutput = output.storageQueue({
    queueName: 'outqueue',
    connection: 'MyStorageConnectionAppSetting',
});

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraOutputs: [queueOutput],
    handler: async (request, context) => {
        const body = await request.text();
        context.extraOutputs.set(queueOutput, body);
        return { body: 'Created queue item.' };
    },
});

v3

This example function.json file defines the HTTP trigger function that returns an HTTP response and writes to a storage queue.

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "function",
      "name": "input"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "myQueueItem",
      "queueName": "outqueue",
      "connection": "MyStorageConnectionAppSetting"
    }
  ]
}

v4

The http method on the exported app object defines an HTTP trigger, and the storageQueue method on output defines an output binding on this trigger.

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const queueOutput = output.storageQueue({
    queueName: 'outqueue',
    connection: 'MyStorageConnectionAppSetting',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    const body = await request.text();
    context.extraOutputs.set(queueOutput, body);
    return { body: 'Created queue item.' };
}

app.http('httpTrigger1', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    extraOutputs: [queueOutput],
    handler: httpTrigger1,
});

v3

This example function.json file defines the HTTP trigger function that returns an HTTP response and writes to a storage queue.

{
  "bindings": [
    {
      "type": "httpTrigger",
      "direction": "in",
      "authLevel": "function",
      "name": "input"
    },
    {
      "type": "http",
      "direction": "out",
      "name": "$return"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "myQueueItem",
      "queueName": "outqueue",
      "connection": "MyStorageConnectionAppSetting"
    }
  ]
}

This example function.json file defines the function:

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

For more information, see the PowerShell developer guide.

The way that the function is defined depends on the version of Python for Functions:

v2

In Python for Functions version 2, you define the function directly in code using decorators.

app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)

@app.route(route="HttpExample")
@app.queue_output(arg_name="msg", queue_name="outqueue", connection="AzureWebJobsStorage")
def HttpExample(req: func.HttpRequest, msg: func.Out [func.QueueMessage]) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

v1

In Python for Functions version 1, this example function.json file defines an HTTP trigger function that returns an HTTP response and writes to a storage queue.

    {
      "authLevel": "function",
      "type": "httpTrigger",
      "direction": "in",
      "name": "Request",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "type": "http",
      "direction": "out",
      "name": "Response"
    },
    {
      "type": "queue",
      "direction": "out",
      "name": "msg",
      "queueName": "outqueue",
      "connection": "AzureWebJobsStorage"
    }
  ]
}

Add bindings to a function

You can connect your function to other services by using input or output bindings. Add a binding by adding its specific definitions to your function. To learn how, see Add bindings to an existing function in Azure Functions.

Azure Functions supports multiple bindings, which must be configured correctly. For example, a function can read data from a queue (input binding) and write data to a database (output binding) simultaneously.

Supported bindings

This table shows the bindings that are supported in the major versions of the Azure Functions runtime:

Type	1.x1	2.x and higher2	Trigger	Input	Output
Blob storage	✔	✔	✔	✔	✔
Azure Cosmos DB	✔	✔	✔	✔	✔
Azure Data Explorer		✔		✔	✔
Azure SQL		✔	✔	✔	✔
Dapr4		✔	✔	✔	✔
Event Grid	✔	✔	✔		✔
Event Hubs	✔	✔	✔		✔
HTTP & webhooks	✔	✔	✔		✔
IoT Hub	✔	✔	✔
Kafka3		✔	✔		✔
Mobile Apps	✔			✔	✔
Notification Hubs	✔				✔
Queue storage	✔	✔	✔		✔
Redis		✔	✔
RabbitMQ3		✔	✔		✔
SendGrid	✔	✔			✔
Service Bus	✔	✔	✔		✔
SignalR		✔	✔	✔	✔
Table storage	✔	✔		✔	✔
Timer	✔	✔	✔
Twilio	✔	✔			✔

Notes:

1. Support will end for version 1.x of the Azure Functions runtime on September 14, 2026. We highly recommend that you migrate your apps to version 4.x for full support.
2. Starting with the version 2.x runtime, all bindings except HTTP and Timer must be registered. See Register binding extensions.
3. Triggers aren't supported in the Consumption plan. Requires runtime-driven triggers.
4. Supported in Kubernetes, IoT Edge, and other self-hosted modes only.

For information about which bindings are in preview or are approved for production use, see Supported languages.

Specific binding extension versions are only supported while the underlying service SDK is supported. Changes to support in the underlying service SDK version affect the support for the consuming extension.

Bindings code examples

Use the following table to find more examples of specific binding types that show you how to work with bindings in your functions. First, choose the language tab that corresponds to your project.

Binding code for C# depends on the specific process model.

Isolated process

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output	Link
Azure SQL	Trigger Input Output	Link
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

In-process

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output	Link
Azure SQL	Trigger Input Output	Link
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output	Link
Azure SQL	Trigger Input Output
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output
Azure SQL	Trigger Input Output	Link
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure SQL	Trigger Input Output
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

Binding code for Python depends on the Python model version.

v2

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output
Azure SQL	Trigger Input Output	Link
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

v1

Service	Examples	Samples
Blob storage	Trigger Input Output	Link
Azure Cosmos DB	Trigger Input Output	Link
Azure Data Explorer	Input Output
Azure SQL	Trigger Input Output	Link
Event Grid	Trigger Output	Link
Event Hubs	Trigger Output
IoT Hub	Trigger Output
HTTP	Trigger	Link
Queue storage	Trigger Output	Link
RabbitMQ	Trigger Output
SendGrid	Output
Service Bus	Trigger Output	Link
SignalR	Trigger Input Output
Table storage	Input Output
Timer	Trigger	Link
Twilio	Output	Link

Custom bindings

You can create custom input and output bindings. Bindings must be authored in .NET, but can be consumed from any supported language. For more information about creating custom bindings, see Creating custom input and output bindings.

Related content

• Binding expressions and patterns
• How to register a binding expression
• Testing:
  • Strategies for testing your code in Azure Functions
  • Manually run a non HTTP-triggered function
• Handling binding errors