Firebase Authentication Triggers

Cloud Functions can be triggered by events from Firebase Authentication in the same Google Cloud project as the function. These events include user creation and user deletion. For example, you could send a welcome email to a user who has just created an account in your app.

Event types

Firebase Authentication can trigger functions in response to user create and delete events.

Event Type Trigger
providers/firebase.auth/eventTypes/user.create Triggered when a user account is created.
providers/firebase.auth/eventTypes/user.delete Triggered when a user account is deleted.

User creation

Firebase accounts trigger user creation events for Cloud Functions when:

  • A user creates an email account and password.

  • A user signs in for the first time using a federated identity provider.

  • The developer creates an account using the Firebase Admin SDK.

  • A user signs in to a new anonymous auth session for the first time.

User deletion

You can also configure a function to trigger upon user deletion.

Event structure

Event data is provided as a UserRecord object.

An example password-based account creation event is shown below:

  "email": "",
  "metadata": {
      "createdAt": "2018-10-19T19:29:16Z"
  "uid": "XXXXX"

Some properties of this object are only defined when using certain authentication methods. For example, password-based account events define an email property containing the user's email address. The uid property (which contains a user ID unique to your project) is always defined.

Sample code


 * Background Function triggered by a change to a Firebase Auth user object.
 * @param {!Object} event The Cloud Functions event.
exports.helloAuth = event => {
  try {
    console.log(`Function triggered by change to user: ${event.uid}`);
    console.log(`Created at: ${event.metadata.createdAt}`);

    if ( {
      console.log(`Email: ${}`);
  } catch (err) {


import json

def hello_auth(data, context):
    """Triggered by creation or deletion of a Firebase Auth user object.
           data (dict): The event payload.
           context ( Metadata for the event.
    print("Function triggered by creation/deletion of user: %s" % data["uid"])
    print("Created at: %s" % data["metadata"]["createdAt"])

    if "email" in data:
        print("Email: %s" % data["email"])


// Package firebase contains a Firestore Cloud Function.
package firebase

import (

// AuthEvent is the payload of a Firestore Auth event.
type AuthEvent struct {
	Email    string `json:"email"`
	Metadata struct {
		CreatedAt time.Time `json:"createdAt"`
	} `json:"metadata"`
	UID string `json:"uid"`

// HelloAuth is triggered by Firestore Auth events.
func HelloAuth(ctx context.Context, e AuthEvent) error {
	log.Printf("Function triggered by creation or deletion of user: %q", e.UID)
	log.Printf("Created at: %v", e.Metadata.CreatedAt)
	if e.Email != "" {
		log.Printf("Email: %q", e.Email)
	return nil


import java.util.logging.Logger;

public class FirebaseAuth implements RawBackgroundFunction {
  private static final Logger logger = Logger.getLogger(FirebaseAuth.class.getName());

  // Use GSON ( to parse JSON content.
  private static final Gson gson = new Gson();

  public void accept(String json, Context context) {
    JsonObject body = gson.fromJson(json, JsonObject.class);

    if (body != null && body.has("uid")) {"Function triggered by change to user: " + body.get("uid").getAsString());

    if (body != null && body.has("metadata")) {
      JsonObject metadata = body.get("metadata").getAsJsonObject();"Created at: " + metadata.get("createdAt").getAsString());

    if (body != null && body.has("email")) {"Email: " + body.get("email").getAsString());


using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Firebase.Auth.V1;
using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

namespace FirebaseAuth;

public class Function : ICloudEventFunction<AuthEventData>
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public Task HandleAsync(CloudEvent cloudEvent, AuthEventData data, CancellationToken cancellationToken)
        _logger.LogInformation("Function triggered by change to user: {uid}", data.Uid);
        if (data.Metadata is UserMetadata metadata)
            _logger.LogInformation("User created at: {created:s}", metadata.CreateTime.ToDateTimeOffset());
        if (!string.IsNullOrEmpty(data.Email))
            _logger.LogInformation("Email: {email}", data.Email);

        // In this example, we don't need to perform any asynchronous operations, so the
        // method doesn't need to be declared async.
        return Task.CompletedTask;


require "functions_framework"

# Triggered by creation or deletion of a Firebase Auth user object.
FunctionsFramework.cloud_event "hello_auth" do |event|
  # Event-triggered Ruby functions receive a CloudEvents::Event::V1 object.
  # See
  # The Firebase event payload can be obtained from the `data` field.
  payload = "Function triggered by creation/deletion of user: #{payload['uid']}" "Created at: #{payload['metadata']['createdAt']}" "Email: #{payload['email']}" if payload.key? "email"


use Google\CloudFunctions\CloudEvent;

function firebaseAuth(CloudEvent $cloudevent)
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb');
    $data = $cloudevent->getData();

        'Function triggered by change to user: ' . $data['uid'] . PHP_EOL
    fwrite($log, 'Created at: ' . $data['metadata']['createTime'] . PHP_EOL);

    if (isset($data['email'])) {
        fwrite($log, 'Email: ' . $data['email'] . PHP_EOL);

Deploying your function

To deploy your function, you need to specify the event type and the project for which you have Firebase Auth configured. In the Google Cloud console, there is a single field for Event Type as the project is assumed to be the same as the project that contains your function.

On the command line, however, you must use specific strings to specify these two parameters. The following gcloud command deploys a function that is triggered by user create events:

gcloud functions deploy FUNCTION_NAME \
  --entry-point ENTRY_POINT \
  --trigger-event providers/firebase.auth/eventTypes/user.create \
  --trigger-resource YOUR_PROJECT_ID \
  --runtime RUNTIME
Argument Description
FUNCTION_NAME The registered name of the Cloud Function you are deploying. This can either be the name of a function in your source code, or an arbitrary string. If FUNCTION_NAME is an arbitrary string, then you must include the --entry-point flag.
--entry-point ENTRY_POINT The name of a function or class in your source code. Optional, unless you did not use FUNCTION_NAME to specify the function in your source code to be executed during deployment. In that case, you must use --entry-point to supply the name of the executable function.
--trigger-event NAME The name of the event type that triggers the function. In this case, it should be one of create or delete, as listed above.
--trigger-resource NAME The project ID (in this example, YOUR_PROJECT_ID) for the project that contains your function and Firebase Authentication.
--runtime RUNTIME The name of the runtime you are using. For a complete list, see the gcloud reference.