Inviare un messaggio utilizzando l'SDK Firebase Admin

Se non hai ancora configurato Firebase Admin SDK già, segui la guida per configurare Firebase Admin SDK sul tuo server.

Abilitare l'API HTTP v1 di FCM

1. Nella Firebase console, vai a Impostazioni > Generali. Poi, fai clic sulla scheda Cloud Messaging.

2. Abilita l'API Cloud Messaging.

Autorizzare un service account di un altro progetto

Puoi inviare messaggi per un progetto, il "progetto di destinazione", utilizzando un service account in un altro progetto, il "progetto mittente". In questo modo puoi centralizzare la gestione dei service account in un unico progetto, inviando messaggi per conto di altri. Per farlo, segui questi passaggi:

1. Nel progetto mittente, assicurati che l'API Firebase Cloud Messaging sia abilitata. Verifica se è abilitata nella Firebase console andando a Impostazioni > Generali. Poi, fai clic sulla scheda Cloud Messaging.

2. Nel progetto mittente, crea un service account.

3. Nel progetto di destinazione, assegna il ruolo Amministratore dell'API Firebase Cloud Messaging all'indirizzo email del service account. Puoi farlo nella pagina IAM e amministrazione > IAM della console Google Cloud. Questo ruolo consente al service account del progetto mittente di inviare messaggi al progetto di destinazione.

4. Inizializza l'SDK con il file della chiave del service account del progetto mittente e l'ID progetto del progetto di destinazione.

   Node.js

   import { initializeApp, applicationDefault } from 'firebase-admin/app';
   
   initializeApp({
     // The credential is configured to be the sender project's service
     // account key via the environment variable GOOGLE_APPLICATION_CREDENTIALS
     credential: applicationDefault(),
     projectId: '<TARGET_PROJECT_ID>',
   });
   

   Java

   FirebaseOptions options = FirebaseOptions.builder()
       // The credential is configured to be the sender project's service
       // account key via the environment variable GOOGLE_APPLICATION_CREDENTIALS
       .setCredentials(GoogleCredentials.getApplicationDefault())
       .setProjectId("<TARGET_PROJECT_ID>")
       .build();
   
   FirebaseApp.initializeApp(options);
   

   Python

   import firebase_admin
   
   app_options = {'projectId': '<TARGET_PROJECT_ID>'}
   # Initialize with the default credential, i.e. the sender project's service
   # account key, stored in GOOGLE_APPLICATION_CREDENTIALS
   default_app = firebase_admin.initialize_app(options=app_options)
   

   Vai

   config := &firebase.Config{ProjectID: "<TARGET_PROJECT_ID>"}
   // Initialize with the default credential, i.e. the sender project's service
   // account key, stored in GOOGLE_APPLICATION_CREDENTIALS
   app, err := firebase.NewApp(context.Background(), config)
   if err != nil {
           log.Fatalf("error initializing app: %v\n", err)
   }
   

   C#

   FirebaseApp.Create(new AppOptions()
   {
       // The credential is configured to be the sender project's service
       // account key via the environment variable GOOGLE_APPLICATION_CREDENTIALS
       Credential = GoogleCredential.GetApplicationDefault(),
       ProjectId = "<TARGET_PROJECT_ID>",
   });
   

Inviare messaggi a dispositivi specifici

Per inviare messaggi a un singolo dispositivo specifico, puoi scegliere come target il suo Firebase ID di installazione (FID) o il suo token di registrazione.

Nota: durante il periodo di migrazione, il campo token accetta anche i FID. Tuttavia, poiché il campo token è deprecato e verrà rimosso, ti consigliamo di utilizzare il campo fid una volta che i client sono registrati utilizzando gli ID di installazione Firebase.

Node.js

Utilizzo del FID (consigliato):

// This installation ID comes from the client FCM SDKs.
const fid = 'YOUR_REGISTERED_FID';

const message = {
  data: {
    score: '850',
    time: '2:45'
  },
  fid: fid
};

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

Utilizzo del token di registrazione (deprecato):

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

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

// Send a message to the device corresponding to the provided
// registration token.
getMessaging().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

Utilizzo del FID (consigliato):

// This installation ID comes from the client FCM SDKs.
String fid = "YOUR_REGISTERED_FID";

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

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

Utilizzo del token di registrazione (deprecato):

// 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);
FirebaseMessagingSnippets.java

Python

Utilizzo del FID (consigliato):

# This installation ID comes from the client FCM SDKs.
fid = 'YOUR_REGISTERED_FID'

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

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

Utilizzo del token di registrazione (deprecato):

# 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)
cloud_messaging.py

Vai

Utilizzo del FID (consigliato):

// 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 installation ID comes from the client FCM SDKs.
fid := "YOUR_REGISTERED_FID"

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

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

Utilizzo del token di registrazione (deprecato):

// 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)
messaging.go

C#

Utilizzo del FID (consigliato):

// This installation ID comes from the client FCM SDKs.
var fid = "YOUR_REGISTERED_FID";

var message = new Message()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Fid = fid,
};

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

Utilizzo del token di registrazione (deprecato):

            // 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" },
                },
#pragma warning disable CS0618
                Token = registrationToken,
#pragma warning restore CS0618
            };

            // 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);

Se l'operazione va a buon fine, ogni metodo di invio restituisce un ID messaggio. Il Firebase Admin SDK restituisce la stringa ID nel formato projects/{project_id}/messages/{message_id}.

Inviare un messaggio a più dispositivi

Gli SDK Admin FCM consentono di inviare un messaggio multicast a un elenco di ID di installazione Firebase (FID) o token di registrazione del dispositivo. Puoi utilizzare questa funzionalità quando devi inviare lo stesso messaggio a un numero elevato di dispositivi. Puoi specificare fino a 500 FID e/o token per chiamata.

Nota: durante il periodo di migrazione, il campo tokens accetta anche i FID. Tuttavia, poiché il campo token è deprecato e verrà rimosso, ti consigliamo di utilizzare il campo fid una volta che i client sono registrati utilizzando gli ID di installazione Firebase.

Il valore restituito include un elenco di risposte che corrisponde all'ordine dei target di input, FID e/o token. Questa opzione è utile quando vuoi controllare quali target hanno generato errori. Se vengono forniti sia token che FID, i token vengono elaborati per primi, seguiti dai FID.

Node.js

Utilizzo dei FID (consigliato):

// These Firebase Installation IDs (FIDs) come from the client FCM SDKs.
const fids = [
  'YOUR_REGISTERED_FID_1',
  // ...
  'YOUR_REGISTERED_FID_N'
];

const message = {
  data: {score: '850', time: '2:45'},
  fids: fids,
};

getMessaging().sendEachForMulticast(message)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
    if (response.failureCount > 0) {
      const failedFids = [];
      response.responses.forEach((resp, idx) => {
        if (!resp.success) {
          failedFids.push(fids[idx]);
        }
      });
      console.log('List of FIDs that caused failures: ' + failedFids);
    }
  });

Utilizzo dei token di registrazione (deprecato):

// 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,
};

getMessaging().sendEachForMulticast(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

Utilizzo dei FID (consigliato):

// These Firebase Installation IDs (FIDs) come from the client FCM SDKs.
List<String> fids = Arrays.asList(
    "YOUR_REGISTERED_FID_1",
    // ...
    "YOUR_REGISTERED_FID_N"
);

MulticastMessage message = MulticastMessage.builder()
    .putData("score", "850")
    .putData("time", "2:45")
    .addAllFids(fids)
    .build();

BatchResponse response = FirebaseMessaging.getInstance().sendEachForMulticast(message);
if (response.getFailureCount() > 0) {
  List<SendResponse> responses = response.getResponses();
  List<String> failedFids = 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 destination FIDs.
      failedFids.add(fids.get(i));
    }
  }
  System.out.println("List of FIDs that caused failures: " + failedFids);
}

Utilizzo dei token di registrazione (deprecato):

// 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().sendEachForMulticast(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);
}
FirebaseMessagingSnippets.java

Python

Utilizzo dei FID (consigliato):

# These Firebase Installation IDs (FIDs) come from the client FCM SDKs.
fids = [
    'YOUR_REGISTERED_FID_1',
    # ...
    'YOUR_REGISTERED_FID_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    fids=fids,
)
response = messaging.send_each_for_multicast(message)
if response.failure_count > 0:
    responses = response.responses
    failed_fids = []
    for idx, resp in enumerate(responses):
        if not resp.success:
            # The order of responses corresponds to the order of the destination FIDs.
            failed_fids.append(fids[idx])
    print('List of FIDs that caused failures: {0}'.format(failed_fids))

Utilizzo dei token di registrazione (deprecato):

# These registration tokens come from the client FCM SDKs.
registration_tokens = [
    'YOUR_REGISTRATION_TOKEN_1',
    # ...
    'YOUR_REGISTRATION_TOKEN_N',
]

message = messaging.MulticastMessage(
    data={'score': '850', 'time': '2:45'},
    tokens=registration_tokens,
)
response = messaging.send_each_for_multicast(message)
if response.failure_count > 0:
    responses = response.responses
    failed_tokens = []
    for idx, resp in enumerate(responses):
        if not resp.success:
            # The order of responses corresponds to the order of the registration tokens.
            failed_tokens.append(registration_tokens[idx])
    print(f'List of tokens that caused failures: {failed_tokens}')
cloud_messaging.py

Vai

Utilizzo dei FID (consigliato):

// Create a list containing up to 500 Firebase Installation IDs (FIDs).
// These Firebase Installation IDs (FIDs) come from the client FCM SDKs.
fids := []string{
    "YOUR_REGISTERED_FID_1",
    // ...
    "YOUR_REGISTERED_FID_N",
}

message := &messaging.MulticastMessage{
    Data: map[string]string{
        "score": "850",
        "time":  "2:45",
    },
    Fids: fids,
}

br, err := client.SendEachForMulticast(ctx, message)
if err != nil {
    log.Fatalln(err)
}

if br.FailureCount > 0 {
    var failedFids []string
    for idx, resp := range br.Responses {
        if !resp.Success {
            // The order of responses corresponds to the order of the destination FIDs.
            failedFids = append(failedFids, fids[idx])
        }
    }
    fmt.Printf("List of FIDs that caused failures: %v\n", failedFids)
}

Utilizzo dei token di registrazione (deprecato):

// Create a list containing up to 500 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.SendEachForMulticast(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)
}
messaging.go

C#

Utilizzo dei FID (consigliato):

// These Firebase Installation IDs (FIDs) come from the client FCM SDKs.
var fids = new List<string>()
{
    "YOUR_REGISTERED_FID_1",
    // ...
    "YOUR_REGISTERED_FID_N",
};

var message = new MulticastMessage()
{
    Data = new Dictionary<string, string>()
    {
        { "score", "850" },
        { "time", "2:45" },
    },
    Fids = fids,
};

var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(message);

if (response.FailureCount > 0)
{
    var failedFids = 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 destination FIDs.
            failedFids.add(fids[i]);
        }
    }
    Console.WriteLine($"List of FIDs that caused failures: {string.Join(", ", failedFids)}");
}

Utilizzo dei token di registrazione (deprecato):

            // 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()
            {
#pragma warning disable CS0618
                Tokens = registrationTokens,
#pragma warning restore CS0618
                Data = new Dictionary<string, string>()
                {
                    { "score", "850" },
                    { "time", "2:45" },
                },
            };

            var response = await FirebaseMessaging.DefaultInstance.SendEachForMulticastAsync(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}");
            }
FirebaseMessagingSnippets.cs

Inviare un elenco di messaggi

Gli SDK Admin supportano l'invio di un elenco di massimo 500 messaggi. Questa funzionalità può essere utilizzata per creare un insieme personalizzato di messaggi e inviarli a destinatari diversi, inclusi argomenti, ID di installazione Firebase (FID) o token di registrazione del dispositivo. Ad esempio, puoi utilizzare questa funzionalità quando devi inviare messaggi diversi a segmenti di pubblico diversi.

Nota: durante il periodo di migrazione, il campo token accetta anche i FID. Tuttavia, poiché il campo token è deprecato e verrà rimosso, ti consigliamo di utilizzare il campo fid una volta che i client sono registrati utilizzando gli ID di installazione Firebase.

Node.js

Utilizzo di target misti (consigliato):

// Create a list containing up to 500 messages.
const messages = [
  {
    notification: { title: 'Price drop', body: '5% off all electronics' },
    fid: 'YOUR_REGISTERED_FID', // Using FID (Recommended)
  },
  {
    notification: { title: 'Price drop', body: '2% off all books' },
    token: 'YOUR_REGISTRATION_TOKEN', // Using token (Deprecated)
  },
  {
    notification: { title: 'Price drop', body: '10% off all shoes' },
    topic: 'readers-club',
  }
];

getMessaging().sendEach(messages)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
  });

Utilizzo dei token di registrazione (deprecato):

// Create a list containing up to 500 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',
});

getMessaging().sendEach(messages)
  .then((response) => {
    console.log(response.successCount + ' messages were sent successfully');
  });

Java

Utilizzo di target misti (consigliato):

// Create a list containing up to 500 messages.
List<Message> messages = new ArrayList<>();
messages.add(Message.builder()
    .setNotification(Notification.builder()
        .setTitle("Price drop")
        .setBody("5% off all electronics")
        .build())
    .setFid("YOUR_REGISTERED_FID") // Using FID (Recommended)
    .build());
messages.add(Message.builder()
    .setNotification(Notification.builder()
        .setTitle("Price drop")
        .setBody("2% off all books")
        .build())
    .setToken("YOUR_REGISTRATION_TOKEN") // Using token (Deprecated)
    .build());
messages.add(Message.builder()
    .setNotification(Notification.builder()
        .setTitle("Price drop")
        .setBody("10% off all shoes")
        .build())
    .setTopic("readers-club")
    .build());

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

Utilizzo dei token di registrazione (deprecato):

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

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

Python

Utilizzo di target misti (consigliato):

# Create a list containing up to 500 messages.
messages = [
    messaging.Message(
        notification=messaging.Notification('Price drop', '5% off all electronics'),
        fid='YOUR_REGISTERED_FID', # Using FID (Recommended)
    ),
    messaging.Message(
        notification=messaging.Notification('Price drop', '2% off all books'),
        token='YOUR_REGISTRATION_TOKEN', # Using token (Deprecated)
    ),
    messaging.Message(
        notification=messaging.Notification('Price drop', '10% off all shoes'),
        topic='readers-club',
    ),
]

response = messaging.send_each(messages)
# See the BatchResponse reference documentation
# for the contents of response.
print('{0} messages were sent successfully'.format(response.success_count))

Utilizzo dei token di registrazione (deprecato):

# Create a list containing up to 500 messages.
messages = [
    messaging.Message(
        notification=messaging.Notification('Price drop', '5% off all electronics'),
        token=registration_token,
    ),
    # ...
    messaging.Message(
        notification=messaging.Notification('Price drop', '2% off all books'),
        topic='readers-club',
    ),
]

response = messaging.send_each(messages)
# See the BatchResponse reference documentation
# for the contents of response.
print(f'{response.success_count} messages were sent successfully')
cloud_messaging.py

Vai

Utilizzo di target misti (consigliato):

// Create a list containing up to 500 messages.
messages := []*messaging.Message{
    {
        Notification: &messaging.Notification{
            Title: "Price drop",
            Body:  "5% off all electronics",
        },
        Fid: "YOUR_REGISTERED_FID", // Using FID (Recommended)
    },
    {
        Notification: &messaging.Notification{
            Title: "Price drop",
            Body:  "2% off all books",
        },
        Token: "YOUR_REGISTRATION_TOKEN", // Using token (Deprecated)
    },
    {
        Notification: &messaging.Notification{
            Title: "Price drop",
            Body:  "10% off all shoes",
        },
        Topic: "readers-club",
    },
}

br, err := client.SendEach(ctx, 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)

Utilizzo dei token di registrazione (deprecato):

// Create a list containing up to 500 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.SendEach(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)
messaging.go

C#

Utilizzo di target misti (consigliato):

// Create a list containing up to 500 messages.
var messages = new List<Message>()
{
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "5% off all electronics",
        },
        Fid = "YOUR_REGISTERED_FID", // Using FID (Recommended)
    },
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "2% off all books",
        },
        Token = "YOUR_REGISTRATION_TOKEN", // Using token (Deprecated)
    },
    new Message()
    {
        Notification = new Notification()
        {
            Title = "Price drop",
            Body = "10% off all shoes",
        },
        Topic = "readers-club",
    },
};

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

Utilizzo dei token di registrazione (deprecato):

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

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