Detect a One-Time Email Address

1. Home
2. Disposable E-Mail Identifier /

---

Detect a One-Time Email Address

Identifies Disposable (One-Time) Email Address using a list that is recently being updated.

GET /api/email/trash-mail-detector

https://api.cookie-api.com/api/email/trash-mail-detector

Authentication Learn how to get your API Key and use it in your requests!

Parameters

URL Parameters

Parameter	Type	Required	Description
email	string	Yes	Email address to be checked

Request examples

cURL

curl --location 'https://api.cookie-api.com/api/email/[email protected]' \
--header 'Authorization: API_Key'

Python

import requests

url = 'https://api.cookie-api.com/api/email/trash-mail-detector'
params = {
    'email': '[email protected]'
}
headers = {
    'Authorization': 'API_Key'
}

response = requests.get(url, headers=headers, params=params)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'https://api.cookie-api.com/api/email/[email protected]';
const headers = {
    'Authorization': 'API_Key'
};

fetch(url, {
    method: 'GET',
    headers
})
.then(res => res.json())
.then(data => console.log(data))
.catch(err => console.error('Error:', err));

Go

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

func main() {
    url := "https://api.cookie-api.com/api/email/[email protected]"

    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        log.Fatal(err)
    }

    req.Header.Set("Authorization", "API_Key")

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/email/[email protected]',
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, res => {
    let data = '';

    res.on('data', chunk => {
        data += chunk;
    });

    res.on('end', () => {
        console.log(JSON.parse(data));
    });
});

req.on('error', error => {
    console.error(error);
});

req.end();

Ruby

require 'net/http'
require 'uri'
require 'json'

uri = URI('https://api.cookie-api.com/api/email/[email protected]')
request = Net::HTTP::Get.new(uri)
request['Authorization'] = 'API_Key'

response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
  http.request(request)
end

puts JSON.parse(response.body)

Rust

use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use serde_json::Value;

fn main() {
    let client = Client::new();
    let url = "https://api.cookie-api.com/api/email/[email protected]";

    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let res = client
        .get(url)
        .headers(headers)
        .send()
        .unwrap();

    let body: Value = res.json().unwrap();
    println!("{:#?}", body);
}

Responses

200

{
    "is_trash_mail": true,
    "success": true,
    "errors": [],
    "messages": []
}