Como enviar e receber SMS com o Firebase Functions (Tutorial)

Este artigo foi atualizado em outubro de 2025

A plataforma Firebase permite que os desenvolvedores criem rapidamente o back-end de um aplicativo. Além disso, é muito agradável de usar. Para este tutorial, eu quis começar a usá-la para enviar mensagens SMS com Vonage. A seguir, vou mostrar como receber e enviar mensagens SMS usando o Firebase. Depois de concluir essas etapas, você poderá criar um registro de mensagens SMS e enviar uma resposta ao remetente usando o o Firebase Cloud Functions e o Realtime Database, juntamente com a SMS API da Vonage.

Esta postagem do blog utiliza a 1ª geração do Firebase; você também pode aprender a enviar mensagens SMS com o Cloud Functions para Firebase de 2ª geração aqui.

Você pode ver o código completo no GitHub.

Você também pode encontrar este tutorial em formato de Video:

Antes de começar

Você vai precisar de alguns itens para começar — então, reserve um momento para verificar se já tem os dois à mão.

• A conta do Firebase Account.

Este tutorial tem três seções principais:

• Primeiro, vamos mostrar como configurar o Firebase para o seu projeto.

• A seguir, vamos mostrar como criar uma função para receber mensagens SMS no Firebase.

• Por fim, vamos abordar como criar uma função que envie mensagens SMS no Firebase.

Configurando o Firebase

O primeiro passo é criar um projeto no Firebase. A seguir, vamos mostrar como criar um novo projeto usando o console do Firebase.

Criar o projeto do Firebase

1. Acesse o console do Firebase

2. Clique em “Adicionar projeto”, insira o nome do projeto e clique em “Continuar”.

Create a Project

1. Não vamos usar o Google Analytics neste projeto, mas fique à vontade para adicioná-lo, se quiser, e, em seguida, clique em “Criar projeto” (caso tenha sido adicionado).

Add analytics

3. Aguarde um pouco até que o projeto seja criado — isso leva menos de um minuto.

4. Defina o tipo de cobrança em ⚙️ -> Uso e cobrança -> Detalhes e configurações para Blaze. O plano pré-pago é necessário para usar uma API de terceiros. Mais detalhes sobre o faturamento com o Google.

1. Change Billing

2. Defina o Google Cloud Platform (GCP) resource location em ⚙️ -> Project Settings.

   Update Location

Instalar as ferramentas do Firebase

Quase tudo o que você precisará fazer com o Firebase pode ser feito diretamente da linha de comando, usando o conjunto de ferramentas que eles oferecem.

1. Instale as ferramentas do Firebase usando o npm.

1. Faça login no Firebase usando firebase login. O processo de login abrirá seu navegador para autenticação.

Configurar o ambiente local

Escrever funções na nuvem para o Firebase exige algum trabalho de inicialização para começar, mas a maior parte desse trabalho é feita automaticamente por meio dos comandos do Firebase Tools.

1. Crie uma pasta de projeto mkdir vonage-project && cd vonage-project.

2. Inicializar o Cloud Functions para o Firebase firebase init functions.

######## #### ########  ######## ########     ###     ######  ########
     ##        ##  ##     ## ##       ##     ##  ##   ##  ##       ##
     ######    ##  ########  ######   ########  #########  ######  ######
     ##        ##  ##    ##  ##       ##     ## ##     ##       ## ##
     ##       #### ##     ## ######## ########  ##     ##  ######  ########

You're about to initialize a Firebase project in this directory:

 /your_folders/your-project-name


=== Project Setup

First, let's associate this project directory with a Firebase project.
You can create multiple project aliases by running firebase use --add,
but for now, we'll just set up a default project.

? Please select an option: (Use arrow keys)
❯ Use an existing project
 Create a new project
 Add Firebase to an existing Google Cloud Platform project
 Don't set up a default project

Como você já criou um projeto no painel, pode selecionar Use an existing project , o que solicitará que você escolha o projeto desejado. Se ainda não tiver feito isso, use Create a new project e dê a ele um nome exclusivo para criar um. Você ainda precisaria acessar o console para atualizar a localização e o faturamento, mas essa é outra opção para criar projetos do Firebase.

1. Selecione o nome do projeto que você criou.

2. Selecione JavaScript.

3. Escolha “Y” para o ESLint, se desejar (eu recomendo).

4. Instale todas as dependências agora.

Essas etapas criarão as pastas e os arquivos necessários para compilar o Firebase Functions e instalar todas as dependências. Assim que o NPM terminar, vá para o functions diretório e abra index.js no seu editor preferido para começar a adicionar código.

Crie uma função do Firebase para receber mensagens SMS

A primeira função que você criar atuará como um webhook para capturar e registrar as mensagens SMS recebidas da Vonage. Essa função permitirá que você receba mensagens de texto SMS por meio do Firebase.

O index.js arquivo contém alguns exemplos de código que você não vai precisar. Apague tudo e comece do início para adicionar o código a seguir:

const functions = require("firebase-functions/v1");

const admin = require("firebase-admin");

const serviceAccount = require("./serviceAccountKey.json");

// Initialize Firebase app for database access
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  databaseURL: "https://name_of_the_database.europe-west1.firebasedatabase.app",
});

A chamada admin.initializeApp(); permite que as funções leiam e gravem no banco de dados Firebase Real-Time.

Você também precisa criar uma Conta de Serviço para o seu projeto e adicionar sua databaseURL que pode ser encontrada na aba “Realtime Database” do seu projeto do Firebase.

Em seguida, use o método a seguir para criar sua função.

// This function will serve as the webhook for incoming SMS messages,
// and will log the message into the Firebase Realtime Database
exports.inboundSMS = functions.https.onRequest(async (req, res) => {
  let params;
  if (Object.keys(req.query).length === 0) {
    params = req.body;
  } else {
    params = req.query;
  }
  await admin.database().ref('/msgq').push(params);
  res.sendStatus(200);
});

O inboundSMS método monitora solicitações HTTPS — que é exatamente o que o webhook da Vonage precisa. A função do Firebase irá capturar a req.body caso seja um POST Method ou o req.query caso seja um GET Method. Em seguida, ela o envia para o /msgq objeto no Banco de Dados em Tempo Real como um registro.

Agora que você já escreveu um pouco de código, não se esqueça de salvar seu arquivo e implantar a função no Firebase:

firebase deploy --only functions

=== Deploying to 'vonage-project'...

i deploying functions
Running command: npm --prefix "$RESOURCE_DIR""

> functions@ lint /Users/kellyjandrews/Google Drive/Apps/vonage-project/functions
> eslint .

✔ functions: Finished running predeploy script.
i functions: ensuring necessary APIs are enabled...
✔ functions: all necessary APIs are enabled
i functions: preparing functions directory for uploading...
i functions: packaged functions (38.78 KB) for uploading
✔ functions: functions folder uploaded successfully
i functions: creating Node.js 18 function inboundSMS(us-central1)...
✔ functions[inboundSMS(us-central1)]: Successful create operation.
Function URL (inboundSMS): https://us-central1-vonage-project.cloudfunctions.net/inboundSMS

✔ Deploy complete!

Project Console: https://console.firebase.google.com/project/vonage-project/overview

A parte essencial do resultado é Function URL (inboundSMS). Essa URL é necessária para configurar o webhook no Vonage, o que você fará a seguir.

No configurações do painel do Vonage, certifique-se de que está usando a SMS API, selecione post e copie a URL da função de saída (SMS recebido) do console do terminal e cole-a no webhook do Vonage.

Vonage Dashboard SettingsPegue seu celular e envie uma mensagem para o número de telefone. Abra o console do Firebase e acesse a database página, e você deverá ver algo assim:

Real-time Database Vonage Message Entry

Agora que existe uma maneira de registrar as mensagens recebidas, você pode criar uma função para realizar alguma ação com a mensagem recebida.

Crie uma função do Firebase para enviar mensagens SMS

Até agora, você criou uma função do Firebase vinculada a um número de telefone da Vonage para capturar mensagens SMS recebidas. As funções do Firebase também podem reagir a atualizações no banco de dados. Quando há uma nova entrada, o código envia um eco do texto original.

A seguir, vamos mostrar como criar uma função no Firebase que envia mensagens de texto por SMS.

Comece adicionando o Vonage à lista de dependências — certifique-se de fazer isso no functions diretório:

Em seguida, adicione o dotenv à lista de dependências.

Crie um .env arquivo e adicione as variáveis de ambiente no functions diretório:

Você pode usar o `dot env` ou adicionar as seguintes variáveis de ambiente à configuração do Firebase:

Em seguida, abra index.js adicionar @vonage/server-sdk aos requisitos na parte superior e importe as variáveis de ambiente para inicializar o Vonage:

require("dotenv").config();

const functions = require("firebase-functions/v1");
const admin = require("firebase-admin");
const { Vonage } = require("@vonage/server-sdk");

const serviceAccount = require("./serviceAccountKey.json");

admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  databaseURL: "https://name_of_the_database.region.firebasedatabase.app",
});

// If you are using .env
const vonage = new Vonage({
  apiKey: process.env.VONAGE_API_KEY,
  apiSecret: process.env.VONAGE_API_SECRET,
});

// If you are using the Firebase Environment Variables
const {
  api_key,
  api_secret
} = functions.config().vonage;

Agora você pode criar a nova função no Firebase para enviar a resposta:

// This function listens for updates to the Firebase Realtime Database
// and sends a message back to the original sender
exports.sendSMS = functions.database
  .ref("/msgq/{pushId}")
  .onCreate(async (message) => {
    const { msisdn, text, to } = message.val();

    const resultSnapshot = await message.ref.parent
      .child("result")
      .once("value");
    if (resultSnapshot.exists()) {
      console.log("Result already exists. Exiting function.");
      return;
    }

    try {
      const responseData = await vonage.sms.send({
        to: to,
        from: msisdn,
        text: `You sent the following text: ${text}`,
      });

      if (responseData.messages && responseData.messages[0].status === "0") {
        const result = `You sent the following text: 
 ${responseData.messages[0]["message-id"]}`;
        await message.ref.parent.child("result").set(result);
        console.log(result);
        return result;
      } else {
        const errorText =
          (responseData.messages && responseData.messages[0]["error-text"]) ||
          "Unknown error";
        const errorMessage = `Message failed with error: ${errorText}`;
        console.error(errorMessage);
        return errorMessage;
      }
    } catch (err) {
      console.error("Vonage error:", err);
      return `Vonage error: ${err.message}`;
    }
  });

A nova função ficará atenta às novas mensagens adicionadas ao /msgq objeto do banco de dados. Quando acionada, o objeto Vonage completo é passado como message. Esse objeto inclui msisdn, que é o número de telefone de origem — o seu, neste caso — e o to número, que é o número virtual da Vonage que você adquiriu.

Com os números de telefone em mãos, além da mensagem de texto, agora você pode fazer várias coisas. Você pode criar uma tabela de consulta para responder com dados específicos com base na palavra-chave, encaminhá-la para outro sistema ou, no nosso caso, enviar a mensagem original.

Implemente as Funções do Firebase novamente a partir da linha de comando:

firebase deploy --only functions

Pegue seu celular, envie outra mensagem e, então, você deve receber uma resposta mais ou menos assim You sent the following text: A text message sent using the Vonage SMS API.

Conclusão

Você já concluiu todas as etapas deste tutorial. Você pode ver o código completo no GitHub.

Agora que as etapas iniciais para enviar e receber mensagens estão concluídas, minhas próximas postagens irão aprofundar esse conceito, abordando o controle de alguns dos sistemas de automação residencial por meio de mensagens de texto.

Leitura complementar

• Detalhes sobre Funcionalidade de SMS da Vonage

• Introdução ao Firebase Functions

• Como adicionar a autenticação de dois fatores (2FA) a um aplicativo React usando o Firebase Functions

• Assista à versão Video deste tutorial

• Enviar e receber mensagens SMS com o Cloud Functions