Ir para o console

Criar solicitações de envio do servidor de apps

Ao usar os protocolos do SDK Admin do Firebase ou do servidor de apps FCM, crie solicitações de mensagens e envie-as a estes tipos de destinos:

  • Nome do tópico
  • Condição
  • Token de registro do dispositivo
  • Nome do grupo de dispositivos (somente protocolos legados e o SDK Admin do Firebase para Node.js)

Envie mensagens com um payload de notificação composta por campos predefinidos, um payload de dados de seus próprios campos definidos pelo usuário ou uma mensagem que contém os dois tipos de payload. Consulte Tipos de mensagens para mais informações.

Nos exemplos desta página, mostramos como enviar mensagens de notificação com o SDK Admin do Firebase, compatível com Node, Java, Python, C# e Go, além do protocolo v1 HTTP. Há também orientação para o envio de mensagens por meio dos protocolos HTTP e XMPP legados.

Enviar mensagens a dispositivos específicos

Para enviar para um único dispositivo específico, transmita o token de registro do dispositivo, conforme mostrado. Consulte as informações de configuração do cliente da sua plataforma para saber mais sobre esses tokens.

Node.js

// This registration token comes from the client FCM SDKs.
var registrationToken = 'YOUR_REGISTRATION_TOKEN';

var message = {
  data: {
    score: '850',
    time: '2:45'
  },
  token: registrationToken
};

// Send a message to the device corresponding to the provided
// registration token.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

// This registration token comes from the client FCM SDKs.
String registrationToken = "YOUR_REGISTRATION_TOKEN";

// See documentation on defining a message payload.
Message message = Message.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .setToken(registrationToken)
    .build();

// Send a message to the device corresponding to the provided
// registration token.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Python

# This registration token comes from the client FCM SDKs.
registration_token = 'YOUR_REGISTRATION_TOKEN'

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    token=registration_token,
)

# Send a message to the device corresponding to the provided
# registration token.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Go

// Obtain a messaging.Client from the App.
ctx := context.Background()
client, err := app.Messaging(ctx)
if err != nil {
	log.Fatalf("error getting Messaging client: %v\n", err)
}

// This registration token comes from the client FCM SDKs.
registrationToken := "YOUR_REGISTRATION_TOKEN"

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Token: registrationToken,
}

// Send a message to the device corresponding to the provided
// registration token.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

// This registration token comes from the client FCM SDKs.
var registrationToken = "YOUR_REGISTRATION_TOKEN";

// See documentation on defining a message payload.
var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Token = registrationToken,
};

// Send a message to the device corresponding to the provided
// registration token.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

REST

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA

{
  "message":{
    "token" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...",
    "notification" : {
      "body" : "This is an FCM notification message!",
      "title" : "FCM Message",
      }
   }
}

Comando cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
"message":{
  "notification": {
    "title": "FCM Message",
    "body": "This is an FCM Message",
  },
  "token": "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
  }
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send

Se tiver sucesso, cada método de envio retorna um ID de mensagem. O SDK Admin do Firebase retorna a string do identificador no formato projects/{project_id}/messages/{message_id}. A resposta do protocolo HTTP é uma única chave JSON:

    {
      "name": "projects/myproject-b5ae1/messages/0:1500415314455276%31bd1c9631bd1c96"
    }

Enviar mensagens a vários dispositivos

As APIs do Admin FCM para Node, Java e .NET permitem fazer multicast de uma mensagem para uma lista de tokens de registro de dispositivo. É possível especificar até 100 tokens de registro de dispositivo por invocação.

Node.js

// Create a list containing up to 100 registration tokens.
// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // …
  'YOUR_REGISTRATION_TOKEN_N',
];

const message = {
  data: {score: '850', time: '2:45'},
  tokens: registrationTokens,
}

admin.messaging().sendMulticast(message)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');

Java

// Create a list containing up to 100 registration tokens.
// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Go

// Create a list containing up to 100 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Tokens: registrationTokens,
}

br, err := client.SendMulticast(context.Background(), message)
if err != nil {
	log.Fatalln(err)
}

// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)

C#

// Create a list containing up to 100 registration tokens.
// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
    Tokens = registrationTokens,
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

Por trás dessa operação usa-se a API sendAll(), conforme mostrado nos exemplos abaixo. O valor de retorno é um BatchResponse em que as lista de respostas corresponde à ordem dos tokens de entrada. Isso é útil quando se quer verificar quais tokens resultaram em erros.

Node.js

// These registration tokens come from the client FCM SDKs.
const registrationTokens = [
  'YOUR_REGISTRATION_TOKEN_1',
  // …
  'YOUR_REGISTRATION_TOKEN_N',
];

const message = {
  data: {score: '850', time: '2:45'},
  tokens: registrationTokens,
}

admin.messaging().sendMulticast(message)
  .then((response) => {
    if (response.failureCount > 0) {
      const failedTokens = [];
      response.responses.forEach((resp, idx) => {
        if (!resp.success) {
          failedTokens.push(registrationTokens[idx]);
        }
      });
      console.log('List of tokens that caused failures: ' + failedTokens);
    }
  });

Java

// These registration tokens come from the client FCM SDKs.
List<String> registrationTokens = Arrays.asList(
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllTokens(registrationTokens)
    .build();
BatchResponse response = FirebaseMessaging.getInstance().sendMulticast(message);
if (response.getFailureCount() > 0) {
  List<SendResponse> responses = response.getResponses();
  List<String> failedTokens = new ArrayList<>();
  for (int i = 0; i < responses.size(); i++) {
    if (!responses.get(i).isSuccessful()) {
      // The order of responses corresponds to the order of the registration tokens.
      failedTokens.add(registrationTokens.get(i));
    }
  }

  System.out.println("List of tokens that caused failures: " + failedTokens);
}

Go

// Create a list containing up to 100 registration tokens.
// This registration tokens come from the client FCM SDKs.
registrationTokens := []string{
	"YOUR_REGISTRATION_TOKEN_1",
	// ...
	"YOUR_REGISTRATION_TOKEN_n",
}
message := &messaging.MulticastMessage{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Tokens: registrationTokens,
}

br, err := client.SendMulticast(context.Background(), message)
if err != nil {
	log.Fatalln(err)
}

if br.FailureCount > 0 {
	var failedTokens []string
	for idx, resp := range br.Responses {
		if !resp.Success {
			// The order of responses corresponds to the order of the registration tokens.
			failedTokens = append(failedTokens, registrationTokens[idx])
		}
	}

	fmt.Printf("List of tokens that caused failures: %v\n", failedTokens)
}

C#

// These registration tokens come from the client FCM SDKs.
var registrationTokens = new List<string>()
{
    "YOUR_REGISTRATION_TOKEN_1",
    // ...
    "YOUR_REGISTRATION_TOKEN_n",
};
var message = new MulticastMessage()
{
    Tokens = registrationTokens,
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendMulticastAsync(message);
if (response.FailureCount > 0)
{
    var failedTokens = new List<string>();
    for (var i = 0; i < response.Responses.Count; i++)
    {
        if (!response.Responses[i].IsSuccess)
        {
            // The order of responses corresponds to the order of the registration tokens.
            failedTokens.Add(registrationTokens[i]);
        }
    }

    Console.WriteLine($"List of tokens that caused failures: {failedTokens}");
}

Enviar mensagens a tópicos

Depois de criar um tópico, seja assinando instâncias do aplicativo cliente para o tópico no cliente ou por meio da API do servidor, será possível enviar mensagens para o tópico. Na sua lógica de envio no back-end, especifique o nome do tópico desejado conforme mostrado abaixo:

Node.js

// The topic name can be optionally prefixed with "/topics/".
var topic = 'highScores';

var message = {
  data: {
    score: '850',
    time: '2:45'
  },
  topic: topic
};

// Send a message to devices subscribed to the provided topic.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

// The topic name can be optionally prefixed with "/topics/".
String topic = "highScores";

// See documentation on defining a message payload.
Message message = Message.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .setTopic(topic)
    .build();

// Send a message to the devices subscribed to the provided topic.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Python

# The topic name can be optionally prefixed with "/topics/".
topic = 'highScores'

# See documentation on defining a message payload.
message = messaging.Message(
    data={
        'score': '850',
        'time': '2:45',
    },
    topic=topic,
)

# Send a message to the devices subscribed to the provided topic.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Go

// The topic name can be optionally prefixed with "/topics/".
topic := "highScores"

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Topic: topic,
}

// Send a message to the devices subscribed to the provided topic.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

// The topic name can be optionally prefixed with "/topics/".
var topic = "highScores";

// See documentation on defining a message payload.
var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Topic = topic,
};

// Send a message to the devices subscribed to the provided topic.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

REST

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
  "message":{
    "topic" : "foo-bar",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message"
      }
   }
}

Comando cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "message": {
    "topic" : "foo-bar",
    "notification": {
      "body": "This is a Firebase Cloud Messaging Topic Message!",
      "title": "FCM Message"
    }
  }
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Para enviar uma mensagem para uma combinação de tópicos, especifique uma condição, que é uma expressão booleana que especifica os tópicos de destino. Por exemplo, a seguinte condição enviará mensagens para dispositivos que estão inscritos em TopicA e em TopicB ou TopicC:

"'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)"

No FCM, todas as condições entre parênteses são avaliadas primeiro e depois a expressão é analisada da esquerda para a direita. Na expressão acima, um usuário que se inscreveu em um só tópico não receberá a mensagem. Do mesmo modo, um usuário que não se inscreveu em TopicA também não receberá a mensagem. Somente estas combinações são válidas:

  • TopicA e TopicB
  • TopicA e TopicC

É possível incluir até cinco tópicos na sua expressão condicional.

Para enviar para uma condição:

Node.js

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
var condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
var message = {
  notification: {
    title: '$GOOG up 1.43% on the day',
    body: '$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  condition: condition
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
admin.messaging().send(message)
  .then((response) => {
    // Response is a message ID string.
    console.log('Successfully sent message:', response);
  })
  .catch((error) => {
    console.log('Error sending message:', error);
  });

Java

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
String condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
Message message = Message.builder()
    .setNotification(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .setCondition(condition)
    .build();

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
String response = FirebaseMessaging.getInstance().send(message);
// Response is a message ID string.
System.out.println("Successfully sent message: " + response);

Python

# Define a condition which will send to devices which are subscribed
# to either the Google stock or the tech industry topics.
condition = "'stock-GOOG' in topics || 'industry-tech' in topics"

# See documentation on defining a message payload.
message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    condition=condition,
)

# Send a message to devices subscribed to the combination of topics
# specified by the provided condition.
response = messaging.send(message)
# Response is a message ID string.
print('Successfully sent message:', response)

Go

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
condition := "'stock-GOOG' in topics || 'industry-tech' in topics"

// See documentation on defining a message payload.
message := &messaging.Message{
	Data: map[string]string{
		"score": "850",
		"time":  "2:45",
	},
	Condition: condition,
}

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
response, err := client.Send(ctx, message)
if err != nil {
	log.Fatalln(err)
}
// Response is a message ID string.
fmt.Println("Successfully sent message:", response)

C#

// Define a condition which will send to devices which are subscribed
// to either the Google stock or the tech industry topics.
var condition = "'stock-GOOG' in topics || 'industry-tech' in topics";

// See documentation on defining a message payload.
var message = new Message()
{
    Notification = new Notification()
    {
        Title = "$GOOG up 1.43% on the day",
        Body = "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
    },
    Condition = condition,
};

// Send a message to devices subscribed to the combination of topics
// specified by the provided condition.
string response = await FirebaseMessaging.DefaultInstance.SendAsync(message);
// Response is a message ID string.
Console.WriteLine("Successfully sent message: " + response);

REST

POST https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Content-Type: application/json
Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA
{
   "message":{
    "condition": "'dogs' in topics || 'cats' in topics",
    "notification" : {
      "body" : "This is a Firebase Cloud Messaging Topic Message!",
      "title" : "FCM Message",
    }
  }
}

Comando cURL:

curl -X POST -H "Authorization: Bearer ya29.ElqKBGN2Ri_Uz...HnS_uNreA" -H "Content-Type: application/json" -d '{
  "notification": {
    "title": "FCM Message",
    "body": "This is a Firebase Cloud Messaging Topic Message!",
  },
  "condition": "'dogs' in topics || 'cats' in topics"
}' https://fcm.googleapis.com/v1/projects/myproject-b5ae1/messages:send HTTP/1.1

Enviar um lote de mensagens

Os SDKs Admin para Node, Java e .NET são compatíveis com o envio de mensagens em lotes. É possível agrupar até 100 mensagens em um único lote e enviá-las todas em uma única chamada de API, com melhoria de desempenho significativa em relação ao envio de solicitações HTTP separadas para cada mensagem.

Esse recurso pode ser usado para criar um conjunto personalizado de mensagens e enviá-las para diferentes destinatários, incluindo tópicos ou tokens de registro de dispositivos específicos. Use esse recurso quando, por exemplo, for necessário enviar simultaneamente mensagens para diferentes públicos com detalhes ligeiramente diferentes no corpo da mensagem.

Node.js

// Create a list containing up to 100 messages.
const messages = [];
messages.push({
  notification: {title: 'Price drop', body: '5% off all electronics'},
  token: registrationToken,
});
messages.push({
  notification: {title: 'Price drop', body: '2% off all books'},
  topic: 'readers-club',
});

admin.messaging().sendAll(messages)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
  });

Java

// Create a list containing up to 100 messages.
List<Message> messages = Arrays.asList(
    Message.builder()
        .setNotification(new Notification("Price drop", "5% off all electronics"))
        .setToken(registrationToken)
        .build(),
    // ...
    Message.builder()
        .setNotification(new Notification("Price drop", "2% off all books"))
        .setTopic("readers-club")
        .build()
);

BatchResponse response = FirebaseMessaging.getInstance().sendAll(messages);
// See the BatchResponse reference documentation
// for the contents of response.
System.out.println(response.getSuccessCount() + " messages were sent successfully");

Go

// Create a list containing up to 100 messages.
messages := []*messaging.Message{
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "5% off all electronics",
		},
		Token: registrationToken,
	},
	{
		Notification: &messaging.Notification{
			Title: "Price drop",
			Body:  "2% off all books",
		},
		Topic: "readers-club",
	},
}

br, err := client.SendAll(context.Background(), messages)
if err != nil {
	log.Fatalln(err)
}

// See the BatchResponse reference documentation
// for the contents of response.
fmt.Printf("%d messages were sent successfully\n", br.SuccessCount)

C#

// Create a list containing up to 100 messages.
var messages = new List<Message>()
{
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "5% off all electronics",
        },
        Token = registrationToken,
    },
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "2% off all books",
        },
        Topic = "readers-club",
    },
};

var response = await FirebaseMessaging.DefaultInstance.SendAllAsync(messages);
// See the BatchResponse reference documentation
// for the contents of response.
Console.WriteLine($"{response.SuccessCount} messages were sent successfully");

É possível consultar o BatchResponse retornado para verificar quantas mensagens foram entregues ao FCM com êxito. Também expõe uma lista de respostas que podem ser usadas para verificar o estado de mensagens individuais. A ordem das respostas corresponde à ordem das mensagens na lista de entrada.

Personalizar mensagens entre plataformas

O SDK Admin do Firebase e o protocolo v1 HTTP do FCM permitem que suas solicitações de mensagens configurem todos os campos disponíveis no objeto message como:

  • um conjunto comum de campos a serem interpretados por todas as instâncias do app que recebem a mensagem;
  • conjuntos de campos específicos da plataforma, como AndroidConfig e WebpushConfig, interpretados apenas pelas instâncias do app em execução na plataforma especificada.

Os blocos específicos da plataforma oferecem flexibilidade para personalizar mensagens em plataformas diferentes a fim de garantir que elas sejam gerenciadas corretamente quando recebidas. O back-end do FCM considerará todos os parâmetros especificados e personalizará a mensagem para cada plataforma.

Quando usar campos comuns

Use campos comuns quando ao:

  • segmentar instâncias de apps em todas as plataformas: iOS, Android e Web;
  • enviar mensagens para tópicos.

Todas as instâncias do app, independentemente da plataforma, podem interpretar os seguintes campos comuns:

Quando usar campos específicos da plataforma

Use campos específicos da plataforma quando quiser:

  • enviar campos apenas para plataformas específicas;
  • enviar campos específicos da plataforma, além dos campos comuns.

Sempre que você quiser enviar valores apenas para plataformas específicas, não use campos comuns. Em vez disso, use campos específicos da plataforma. Por exemplo, para enviar uma notificação apenas para iOS e Web, mas não para o Android, use dois conjuntos de campos separados, um para iOS e outro para a Web.

Ao enviar mensagens com opções de entrega específicas, use os campos específicos da plataforma para configurá-las. É possível especificar valores diferentes por plataforma, se você quiser. No entanto, mesmo quando você quiser definir essencialmente o mesmo valor em todas as plataformas, é necessário usar campos específicos da plataforma. Isso ocorre porque o valor pode ser interpretado de maneira ligeiramente diferente dependendo da plataforma. Por exemplo, a vida útil é definida no Android como um período de validade em segundos, enquanto que no iOS é definido como uma data de validade.

Exemplo: mensagem de notificação com opções de entrega específicas da plataforma

A solicitação de envio a seguir envia o título e o conteúdo de uma notificação comum para todas as plataformas, mas também envia algumas modificações específicas da plataforma. Especificamente, a solicitação:

  • define uma vida útil longa para o Android, juntamente com um ícone e cor especiais para exibir em dispositivos Android;
  • define o campo badge apenas para iOS no payload do APN, para entrega em dispositivos iOS.

Node.js

var message = {
  notification: {
    title: '$GOOG up 1.43% on the day',
    body: '$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
  },
  android: {
    ttl: 3600 * 1000,
    notification: {
      icon: 'stock_ticker_update',
      color: '#f45342',
    },
  },
  apns: {
    payload: {
      aps: {
        badge: 42,
      },
    },
  },
  topic: 'industry-tech'
};

Java

Message message = Message.builder()
    .setNotification(new Notification(
        "$GOOG up 1.43% on the day",
        "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."))
    .setAndroidConfig(AndroidConfig.builder()
        .setTtl(3600 * 1000)
        .setNotification(AndroidNotification.builder()
            .setIcon("stock_ticker_update")
            .setColor("#f45342")
            .build())
        .build())
    .setApnsConfig(ApnsConfig.builder()
        .setAps(Aps.builder()
            .setBadge(42)
            .build())
        .build())
    .setTopic("industry-tech")
    .build();

Python

message = messaging.Message(
    notification=messaging.Notification(
        title='$GOOG up 1.43% on the day',
        body='$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.',
    ),
    android=messaging.AndroidConfig(
        ttl=datetime.timedelta(seconds=3600),
        priority='normal',
        notification=messaging.AndroidNotification(
            icon='stock_ticker_update',
            color='#f45342'
        ),
    ),
    apns=messaging.APNSConfig(
        payload=messaging.APNSPayload(
            aps=messaging.Aps(badge=42),
        ),
    ),
    topic='industry-tech',
)

Go

oneHour := time.Duration(1) * time.Hour
badge := 42
message := &messaging.Message{
	Notification: &messaging.Notification{
		Title: "$GOOG up 1.43% on the day",
		Body:  "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
	},
	Android: &messaging.AndroidConfig{
		TTL: &oneHour,
		Notification: &messaging.AndroidNotification{
			Icon:  "stock_ticker_update",
			Color: "#f45342",
		},
	},
	APNS: &messaging.APNSConfig{
		Payload: &messaging.APNSPayload{
			Aps: &messaging.Aps{
				Badge: &badge,
			},
		},
	},
	Topic: "industry-tech",
}

C#

var message = new Message
{
    Notification = new Notification()
    {
        Title = "$GOOG up 1.43% on the day",
        Body = "$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.",
    },
    Android = new AndroidConfig()
    {
        TimeToLive = TimeSpan.FromHours(1),
        Notification = new AndroidNotification()
        {
            Icon = "stock_ticker_update",
            Color = "#f45342",
        },
    },
    Apns = new ApnsConfig()
    {
        Aps = new Aps()
        {
            Badge = 42,
        },
    },
    Topic = "industry-tech",
};

REST

{
  "message":{
     "topic":"industry-tech",
     "notification":{
       "title": "$GOOG" up 1.43% on the day",
       "body":"GOOG gained 11.80 points to close at 835.67, up 1.43% on the day."
     },
     "android":{
       "ttl":"3600s",
       "notification"{
         "icon:stock_ticker_update"
         "color:#f45342"
       }
     },
     "apns": {
       "payload": {
         "aps": {
           "badge": "42"
         }
       }
     },
     "webpush":{
       "headers":{
         "TTL":"86400"
       }
     }
   }
 }

Consulte a documentação de referência HTTP v1 para ver mais detalhes sobre as chaves disponíveis em blocos específicos da plataforma no corpo da mensagem.

Referência de erros do SDK Admin do FCM

A tabela a seguir lista os códigos de erro da API Firebase Admin FCM e a descrição de cada um, incluindo as etapas de resolução recomendadas.

Código do erro Etapas de descrição e resolução
messaging/invalid-argument Um argumento inválido foi fornecido a um método do FCM. A mensagem de erro deve conter informações adicionais.
messaging/invalid-recipient O destinatário da mensagem pretendida é inválido. A mensagem de erro deve conter informações adicionais.
messaging/invalid-payload Um objeto de payload de mensagem inválido foi fornecido. A mensagem de erro deve conter informações adicionais.
messaging/invalid-data-payload-key O payload da mensagem de dados contém uma chave inválida. Consulte a documentação de referência de DataMessagePayload para mais detalhes sobre chaves restritas.
messaging/payload-size-limit-exceeded O payload da mensagem fornecido excede os limites de tamanho do FCM. O limite é de 4.096 bytes para a maioria das mensagens. Para mensagens enviadas para tópicos, o limite é de 2.048 bytes. O tamanho do payload total inclui chaves e valores.
messaging/invalid-options Um objeto de opções de mensagem inválido foi fornecido. A mensagem de erro deve conter informações adicionais.
messaging/invalid-registration-token Um token de registro inválido foi fornecido. Verifique se ele corresponde ao token de registro que o app cliente recebe a partir do registro no FCM. Não faça truncagem nem adicione caracteres adicionais a ele.
messaging/registration-token-not-registered O token de registro fornecido não está registrado. Um token de registro anteriormente válido pode não ter sido registrado por várias razões, incluindo:
  • O app cliente não se registrou a partir do FCM.
  • O app cliente foi automaticamente cancelado. Isso pode acontecer se o usuário desinstala o app ou, no iOS, se o Serviço de feedback APNS informou o token APNS como inválido.
  • O token de registro expirou. Por exemplo, o Google pode decidir atualizar tokens de registro, ou o token APNS pode ter expirado para dispositivos iOS.
  • O app cliente foi atualizado, mas a nova versão não está configurada para receber mensagens.
Para todos esses casos, remova o token de registro e pare de usá-lo no envio de mensagens.
messaging/invalid-package-name A mensagem foi encaminhada a um token de registro e o nome do pacote dele não coincide com a opção restrictedPackageName fornecida.
messaging/message-rate-exceeded A taxa de mensagens para um determinado destino é muito alta. Reduza o número de mensagens enviadas a esse dispositivo e não tente reenviar mensagens ao mesmo dispositivo imediatamente.
messaging/device-message-rate-exceeded A taxa de mensagens para um determinado dispositivo é muito alta. Reduza o número de mensagens enviadas a esse dispositivo e não tente reenviar mensagens a esse dispositivo imediatamente.
messaging/topics-message-rate-exceeded A taxa de mensagens para assinantes de um determinado tópico está muito alta. Reduza o número de mensagens enviadas a esse tópico e não tente reenviar mensagens a esse tópico imediatamente.
messaging/too-many-topics Um token de registro foi inscrito no número máximo de tópicos e não pode mais haver inscrições.
messaging/invalid-apns-credentials Uma mensagem direcionada a um dispositivo iOS não conseguiu ser enviada porque o certificado obrigatório de SSL de APNs não foi carregado ou expirou. Verifique a validade de seus certificados de desenvolvimento e produção.
messaging/mismatched-credential A credencial utilizada para autenticar esse SDK não tem permissão para enviar mensagens ao dispositivo correspondente ao token de registro fornecido. Verifique se o token de registro e a credencial pertencem ao mesmo projeto do Firebase. Consulte Adicionar Firebase ao seu app para ver uma documentação sobre como autenticar os SDKs Admin do Firebase.
messaging/authentication-error O SDK não conseguiu se autenticar com os servidores do FCM. Autentique o SDK Admin do Firebase com uma credencial que tenha as permissões adequadas para enviar mensagens do FCM. Consulte Adicionar Firebase ao seu app para ver uma documentação sobre como autenticar os SDKs Admin do Firebase.
messaging/server-unavailable O servidor do FCM não conseguiu processar a solicitação a tempo. Repita o mesmo pedido, mas você precisa:
  • respeitar o cabeçalho Retry-After se ele estiver incluído na resposta do servidor de conexão do FCM;
  • implementar uma retirada exponencial no mecanismo de nova tentativa. Por exemplo, se você esperou um segundo antes da primeira nova tentativa, aguarde pelo menos dois segundos antes da próxima, depois quatro segundos e assim por diante. Se você estiver enviando várias mensagens, atrase cada uma de maneira independente por um período aleatório adicional para evitar emitir uma nova solicitação a todas as mensagens ao mesmo tempo.
Os remetentes que causam problemas podem ser incluídos em listas negras.
messaging/internal-error O servidor do FCM encontrou um erro ao tentar processar a solicitação. Repita a mesma solicitação seguindo os requisitos listados na linha messaging/server-unavailable acima. Se o erro persistir, informe o problema ao nosso canal de suporte pelo Relatório de bugs.
messaging/unknown-error Um erro de servidor desconhecido foi retornado. Veja a resposta do servidor bruto na mensagem de erro para saber mais. Se você receber esse erro, informe a mensagem completa no nosso canal de suporte Relatório de bugs.

Enviar mensagens usando os protocolos do servidor de apps legados

Se você preferir usar os protocolos legados, crie solicitações de mensagens como as mostradas nesta seção. Tenha em mente que, se você estiver enviando para várias plataformas via HTTP, o protocolo v1 pode simplificar as solicitações de mensagens.

Enviar mensagens a dispositivos específicos

Para enviar mensagens a dispositivos específicos, defina a chave to como o token de registro da instância de app. Consulte as informações de configuração do cliente da sua plataforma para saber mais sobre esses tokens.

Solicitação HTTP POST

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA

{ "data": {
    "score": "5x1",
    "time": "15:10"
  },
  "to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
}

Resposta HTTP

{ "multicast_id": 108,
  "success": 1,
  "failure": 0,
  "results": [
    { "message_id": "1:08" }
  ]
}

Mensagem XMPP

<message id="">
  <gcm xmlns="google:mobile:data">
    { "data": {
      "score": "5x1",
      "time": "15:10"
    },
    "to" : "bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1..."
  }
  </gcm>
</message>

Resposta XMPP

<message id="">
  <gcm xmlns="google:mobile:data">
  {
      "from":"REGID",
      "message_id":"m-1366082849205"
      "message_type":"ack"
  }
  </gcm>
</message>

No servidor de conexão XMPP, há outras opções de resposta. Consulte Formato de resposta do servidor.

Para ver a lista completa de opções de mensagens disponíveis ao enviar mensagens downstream a aplicativos cliente, consulte as informações de referência do protocolo do servidor de conexão selecionado, HTTP ou XMPP.

Enviar mensagens a tópicos

O envio de mensagens a um tópico do Firebase Cloud Messaging é muito semelhante ao envio a um dispositivo individual ou a um grupo de usuários. O servidor do app define a chave to com um valor como /topics/yourTopic. Os desenvolvedores podem escolher um nome de tópico que corresponda à expressão regular: "/topics/[a-zA-Z0-9-_.~%]+".

Para enviar a combinações de vários tópicos, a chave condition (em vez da chave to) precisa ser definida como uma condição booleana que especifica os tópicos de destino no servidor de apps. Por exemplo, para enviar mensagens para dispositivos que se inscreveram no TopicA e também no TopicB ou TopicC:

'TopicA' in topics && ('TopicB' in topics || 'TopicC' in topics)

Primeiramente, o FCM avalia todas as condições entre parênteses. Em seguida, ele avalia a expressão da esquerda para a direita. Na expressão acima, um usuário que se inscreveu em um só tópico não receberá a mensagem. Do mesmo modo, um usuário que não se inscreveu no TopicA também não receberá a mensagem. As seguintes combinações receberão a mensagem:

  • TopicA e TopicB
  • TopicA e TopicC

Inclua até cinco tópicos em sua expressão condicional, e parênteses são aceitos. Operadores aceitos: &&, ||, !. Observe o uso para !:

!('TopicA' in topics)

Com essa expressão, todas as instâncias do app que não estão inscritas no TopicA recebem a mensagem, inclusive as que não estão inscritas em nenhum tópico.

Para ver mais detalhes sobre as chaves do servidor do app, consulte as informações de referência do protocolo do servidor de conexão selecionado, HTTP ou XMPP. Veja nesta página exemplos de como enviar mensagens para tópicos nesses protocolos.

Solicitação HTTP POST de tópico

Enviar para um único tópico:

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA

Enviar para dispositivos inscritos nos tópicos "dogs" ou "cats":

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA

Resposta HTTP de tópico

//Success example:
{
  "message_id": "1023456"
}

//failure example:
{
  "error": "TopicsMessageRateExceeded"
}

Mensagem XMPP de tópico

Enviar para um único tópico:

<message id="">
  <gcm xmlns="google:mobile:data">

  </gcm>
</message>

Enviar para dispositivos inscritos nos tópicos "dogs" ou "cats":

<message id="">
  <gcm xmlns="google:mobile:data">

  </gcm>
</message>

Resposta XMPP de tópico

//Success example:
{
  "message_id": "1023456"
}

//failure example:
{
  "error": "TopicsMessageRateExceeded"
}

Aguarde até 30 segundos para que o servidor de conexão do FCM retorne uma resposta de êxito ou falha para as solicitações de envio de tópico. Defina corretamente o valor de tempo limite do servidor de apps na solicitação.

Para ver a lista completa de opções de mensagens, consulte as informações de referência do protocolo do servidor de conexão selecionado, HTTP ou XMPP.

Como enviar mensagens para grupos de dispositivos

Enviar mensagens para um grupo de dispositivos é similar ao envio para um dispositivo individual. Defina o parâmetro to como a chave de notificação exclusiva do grupo. Consulte Tipos de mensagem para detalhes sobre suporte a payload. Nos exemplos desta página, você vê como enviar mensagens de dados para esses grupos de dispositivos nos protocolos HTTP e XMPP.

Solicitação HTTP POST para grupo de dispositivos

https://fcm.googleapis.com/fcm/send
Content-Type:application/json
Authorization:key=AIzaSyZ-1u...0GBYzPu7Udno5aA

{
  "to": "aUniqueKey",
  "data": {
    "hello": "This is a Firebase Cloud Messaging Device Group Message!",
   }
}

Resposta HTTP do grupo de dispositivos

Este é um exemplo de êxito na operação: a notification_key tem dois tokens de registro associados a ela e a mensagem foi enviada a ambos:

{
  "success": 2,
  "failure": 0
}

Este é um exemplo de êxito parcial na operação: a notification_key tem três tokens de registro associados a ela. A mensagem foi enviada apenas para um dos tokens de registro. A resposta lista os tokens onde houve falha ao receber a mensagem:

{
  "success":1,
  "failure":2,
  "failed_registration_ids":[
     "regId1",
     "regId2"
  ]
}

Quando uma mensagem não é entregue a um ou mais tokens de registro associados a uma notification_key, o servidor de apps faz uma nova tentativa com um intervalo de espera entre elas.

Se o servidor tenta enviar uma mensagem para um grupo de dispositivos que não tem membros, a resposta é parecida com esta, com 0 sucesso e 0 falha:

{
  "success": 0,
  "failure": 0
}

Mensagem XMPP para grupo de dispositivos

<message id="">
  <gcm xmlns="google:mobile:data">
  {
      "to": "aUniqueKey",
      "message_id": "m-1366082849205" ,
      "data": {
          "hello":"This is a Firebase Cloud Messaging Device Group Message!"
      }
  }
  </gcm>
</message>

Resposta XMPP do grupo de dispositivos

Quando a mensagem é enviada com sucesso para qualquer um dos dispositivos do grupo, o servidor de conexões XMPP responde com um ACK. Quando ocorre falha no envio de todas as mensagens a todos os dispositivos do grupo, o servidor responde com um NACK.

Este é um exemplo de êxito na operação: a notification_key tem três tokens de registro associados a ela e a mensagem foi enviada a todos:

{
  "from": "aUniqueKey",
  "message_type": "ack",
  "success": 3,
  "failure": 0,
  "message_id": "m-1366082849205"
}

Este é um exemplo de êxito parcial na operação: a notification_key tem três tokens de registro associados a ela. A mensagem foi enviada apenas para um dos tokens de registro. A resposta lista os tokens onde houve falha ao receber a mensagem:

{
  "from": "aUniqueKey",
  "message_type": "ack",
  "success":1,
  "failure":2,
  "failed_registration_ids":[
     "regId1",
     "regId2"
  ]
}

Quando um servidor de conexão FCM não entrega para todos os dispositivos no grupo, o servidor do app receberá uma resposta NACK.

Para ver a lista completa de opções de mensagens, consulte as informações de referência relacionadas ao protocolo do servidor de conexão selecionado, HTTP ou XMPP.

Métodos de envio legados do SDK Admin do Firebase

O SDK Admin para Node.js do Firebase é compatível com métodos de entrega de mensagens (FCM) baseados na API do servidor FCM legado. Esses métodos aceitam argumentos diferentes em comparação com o método send(). Use o método send() sempre que possível e utilize os métodos descritos nesta página apenas ao enviar mensagens para dispositivos individuais ou grupos de dispositivos.

Enviar para dispositivos individuais

É possível transmitir um token de registro ao método sendToDevice() para enviar uma mensagem a esse dispositivo:

Node.js

// This registration token comes from the client FCM SDKs.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the device corresponding to the provided
// registration token.
admin.messaging().sendToDevice(registrationToken, payload)
  .then(function(response) {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });

O método sendToDevice() também pode enviar uma mensagem multicast (ou seja, para vários dispositivos) ao transmitir uma matriz de tokens de registro, em vez de apenas um único token de registro:

Node.js

// These registration tokens come from the client FCM SDKs.
var registrationTokens = [
  'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...',
  // ...
  'ecupwIfBy1w:APA91bFtuMY7MktgxA3Au_Qx7cKqnf...'
];

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the devices corresponding to the provided
// registration tokens.
admin.messaging().sendToDevice(registrationTokens, payload)
  .then(function(response) {
    // See the MessagingDevicesResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });

O método sendToDevice() retorna uma promessa que é resolvida com um objeto MessagingDevicesResponse contendo a resposta do FCM. O tipo de retorno tem o mesmo formato, seja para transmitir um único token de registro ou uma matriz.

Alguns casos, como um erro de autenticação ou limitação de taxa, fazem com que a totalidade da mensagem não seja processada. Nesses casos, a promessa retornada pelo sendToDevice() é rejeitada com um erro. Para ver uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da Admin FCM API.

Enviar para um grupo de dispositivos

Com as mensagens para grupos de dispositivos, é possível adicionar vários dispositivos a um único grupo. Esse processo é semelhante ao das mensagens de tópico, mas inclui a autenticação para garantir que a associação ao grupo seja gerenciada apenas pelos seus servidores. Por exemplo, se você quiser enviar mensagens diferentes para diferentes modelos de smartphone, seus servidores poderão adicionar/remover registros dos respectivos grupos e enviar a mensagem relevante para cada um deles. A diferença entre as mensagens para grupos de dispositivos e as mensagens de tópico é que, no primeiro caso, o gerenciamento de grupos de dispositivos é feito a partir dos seus servidores em vez de diretamente no aplicativo.

É possível usar as mensagens para grupos de dispositivos por meio dos protocolos XMPP ou HTTP legados no servidor de aplicativos. O SDK Admin do Firebase para Node.js baseado nos protocolos legados também oferece recursos de mensagens de grupo de dispositivos. O número máximo permitido de membros em uma chave de notificação é 20.

Crie grupos de dispositivos e gerar chaves de notificação por meio de um servidor de aplicativos ou de um cliente Android. Consulte Gerenciar grupos de dispositivos para ver detalhes.

Com o sendToDeviceGroup(), é possível enviar uma mensagem para um grupo de dispositivos ao especificar a chave de notificação para ele:

Node.js

// See the "Managing device groups" link above on how to generate a
// notification key.
var notificationKey = 'some-notification-key';

// See the "Defining the message payload" section below for details
// on how to define a message payload.
var payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

// Send a message to the device group corresponding to the provided
// notification key.
admin.messaging().sendToDeviceGroup(notificationKey, payload)
  .then(function(response) {
    // See the MessagingDeviceGroupResponse reference documentation for
    // the contents of response.
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });

O método sendToDeviceGroup() retorna uma promessa que é resolvida com um objeto MessagingDeviceGroupResponse contendo a resposta do FCM.

Alguns casos, como um erro de autenticação ou limitação de taxa, fazem com que a totalidade da mensagem não seja processada. Nesses casos, a promessa retornada pelo sendToDeviceGroup() é rejeitada com um erro. Para ver uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da Admin FCM API.

Definir o payload da mensagem

Os métodos acima baseados nos métodos legados do FCM aceitam um payload da mensagem como segundo argumento e aceitam mensagens de notificação e de dados. Especifique um ou ambos os tipos de mensagens criando um objeto com as chaves de data e/ou notification. Por exemplo, veja como definir diferentes tipos de payloads de mensagens:

Mensagem de notificação

var payload = {
  notification: {
    title: '$GOOG up 1.43% on the day',
    body: '$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.'
  }
};

Mensagem de dados

var payload = {
  data: {
    score: '850',
    time: '2:45'
  }
};

Mensagem combinada

var payload = {
  notification: {
    title: '$GOOG up 1.43% on the day',
    body: '$GOOG gained 11.80 points to close at 835.67, up 1.43% on the day.'
  },
  data: {
    stock: 'GOOG',
    open: '829.62',
    close: '635.67'
  }
};

Os payloads das mensagens de notificação têm um subconjunto predefinido de propriedades válidas e diferem ligeiramente, dependendo de qual sistema operacional móvel você tem por objetivo. Para ver uma lista completa, consulte a documentação de referência de NotificationMessagePayload.

Os payloads das mensagens de dados são compostos por pares de chave-valor personalizados com algumas restrições, incluindo o fato de que todos os valores precisam ser strings. Para ver uma lista completa de restrições, consulte a documentação de referência de DataMessagePayload.

Definir as opções de mensagem

Os métodos acima baseados nos protocolos legados do FCM aceitam um terceiro argumento opcional que especifica algumas opções para a mensagem. Veja no exemplo a seguir o envio de uma mensagem de alta prioridade que expira após 24 horas a um dispositivo:

Node.js

// This registration token comes from the client FCM SDKs.
var registrationToken = 'bk3RNwTe3H0:CI2k_HHwgIpoDKCIZvvDMExUdFQ3P1...';

// See the "Defining the message payload" section above for details
// on how to define a message payload.
var payload = {
  notification: {
    title: 'Urgent action needed!',
    body: 'Urgent action is needed to prevent your account from being disabled!'
  }
};

// Set the message as high priority and have it expire after 24 hours.
var options = {
  priority: 'high',
  timeToLive: 60 * 60 * 24
};

// Send a message to the device corresponding to the provided
// registration token with the provided options.
admin.messaging().sendToDevice(registrationToken, payload, options)
  .then(function(response) {
    console.log('Successfully sent message:', response);
  })
  .catch(function(error) {
    console.log('Error sending message:', error);
  });

Para ver uma lista completa das opções disponíveis, consulte a documentação de referência de MessagingOptions.