Ícone do site Mailtrap

SMTP Gmail no Nodemailer: Configuração, Envio de Email e Limitações

Piotr Malek

Vamos diretos ao ponto: você quer enviar emails com Nodemailer e Gmail, e estou aqui para mostrar como fazer isso, passo a passo.

Vou incluir algumas informações adicionais que você pode achar úteis, como as limitações do Gmail e algumas alternativas que você pode usar.

Como enviar emails usando Nodemailer e Gmail SMTP

Aqui está o que você precisará para enviar emails com sua conta do Gmail e Nodemailer:

1. Criando uma senha de app

Para criar uma senha de app, siga estes passos:

Importante: Não se esqueça de armazenar sua senha de app com segurança após gerá-la, pois ela não será mostrada novamente.

2. Configurando seu projeto

Em seguida, vamos preparar a base para nosso backend de envio inicializando o Node.js e criando nosso arquivo package.json que contém metadados importantes sobre o projeto.

Para isso, use o seguinte comando:

npm init -y

Então, vamos instalar o Nodemailer com o comando npm ou Yarn:

npm install nodemailer

# ou

yarn add nodemailer

Finalmente, no diretório do seu projeto, crie um diretório src com um arquivo index.js dentro dele, que conterá nossa configuração do Nodemailer.

Seu diretório de projeto deve ficar algo assim:

3. Configurando Nodemailer para Gmail

E agora, tudo o que resta fazer é inserir suas credenciais do Gmail e a senha de app na configuração do Nodemailer.

Para isso, cole o seguinte snippet de código no arquivo index.js e substitua os placeholders pelas suas credenciais do Gmail e senha de app:

// Importe a biblioteca Nodemailer
const nodemailer = require('nodemailer');

// Crie um objeto transportador
const transporter = nodemailer.createTransport({
  host: 'smtp.gmail.com',
  port: 587,
  secure: false, // use false para STARTTLS; true para SSL na porta 465
  auth: {
    user: 'SEU_ENDERECO_GMAIL',
    pass: 'SUA_SENHA_DE_APP',
  }
});

// Configure o objeto mailOptions
const mailOptions = {
  from: 'seunomeusuario@email.com',
  to: 'seuamigo@email.com',
  subject: 'Enviando Email usando Node.js',
  text: 'Isso foi fácil!'
};

// Envie o email
transporter.sendMail(mailOptions, function(error, info){
  if (error) {
    console.log('Erro:', error);
  } else {
    console.log('Email enviado: ', info.response);
  }
});

Para salvar e executar o script, use o seguinte comando:

node src/index.js

Observe que você pode configurar diferentes tipos de callbacks nas últimas seções do código. Em vez de apenas ser notificado quando uma mensagem falha ao ser entregue, você pode, por exemplo, receber um array incluindo o endereço do destinatário junto com a resposta do servidor. Veja todas as opções disponíveis aqui.

4. Criar variáveis de ambiente (opcional)

Embora este passo seja opcional, é uma das práticas de segurança que sempre recomendo. Nomeadamente, armazenar suas credenciais em variáveis de ambiente é muito mais seguro do que salvá-las diretamente em seu código.

Pense nisso como usar um cofre no banco em vez de guardar seu dinheiro debaixo do colchão. Se alguém invadir sua casa (Deus nos livre), você quer seu dinheiro no banco em vez de em um lugar óbvio para qualquer ladrão amador. 🏦

Tudo o que você precisa fazer é criar um arquivo .env no diretório raiz, que conterá suas variáveis de ambiente.

Em seguida, adicione suas credenciais do Gmail (ou qualquer outra informação sensível) ao seu recém-criado arquivo .env. Por exemplo:

GMAIL_USER=seu-email@gmail.com
GMAIL_PASS=sua-senha-de-app

Proceda instalando o pacote dotenv que será responsável por carregar as variáveis de ambiente do seu arquivo .env para process.env. Para isso, você pode usar o confiável npm:

npm install dotenv

Nota: A partir da versão 20.6.0, o Node.js tem suporte nativo para arquivos .env para configurar variáveis de ambiente. Então, não é necessário usar o pacote dotenv, mas muitos projetos ainda dependem do dotenv, então ainda é o padrão de fato.

Por fim, no seu arquivo index.js (ou onde você decidir configurar o Nodemailer), carregue as variáveis de ambiente no início do arquivo exigindo o dotenv. O início da sua configuração do Nodemailer deve ficar algo assim:

require('dotenv').config();                              // Carregar variáveis de ambiente do arquivo .env
const nodemailer = require('nodemailer');

const transporter = nodemailer.createTransport({
  service: 'gmail',
  auth: {
    user: process.env.GMAIL_USER,             // Seu endereço Gmail do arquivo .env 
    pass: process.env.GMAIL_PASS,             // Sua senha de app do Gmail do arquivo .env
  }
});

// Configure o objeto mailOptions
const mailOptions = {
  from: process.env.GMAIL_USER,               // Endereço do remetente do arquivo .env
  to: 'seuamigo@email.com',
  subject: 'Enviando Email usando Node.js',
  text: 'Isso foi fácil!'
};

// Envie o email
transporter.sendMail(mailOptions, function(error, info){
  if (error) {
    console.log('Erro:', error);
  } else {
    console.log('Email enviado: ', info.response);
  }
});

Enviar emails em HTML

Anteriormente, mostrei como enviar um email de texto simples. No entanto, enviar email HTML no Nodemailer é bastante simples, pois você pode simplesmente adicionar o campo html às opções da mensagem e usar as tags apropriadas (ex: <h1>, <p>, etc.).

Veja:

const mailOptions = {
  from: 'seuemail@email.com',
  to: 'seuamigo@yahoo.com',
  subject: 'Enviar email HTML usando Node.js é moleza',
  text: 'Isso foi fácil!',
  html: '<h1>Bem-vindo</h1><p>Isso foi fácil!</p>'
}

Além de texto e HTML, você também pode adicionar qualquer tipo de dado como conteúdo do corpo principal (como Markdown).

Por exemplo:

let message = {
    ...
    html: '<b>Olá mundo!</b>',
    alternatives: [
        {
            contentType: 'text/x-web-markdown',
            content: '**Olá mundo!**'
        }
    ]
}

Dica: Com o campo alternatives, você pode adicionar quantas alternativas desejar.

Enviar emails para múltiplos destinatários

Com Nodemailer, enviar emails para múltiplos destinatários é bastante simples, pois você pode adicionar quantos endereços de destinatários desejar no mesmo campo to, assim:

const mailOptions = {
  from: 'seuemail@email.com',
  to: 'seuamigo@example.com, seusegundoamigo@example.com, seuamigodoamigo@example.com',
  subject: 'Enviando Email usando Node.js',
  text: 'Isso foi fácil!'
}

Enviar emails com anexos

Para enviar anexos, você pode usar a opção attachments no objeto da mensagem.

Veja como:

let message = {
    ...
    attachments: [
        {   // string utf-8 como anexo
            filename: 'texto1.txt',
            content: 'hello world!'
        },
        {   // buffer binário como anexo
            filename: 'texto2.txt',
            content: Buffer.from('hello world!','utf-8')
        },
        {   // arquivo no disco como anexo
            filename: 'texto3.txt',
            path: '/caminho/para/arquivo.txt' // transmitir este arquivo
        },
        {   // nome do arquivo e tipo de conteúdo são derivados do caminho
            path: '/caminho/para/arquivo.txt'
        },
        {   // stream como anexo
            filename: 'texto4.txt',
            content: fs.createReadStream('arquivo.txt')
        },
        {   // definir tipo de conteúdo personalizado para o anexo
            filename: 'texto.bin',
            content: 'hello world!',
            contentType: 'text/plain'
        },
        {   // usar URL como anexo
            filename: 'licenca.txt',
            path: 'https://raw.github.com/nodemailer/nodemailer/master/LICENSE'
        },
        {   // string codificada como anexo
            filename: 'texto1.txt',
            content: 'aGVsbG8gd29ybGQh',
            encoding: 'base64'
        },
        {   // data uri como anexo
            path: 'data:text/plain;base64,aGVsbG8gd29ybGQ='
        },
        {
            // usar nó MIME pré-gerado
            raw: 'Content-Type: text/plain\r\n' +
                 'Content-Disposition: attachment;\r\n' +
                 '\r\n' +
                 'Hello world!'
        }
    ]
}

Enviar emails em massa

Para enviar email em massa com Nodemailer e Gmail, você pode usar o seguinte código que preparei para você:

const nodemailer = require('nodemailer');


// Configure o Nodemailer para usar Gmail para SMTP com conexão agrupada
const transporter = nodemailer.createTransport({
   host: 'smtp.gmail.com',
   port: 587,
   pool: true, // Use o agrupamento SMTP para manter a conexão aberta para vários emails
   auth: {
       user: 'seu-usuario-gmail', // Substitua pelo seu nome de usuário do Gmail
       pass: 'sua-senha-de-app'  // Substitua pela sua senha de app
   },
   maxMessages: Infinity, // Permitir um número ilimitado de mensagens por conexão
   maxConnections: 5 // Limitar o número de conexões simultâneas
});


// Lista de destinatários para envio em massa
const recipients = [
   {email: 'destinatario1@example.com', name: 'Destinatário Um'},
   {email: 'destinatario2@example.com', name: 'Destinatário Dois'},
   {email: 'destinatario3@example.com', name: 'Destinatário Três'},
   // Adicione mais destinatários conforme necessário
];

// Preparar promessas de email para envio em massa
const emailPromises = recipients.map(recipient =>
   transporter.sendMail({
       from: '"Nome do Remetente" <remetente@example.com>',
       to: `${recipient.name} <${recipient.email}>`, // Personalizado para cada destinatário
       subject: 'Teste de Email em Massa',
       text: 'Este é um email de teste enviado em massa usando Nodemailer e Gmail.',
       html: `<b>Olá ${recipient.name},</b><p>Este é um email de teste enviado em massa usando Nodemailer e Gmail.</p>`
   })
);

// Enviar todos os emails em paralelo e tratar os resultados
Promise.all(emailPromises)
   .then(results => {
       console.log('Todos os emails foram enviados com sucesso');
       results.forEach(result => {
           console.log(`Mensagem para ${result.envelope.to} enviada: ${result.messageId}`);
       });
   })
   .catch(errors => {
       console.error('Falha ao enviar um ou mais emails:', errors);
   });

Explicação do código:

Importante: Como o Gmail possui várias limitações de envio, que abordarei na seção a seguir, você deve considerar o uso de um provedor de serviços de email dedicado para envios em massa (por exemplo, Mailtrap).

Limitações do Gmail SMTP e possíveis problemas

Como mencionei, o Google tem limitações oficiais para garantir o uso justo e proteger sua infraestrutura.

Algumas das limitações incluem:

Contas normais do Gmail podem enviar tipicamente cerca de 100-150 emails por dia. Se você incluir três destinatários, como fizemos acima, isso já conta como três emails enviados. Se você enviar três emails separados para os mesmos destinatários, ainda serão três emails.

Por outro lado, contas do Google Workspace podem ter limites mais altos (até 2.000 emails por dia). Agora, isso seria perfeitamente adequado para enviar atualizações ocasionais do sistema ou emails transacionais.

No entanto, se você tiver campanhas de marketing em massa em mente ou milhares de usuários para enviar emails, provavelmente desejará procurar soluções mais sofisticadas projetadas para envio de email em massa. Nossa lista dos melhores provedores de email transacional pode ser útil.

Enviar anexos com Nodemailer é fácil, mas enviar um único email com mais de 25 MB via servidor SMTP do Gmail não é tão fácil, receio. Para enviar arquivos maiores, você terá que usar o Google Drive e inserir o link no email.

Um dos problemas que você pode enfrentar é com autenticação. “Impossível”, você pode estar pensando depois de todos os passos que mostrei para configurar sua conta. Infelizmente, o Google fará o seu melhor para dificultar a vida dos spammers, e usuários honestos como eu e você muitas vezes acabam sofrendo.

Para evitar possíveis problemas, use OAuth2 com Gmail e Nodemailer. Siga estas instruções.

Se isso não fosse suficiente, você também pode ter problemas se seus servidores estiverem em uma localização geográfica diferente. O Google é facilmente capaz de detectar tal comportamento e pode marcar sua atividade como suspeita, tornando difícil o envio de qualquer email.

Finalmente, você pode enfrentar problemas de entregabilidade ao enviar mensagens de servidores publicamente disponíveis. Há um bom número de spammers e fraudadores utilizando contas do Gmail e até mesmo do Google Apps, e isso tudo afeta a reputação dos domínios de envio.

Mesmo com todos os problemas potenciais em jogo, contas básicas do Gmail e planos do Workspace não oferecem suporte ao cliente dedicado, que está disponível apenas para planos de níveis mais altos. Então, infelizmente, sua melhor aposta para resolver qualquer problema relacionado ao Gmail são fóruns comunitários como o Stack Overflow.

Observe que essas limitações estão sujeitas a alterações e são regularmente atualizadas pelo Google.

Existe uma alternativa ao SMTP do Gmail?

Agora, como superar as limitações do Gmail SMTP? Não se preocupe — tenho a solução perfeita para desenvolvedores com a qual você mantém a funcionalidade contínua do Nodemailer e obtém uma infraestrutura com altas taxas de entregabilidade por design.

Claro, estou falando sobre o Email API/SMTP do Mailtrap, parte da Plataforma de Email Delivery do Mailtrap projetada para testar, enviar e controlar sua infraestrutura de email.

O Email API/SMTP do Mailtrap possui um cliente Node.js oficial que você pode usar para adicionar rapidamente funcionalidade de envio de emails à sua aplicação Node.js, utilizando SMTP ou a API oficial de email. Para um guia rápido, confira nosso guia dedicado.

Para garantir que seus emails alcancem as caixas de entrada desejadas a tempo, o Mailtrap também oferece uma infinidade de recursos destinados a melhorar a entregabilidade.

Destaques dos benefícios de usar Mailtrap:

Mais importante ainda, configurar o Email API/SMTP do Mailtrap é super simples e leva apenas cinco minutos graças ao seu processo de configuração contínuo!

Guia de configuração do Nodemailer para o serviço SMTP do Mailtrap:

E é basicamente isso!

Envie emails gratuitamente com o Mailtrap

Testar emails e envio de emails em staging

Se você é desenvolvedor, provavelmente está ciente de que uma única linha de código com erro pode causar um erro que dá dor de cabeça.

Agora, para evitar enviar emails com erros e evitar a dor de cabeça que vem ao corrigir o código com falha, aconselho você a testar seus emails antes de enviá-los. Isso é uma prática padrão da indústria que acompanha qualquer ciclo sólido de envio de emails como arroz no feijão. 🍚

Para isso, recomendo o Email Testing do Mailtrap, outra parte inseparável da Plataforma de Email Delivery do Mailtrap.

Com o Email Testing do Mailtrap, você pode inspecionar e depurar emails em ambientes de staging, dev e QA sem risco de spam de usuários com emails de teste.

Algumas funcionalidades do Email Testing do Mailtrap que se destacam incluem:

Agora, deixe-me mostrar como funciona o Email Testing do Mailtrap e como configurá-lo!

Primeiro, registre-se para uma conta gratuita do Mailtrap se você ainda não tiver uma, e então:

Ou, você também pode usar a integração pronta para uso do Mailtrap com Nodemailer:

O snippet de código contém atributos transporter e syntaxis, e fica algo assim:

const transport = nodemailer.createTransport({
  host: "sandbox.smtp.mailtrap.io",
  port: 2525,
  auth: {
    user: "1a2b3c4d5e6f7g",
    pass: "1a2b3c4d5e6f7g"
  }
});

Alternativamente, você pode integrar o Email Testing no seu app e usar a API de Teste para testar, automatizar e testar sequências automatizadas.

Teste emails gratuitamente com o Mailtrap

Concluindo

Isso é tudo pessoal! (Inserir a música do Looney Tunes aqui)

Como prometido, mostrei como enviar emails com Nodemailer e Gmail SMTP, e, como você pôde ver, não é uma ciência super complicada. 🧪

No entanto, você sempre pode seguir a rota mais fácil (e mais eficiente) optando pelo Mailtrap, evitando as limitações do Gmail e garantindo que seus emails sejam entregues onde e quando devem ser.

Além disso, se você quiser apimentar sua jornada de codificação e aprender mais sobre JavaScript, confira nosso blog, onde você pode encontrar artigos como:

Sair da versão mobile