Como verificar um endereço de e-mail em Python

Neste artigo, vou orientá-lo sobre a maneira mais simples possível de verificar endereços de e-mail e melhorar o procedimento de registro de usuário do seu aplicativo Python.

A verificação de e-mail é extremamente importante. Garantir que os usuários que se inscrevem no seu site tenham um endereço de e-mail válido é essencial por vários motivos:

• É possível detectar erros de digitação quando os usuários inserem seus endereços de e-mail antes de permitir o registro.
• Ele permite que você mantenha contato com seus usuários: você pode enviar e-mails quando o cartão de crédito deles expirar, quando enviar recibos ou quando tiver novos recursos disponíveis, para citar alguns motivos.
• Isso garante que seus usuários possam redefinir a senha com segurança caso a esqueçam: sem um endereço de e-mail, não há como validar a identidade de alguém além da verificação manual e humana.
• Ele impede que os usuários se inscrevam no seu site com endereços de e-mail descartáveis, como os do Mailinator. Os usuários que se inscrevem nesses serviços geralmente estão tentando evitar fornecer o e-mail real por motivos específicos, como querer abusar dos recursos freemium etc. Ao garantir que você só permita que usuários com endereços de e-mail pessoais ou comerciais reais se registrem, você reduz o risco de abuso do seu site.

O ponto em que a verificação de e-mail se torna complexa, no entanto, é quando se decide como verificar endereços de e-mail para o SEU site. Cada site tem requisitos diferentes e, dependendo do que o seu faz, talvez você só queira verificar o endereço de e-mail de um usuário de uma ou duas maneiras específicas.

Para ajudar a resolver esse problema, lançamos recentemente o pacote email-verifier no repositório de pacotes PyPi.

Essa biblioteca Python permite que você verifique facilmente os endereços de e-mail de várias maneiras diferentes e oferece verificação flexível (como você verá em breve).

Então, sem mais delongas, vamos dar uma olhada em como ele funciona!

Criar uma Conta de Email Verification

A primeira coisa que você precisa fazer para verificar endereços de e-mail usando a biblioteca de verificação de e-mail é criar uma conta gratuita para o serviço da Email Verification API aqui: https://emailverification.whoisxmlapi.com/signup

Depois de criar sua conta gratuita, você poderá usar o serviço da API para verificar 1.000 endereços de e-mail gratuitamente. Se quiser fazer mais, você sempre pode pagar uma pequena quantia.

Instalar o pacote

Agora que sua conta está configurada, a próxima coisa que você precisa fazer é instalar o pacote Python. Na linha de comando, execute o seguinte comando:

            
$ pip install email-verifier
            
            

Isso fará o download e instalará a versão mais recente do pacote email-verifier do PyPi.

Verificar um endereço de e-mail

Depois de ter uma conta e o pacote instalados, vamos dar uma olhada em alguns códigos que podem ser executados para verificar um endereço de e-mail imediatamente.

Aqui está um pequeno script, 'verify.py'que verificará um endereço de e-mail usando todos os métodos de verificação possíveis:

            
from emailverifier import Client
from emailverifier import exceptions

client = Client('Your-api-key')

try:
  data = client.get("support@whoisxmlapi.com")

# If you get here, it means service returned HTTP error code
except exceptions.HttpException:
  pass

# If you get here, it means you cannot connect to the service
except exceptions.GeneralException:
  pass

# If you get here, it means you forgot to specify the API key
except exceptions.UndefinedVariableException:
  pass

# If you get here, it means you specified invalid argument
# (options should be a dictionary)
except exceptions.InvalidArgumentException:
  pass

except:
  pass
# Something else happened related.Maybe you hit CTRL - C
# while the program was running, the kernel is killing your process, or
# something else all together.
print(data)

# Use data.json_string to get raw data in JSON.
# You can access any response field as a class property
# by converting field name from "camelCase" to "snake_case"
print("Email address: " + data.email_address)
print("Format: " + str(data.format_check))
print("DNS: " + str(data.dns_check))
print("SMTP: " + str(data.smtp_check))
print("Catch all: " + str(data.catch_all_check))
print("Disposable: " + str(data.disposable_check))
print("Free: " + str(data.free_check))
print("Last audit date: " + str(data.audit.audit_updated_date))           
            
            

Como você pode ver, há apenas três etapas para usar a biblioteca:

• Importar ‘Client’ (Cliente) classe e exceções do pacote.
• Criar um ‘Client’ (Cliente) fornecendo a ele a chave de API que você criou quando se inscreveu no serviço de API.
• Executar o 'get' passando o endereço de e-mail que você deseja verificar e um dicionário com opções e seus valores. Esta é a lista de opções disponíveis: validateDNS, validateSMTP, checkCatchAll, checkFree, checkDisposable, _hardRefresh. A descrição dessas opções pode ser encontrada em nosso documentation page.

Os dados impressos no exemplo terão a seguinte aparência:

            
{
    "emailAddress": "support@whoisxmlapi.com",
    "formatCheck": "true",
    "smtpCheck": "true",
    "dnsCheck": "true",
    "freeCheck": "false",
    "disposableCheck": "false",
    "catchAllCheck": "true",
    "mxRecords": [
        "ALT1.ASPMX.L.GOOGLE.com",
        "ALT2.ASPMX.L.GOOGLE.com",
        "ASPMX.L.GOOGLE.com",
        "ASPMX2.GOOGLEMAIL.com",
        "ASPMX3.GOOGLEMAIL.com"
    ],
    "audit": {
        "auditCreatedDate": "2018-04-19 18:12:45.000 UTC",
        "auditUpdatedDate": "2018-04-19 18:12:45.000 UTC"
    }
}

Email address: support@whoisxmlapi.com
Format: True
DNS: True
SMTP: True
Catch all: True
Disposable: False
Free: False
Last audit date: 2018-04-19 18:12:45
            
            

Cada valor de objeto retornado corresponde a diferentes tipos de verificação:

• The catchAllCheck verifica se esse endereço de e-mail é ou não um endereço "catch-all". Isso se refere a um tipo especial de endereço que pode receber e-mails de qualquer número de outros endereços. Isso é comum em empresas em que, se você enviar um e-mail para test@hi.com e outro para test2@hi.com, ambos os e-mails serão enviados para a mesma caixa de entrada.
• The disposableCheck verifica se o endereço de e-mail é descartável ou não (criado por meio de um serviço como o Mailinator). Isso o ajuda a verificar se há abuso. Esse valor será false se o e-mail não for descartável, e true otherwise.
• The dnsCheck verifica se o domínio no endereço de e-mail, por exemplo: gmail.com, é um domínio válido. Esse valor será OK se o domínio for bom.
• The freeCheck verificará se o endereço de e-mail é de um provedor de e-mail gratuito, como o Gmail ou não. Esse valor será 'false' se o endereço de e-mail não for gratuito, e true otherwise.
• The formatCheck A verificação permite que você saiba se há algum erro de sintaxe no endereço de e-mail. Essa é uma verificação básica realizada para detectar erros de digitação simples ou erros graves. Esse valor será false se não houver erros, e true otherwise.
  Nos bastidores, o serviço de API está lidando com todos esses tipos de verificações para você de várias maneiras interessantes. Falarei sobre isso em um artigo futuro.

Personalizando o Email Verification

Como mencionei anteriormente, o exemplo de código acima mostrou como validar um endereço de e-mail com todos os métodos possíveis de verificação, mas isso pode não ser o que você deseja fazer em todos os casos.

A verificação de e-mail pode ser lenta. Cada tipo de verificação leva pouco tempo (frações de segundo), mas quando todas as verificações são realizadas, esse tempo pode se acumular.

Se o seu site só precisa verificar um endereço de e-mail para garantir que ele possa receber e-mails, por exemplo, você pode informar ao pacote email-verifier para que ele faça apenas essa verificação. A biblioteca do verificador de e-mail é totalmente flexível: você pode ativar ou desativar qualquer tipo de verificação que desejar.

Veja como funciona:

            
client.get("support@whoisxmlapi.com", {
    'validateSMTP': 0,
    '_hardRefresh': 1,
    #. . . .
})
            
            

Ao executar o 'get' você pode usar um dicionário com opções (como mostrado acima) que afetam diretamente os tipos de verificações que são realizadas. Sinta-se à vontade para usá-las conforme necessário.

Melhorar o fluxo de registro do usuário

Agora que você viu como pode verificar endereços de e-mail usando a biblioteca email-verifier, talvez queira modificar o processo de registro do seu site para fazer uso disso.

A melhor maneira de fazer isso é bastante simples. Quando um usuário preenche o formulário de registro e o envia, você deve:

• Receber os dados do formulário em seu servidor da Web
• Analisar os dados de registro do usuário, incluindo seu endereço de e-mail
• Verifique imediatamente o endereço de e-mail do usuário usando a biblioteca de verificação de e-mail
• Mostrar um erro ao usuário se o e-mail for inválido, solicitando que ele tente novamente
• Se tudo estiver em ordem, crie a nova conta do usuário e faça o login

Seguindo essas etapas, você melhorará muito o fluxo de registro do seu site ao detectar erros de digitação e erros no início do processo de registro, antes que seja tarde demais para corrigi-los.

Resumo

Portanto, para concluir: verificar os endereços de e-mail dos seus usuários pode ser uma maneira simples de melhorar a experiência do usuário em seu site.

Se você precisar verificar um endereço de e-mail, o novo email-verifier é a ferramenta perfeita, pois lida com muitos tipos diferentes de validação e é extremamente flexível.

Se tiver alguma dúvida, envie um e-mail para nós!