Como exportar e-mails para Excel / Google Sheets

Se precisa de ter os seus e-mails numa folha de cálculo, veja exatamente como o fazer. Existem aplicações que analisam e exportam as suas mensagens de e-mail e os dados extraídos para uma folha de cálculo do Google. O ActorAi também pode ajudar com isto.

Segue-se uma lista concisa de casos de utilização comuns para exportar e-mails para Excel ou Google Sheets:

• Exporte notificações de encomendas e envios.
• Exporte contactos potenciais por email para atualizar o CRM ou a base de dados.
• Identifique endereços de email devolvidos para gerir listas.
• Partilhe problemas em aberto ou pedidos com as equipas através de folhas de cálculo partilhadas.
• Importe dados estruturados de emails para bases de dados ou aplicações empresariais.
• Crie cópias de segurança e arquive emails empresariais importantes.
• Crie listas de distribuição a partir de contactos e endereços.
• Extraia informações financeiras e de despesas para relatórios.

Exportar e-mails do Gmail para o Google Sheets

Opção A – Com o complemento do Google Workspace (mais fácil)

• Abra o Google Sheets → Extensões → Suplementos.
• Pesquise o suplemento «Gmail to Sheets» (escolha o que melhor se adequa às suas necessidades)
• Instale-o e ligue a sua conta do Gmail.
• Selecione uma etiqueta/pasta ou um filtro de pesquisa.
• Execute a exportação → os dados aparecem na sua folha de cálculo.
• Sugestão: configure a atualização automática para atualizar os dados diariamente.

Opção B – Com o Google Apps Script (método faça você mesmo)

• Obtém emails que correspondem a uma pesquisa do Gmail (etiqueta, from:, subject:, after:, etc.)
• Escreve-os na folha ativa, com colunas organizadas
• Adiciona um menu personalizado: Exportação de e-mails → Executar exportação
• Permite controlar: a consulta de pesquisa, o número máximo de e-mails e se deve incluir o conteúdo das mensagens

Configurar o Google Apps Script (método faça você mesmo para exportar para o Excel)

1. Abra uma nova folha do Google Sheets.
2. Extensões → Apps Script.
3. Elimine todo o código e cole o script abaixo.
4. Clique Guarde, depois Executar → a função onOpen() para adicionar o menu personalizado.
5. De volta à folha, aceda a Exportação de e-mails → Configurar folha (cria um separador Config e os cabeçalhos).
6. Introduza a sua pesquisa em Config!B2 (exemplos abaixo) e, em seguida, Exportação de e-mails → Executar exportação.

/**************************************
 * Gmail → Google Sheets Exporter
 * Simple, DYI method for tech advanced.
 **************************************/

const CONFIG_SHEET = 'Config';
const OUTPUT_SHEET = 'Emails';
const PROPERTY_STORE = PropertiesService.getDocumentProperties();

function onOpen() {
  SpreadsheetApp.getUi()
    .createMenu('Email Export')
    .addItem('Setup sheet', 'setupSheet')
    .addItem('Run export', 'exportEmails')
    .addToUi();
}

function setupSheet() {
  const ss = SpreadsheetApp.getActive();
  // Config sheet
  let conf = ss.getSheetByName(CONFIG_SHEET);
  if (!conf) conf = ss.insertSheet(CONFIG_SHEET);
  conf.clear();

  conf.getRange('A1').setValue('Setting');
  conf.getRange('B1').setValue('Value');

  const rows = [
    ['Search query', 'label:inbox newer_than:30d'], // B2
    ['Max emails to fetch (per run)', 500],          // B3 (limit to avoid timeouts)
    ['Include message body? (true/false)', false],   // B4
    ['Body max characters', 5000],                  // B5
    ['Continue from last run? (true/false)', false]  // B6
  ];
  conf.getRange(2, 1, rows.length, 2).setValues(rows);
  conf.autoResizeColumns(1, 2);

  // Output sheet
  let out = ss.getSheetByName(OUTPUT_SHEET);
  if (!out) out = ss.insertSheet(OUTPUT_SHEET);
  out.clear();

  const headers = [
    'Date',
    'From',
    'To',
    'Subject',
    'Snippet',
    'Thread ID',
    'Message ID',
    'Labels',
    'Has Attachments',
    'Thread Link',
    'Message Link',
    'Body (optional)'
  ];
  out.getRange(1, 1, 1, headers.length).setValues([headers]);
  out.setFrozenRows(1);
  out.autoResizeColumns(1, headers.length);

  SpreadsheetApp.getUi().alert('Setup complete. Enter your query in Config!B2, then run "Email Export → Run export".');
}

function getConfig_() {
  const ss = SpreadsheetApp.getActive();
  const conf = ss.getSheetByName(CONFIG_SHEET);
  if (!conf) throw new Error('Config sheet missing. Run "Setup sheet" first.');

  const getVal = (row) => conf.getRange(row, 2).getValue();

  return {
    query: String(getVal(2) || '').trim(),
    maxEmails: Number(getVal(3) || 500),
    includeBody: String(getVal(4)).toLowerCase() === 'true',
    bodyMaxChars: Number(getVal(5) || 5000),
    continueFromLast: String(getVal(6)).toLowerCase() === 'true',
  };
}

function exportEmails() {
  const cfg = getConfig_();
  if (!cfg.query) throw new Error('Please fill a Gmail search in Config!B2.');

  const ss = SpreadsheetApp.getActive();
  const out = ss.getSheetByName(OUTPUT_SHEET) || ss.insertSheet(OUTPUT_SHEET);

  // Resume support (optional)
  let startIndex = 0;
  if (cfg.continueFromLast) {
    startIndex = Number(PROPERTY_STORE.getProperty('startIndex') || 0);
  } else {
    PROPERTY_STORE.deleteProperty('startIndex');
    // If not continuing, start fresh by clearing previous rows (keep header)
    const lastRow = out.getLastRow();
    if (lastRow > 1) out.getRange(2, 1, lastRow - 1, out.getLastColumn()).clearContent();
  }

  const BATCH_SIZE_THREADS = 100; // Gmail returns threads, we’ll page through them
  const rows = [];
  let fetchedEmails = 0;

  while (fetchedEmails < cfg.maxEmails) {
    const threads = GmailApp.search(cfg.query, startIndex, BATCH_SIZE_THREADS);
    if (!threads.length) break;

    for (const thread of threads) {
      const msgs = thread.getMessages();
      for (const msg of msgs) {
        if (fetchedEmails >= cfg.maxEmails) break;

        const date = msg.getDate();
        const from = msg.getFrom();
        const to = msg.getTo();
        const subject = msg.getSubject() || '';
        const snippet = msg.getPlainBody().slice(0, 120).replace(/\s+/g, ' ').trim();
        const threadId = thread.getId();
        const msgId = msg.getId();
        const labels = thread.getLabels().map(l => l.getName()).join(', ');
        const hasAttachments = msg.getAttachments().length > 0;

        const threadLink = `https://mail.google.com/mail/u/0/#all/${threadId}`;
        const messageLink = `https://mail.google.com/mail/u/0/#inbox/${msgId}`;

        let body = '';
        if (cfg.includeBody) {
          // Prefer plain body; fallback to HTML stripped
          body = msg.getPlainBody();
          if (!body) {
            const html = msg.getBody();
            body = stripHtml_(html);
          }
          if (cfg.bodyMaxChars > 0 && body.length > cfg.bodyMaxChars) {
            body = body.slice(0, cfg.bodyMaxChars) + '…';
          }
        }

        rows.push([
          date,
          from,
          to,
          subject,
          snippet,
          threadId,
          msgId,
          labels,
          hasAttachments,
          threadLink,
          messageLink,
          body
        ]);

        fetchedEmails++;
      }
      if (fetchedEmails >= cfg.maxEmails) break;
    }

    startIndex += BATCH_SIZE_THREADS;
    // Safety: avoid 6-minute execution limit
    if (Utilities.getRemainingDailyQuota && rows.length >= 5000) break;
  }

  if (rows.length) {
    out.insertRowsAfter(out.getLastRow() || 1, rows.length);
    out.getRange(out.getLastRow() - rows.length + 1, 1, rows.length, rows[0].length).setValues(rows);
    out.autoResizeColumns(1, out.getLastColumn());
  }

  if (cfg.continueFromLast) {
    PROPERTY_STORE.setProperty('startIndex', String(startIndex));
  }

  SpreadsheetApp.getUi().alert(`Export complete: ${fetchedEmails} emails added.`);
}

function stripHtml_(html) {
  // Lightweight HTML → text
  return String(html || '')
    .replace(/<style[\s\S]*?<\/style>/gi, '')
    .replace(/<script[\s\S]*?<\/script>/gi, '')
    .replace(/<[^>]+>/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

Versão simples do script para o Google Sheets.

function exportSimple() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const query = 'label:inbox newer_than:7d';
  const threads = GmailApp.search(query, 0, 100);
  const rows = [['Date','From','Subject','Snippet','Thread Link']];
  threads.forEach(t => {
    t.getMessages().forEach(m => {
      rows.push([
        m.getDate(),
        m.getFrom(),
        m.getSubject(),
        m.getPlainBody().slice(0,120).replace(/\s+/g,' ').trim(),
        'https://mail.google.com/mail/u/0/#all/' + t.getId()
      ]);
    });
  });
  sheet.clear().getRange(1,1,rows.length,rows[0].length).setValues(rows);
}

Exportar e-mails do Outlook para o Excel

1. Utilize o método de exportação para CSV no Outlook:

• Aceda a  Ficheiro > Abrir e Exportar > Importar/Exportar.
• Escolha  Exportar para um ficheiro  e selecione  Valores separados por vírgulas (CSV).
• Selecione a pasta de correio eletrónico que pretende exportar (por exemplo, a Caixa de entrada).
• Quando lhe for pedido, clique em  Mapear campos personalizados  para selecionar apenas os atributos específicos dos e-mails de que precisa, como  De,  Para,  Assunto,  Data de receção, etc.
• Conclua a exportação e abra o ficheiro CSV no Excel para ver apenas os metadados.

2. Filtre e copie metadados em formato de texto no Outlook:

• Crie uma vista personalizada no Outlook com apenas as colunas pretendidas visíveis (como remetente, data, etc.).
• Selecione os e-mails, copie-os e cole-os no Excel.
• Este método pode ser mais rápido para pequenos conjuntos, sobretudo se apenas estiver a exportar informações específicas do cabeçalho ou metadados.

3. Utilize o Power Query para exportação dinâmica:

• O Power Query no Excel pode ligar-se diretamente ao Outlook e filtrar apenas os campos necessários.
• Este método permite atualizações contínuas e automatização, mantendo os dados reduzidos ao mínimo.

1. Abra o Excel e aceda ao separador Dados.
2. Selecione Obter Dados > De Outras Origens > Do Microsoft Exchange.
3. Introduza o seu endereço de e-mail do Outlook e inicie sessão para estabelecer ligação.
4. Escolha a pasta da caixa de correio (por exemplo, Caixa de Entrada) que contém os e-mails pretendidos.
5. No Editor do Power Query, selecione apenas as colunas necessárias, como Assunto, De, Para e Data de receção.
6. Aplique os filtros necessários para restringir os e-mails, por exemplo, por data ou remetente.
7. Clique em Fechar e Carregar para importar os dados filtrados dos e-mails para uma tabela do Excel.
8. Atualize a consulta sempre que quiser para atualizar os dados com e-mails novos ou alterados.

Nota: planeamos integrar esta funcionalidade no Actor, como aplicação de e-mail. Atualmente, estamos a avaliar o interesse.

Nota: exportar para Excel ou Google Sheets não faz qualquer diferença. Ambos são excelentes ferramentas, desenvolvidas pela Google e pela Microsoft.

Agora já tem os seus e-mails numa folha de cálculo — prontos para analisar, filtrar ou partilhar. Se precisar de fazer isto regularmente, terá de automatizar o processo para o repetir nos intervalos que pretender.