Como gerenciar o encaminhamento

Você pode usar Configurações para configurar o encaminhamento para uma conta. Para ser usado como endereço de encaminhamento, um endereço precisa atender a um dos seguintes critérios:

  • O endereço de e-mail foi verificado. Para mais informações, consulte Como criar e verificar endereços de encaminhamento.
  • O endereço de e-mail pertence ao mesmo domínio do remetente.
  • O endereço de e-mail pertence a um subdomínio no mesmo domínio do remetente.
  • O endereço de e-mail pertence a um alias de domínio configurado como parte da mesma conta do Google Workspace.

Se o endereço de e-mail de encaminhamento não aderir a uma dessas regras, a configuração do encaminhamento usando a API falhará.

Para informações sobre como criar, listar, receber ou excluir endereços de encaminhamento, consulte a referência de ForwardingAddresses.

Para informações sobre como receber ou atualizar as configurações de encaminhamento, consulte a Referência de configurações

Como criar e verificar endereços de encaminhamento

Crie endereços de encaminhamento antes de usá-los. Em alguns casos, os usuários também precisam confirmar a propriedade do endereço.

Se o Gmail exigir a verificação do usuário para um endereço de encaminhamento, esse endereço será retornado com o status pending. Uma mensagem de verificação é enviada automaticamente para o endereço de e-mail de destino. O proprietário do endereço de e-mail precisa concluir o processo de verificação antes de usá-lo.

Os endereços de encaminhamento que não exigem confirmação têm o status de verificação accepted.

Como ativar o encaminhamento automático

Chame o método updateAutoForwarding para ativar o encaminhamento automático de uma conta. A chamada requer um endereço de encaminhamento registrado e verificado, bem como uma ação a executar nas mensagens encaminhadas.

Por exemplo, para ativar o encaminhamento automático e mover as mensagens encaminhadas para a lixeira:

Java

gmail/snippets/src/main/java/EnableForwarding.java
import com.google.api.client.googleapis.json.GoogleJsonError;
import com.google.api.client.googleapis.json.GoogleJsonResponseException;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.api.client.json.gson.GsonFactory;
import com.google.api.services.gmail.Gmail;
import com.google.api.services.gmail.GmailScopes;
import com.google.api.services.gmail.model.AutoForwarding;
import com.google.api.services.gmail.model.ForwardingAddress;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import java.io.IOException;

/* Class to demonstrate the use of Gmail Enable Forwarding API */
public class EnableForwarding {
  /**
   * Enable the auto-forwarding for an account.
   *
   * @param forwardingEmail - Email address of the recipient whose email will be forwarded.
   * @return forwarding id and metadata, {@code null} otherwise.
   * @throws IOException - if service account credentials file not found.
   */
  public static AutoForwarding enableAutoForwarding(String forwardingEmail) throws IOException {
        /* Load pre-authorized user credentials from the environment.
           TODO(developer) - See https://developers.google.com/identity for
            guides on implementing OAuth2 for your application. */
    GoogleCredentials credentials = GoogleCredentials.getApplicationDefault()
        .createScoped(GmailScopes.GMAIL_SETTINGS_SHARING);
    HttpRequestInitializer requestInitializer = new HttpCredentialsAdapter(credentials);

    // Create the gmail API client
    Gmail service = new Gmail.Builder(new NetHttpTransport(),
        GsonFactory.getDefaultInstance(),
        requestInitializer)
        .setApplicationName("Gmail samples")
        .build();

    try {
      // Enable auto-forwarding and move forwarded messages to the trash
      ForwardingAddress address = new ForwardingAddress()
          .setForwardingEmail(forwardingEmail);
      ForwardingAddress createAddressResult = service.users().settings().forwardingAddresses()
          .create("me", address).execute();
      if (createAddressResult.getVerificationStatus().equals("accepted")) {
        AutoForwarding autoForwarding = new AutoForwarding()
            .setEnabled(true)
            .setEmailAddress(address.getForwardingEmail())
            .setDisposition("trash");
        autoForwarding =
            service.users().settings().updateAutoForwarding("me", autoForwarding).execute();
        System.out.println(autoForwarding.toPrettyString());
        return autoForwarding;
      }
    } catch (GoogleJsonResponseException e) {
      // TODO(developer) - handle error appropriately
      GoogleJsonError error = e.getDetails();
      if (error.getCode() == 403) {
        System.err.println("Unable to enable forwarding: " + e.getDetails());
      } else {
        throw e;
      }
    }
    return null;
  }
}

Python

gmail/snippet/settings snippets/enable_forwarding.py
from __future__ import print_function

import google.auth
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError


def enable_forwarding():
    """Enable email forwarding.
    Returns:Draft object, including forwarding id and result meta data.

    Load pre-authorized user credentials from the environment.
    TODO(developer) - See https://developers.google.com/identity
    for guides on implementing OAuth2 for the application.
    """
    creds, _ = google.auth.default()

    try:
        # create gmail api client
        service = build('gmail', 'v1', credentials=creds)

        address = {'forwardingEmail': 'gduser1@workspacesamples.dev'}

        # pylint: disable=E1101
        result = service.users().settings().forwardingAddresses(). \
            create(userId='me', body=address).execute()
        if result.get('verificationStatus') == 'accepted':
            body = {
                'emailAddress': result.get('forwardingEmail'),
                'enabled': True,
                'disposition': 'trash'
            }
            # pylint: disable=E1101
            result = service.users().settings().updateAutoForwarding(
                userId='me', body=body).execute()
            print(F'Forwarding is enabled : {result}')

    except HttpError as error:
        print(F'An error occurred: {error}')
        result = None

    return result


if __name__ == '__main__':
    enable_forwarding()

Para desativar o encaminhamento automático, chame updateAutoForwarding e defina a propriedade enabled como false.

Como encaminhar mensagens específicas

O encaminhamento automático envia todas as mensagens recebidas para a conta de destino. Para encaminhar as mensagens seletivamente, use filtros para criar regras que encaminhem em resposta a atributos ou conteúdo da mensagem.