ShieldMail API v3.0

const email = 'test@tempmail.com';

const response = await fetch(
  `https://api.teknikzeka.net/tempmail/api/?action=check&email=${encodeURIComponent(email)}`,
  { headers: { 'X-API-Key': 'sm_YOUR_API_KEY_HERE' } }
);
const result = await response.json();

if (result.success && result.data.blocked) {
  console.log('Disposable email!', result.data.domain);
} else {
  console.log('Temiz email.', result.data.domain);
}

console.log('Kullanim:', result.usage);

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

document.getElementById('registerForm')
  .addEventListener('submit', async (e) => {
    e.preventDefault();
    const email = document.getElementById('email').value;

    const res = await fetch(
      `https://api.teknikzeka.net/tempmail/api/?action=check&email=${encodeURIComponent(email)}`,
      { headers: { 'X-API-Key': 'sm_YOUR_API_KEY_HERE' } }
    ).then(r => r.json());

    if (res.success && res.data.blocked) {
      alert('Gecici email adresleri kabul edilmez!');
      return;
    }
    e.target.submit();
  });

const emails = ['a@temp.com', 'b@gmail.com'];

const res = await fetch('https://api.teknikzeka.net/tempmail/api/?action=bulk_check', {
  method: 'POST',
  headers: {
    'X-API-Key': 'sm_YOUR_API_KEY_HERE',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ emails })
}).then(r => r.json());

console.log(`Toplam: ${res.total}, Engelli: ${res.blocked_count}`);
res.data.forEach(d =>
  console.log(`${d.email}: ${d.blocked ? 'ENGELLI' : 'TEMIZ'}`)
);

{
  "success": true,
  "data": [
    {"email":"a@temp.com","domain":"temp.com","blocked":true,"disposable":true},
    {"email":"b@gmail.com","domain":"gmail.com","blocked":false,"disposable":false}
  ],
  "total": 2,
  "blocked_count": 1
}

import requests

API_KEY = 'sm_YOUR_API_KEY_HERE'
API_URL = 'https://api.teknikzeka.net/tempmail/api/'

def check_email(email):
    r = requests.get(API_URL, params={
        'action': 'check',
        'email': email
    }, headers={'X-API-Key': API_KEY})

    data = r.json()
    if data['success'] and data['data']['blocked']:
        print(f"{email} - DISPOSABLE!")
    else:
        print(f"{email} - Temiz")
    return data

result = check_email('test@tempmail.com')
print(f"Kullanim: {result['usage']}")

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

from flask import Flask, request, jsonify
import requests

app = Flask(__name__)

def is_disposable(email):
    try:
        r = requests.get('https://api.teknikzeka.net/tempmail/api/', params={
            'action': 'check', 'email': email
        }, headers={'X-API-Key': 'sm_YOUR_API_KEY_HERE'}, timeout=5)
        data = r.json()
        return data.get('success') and data['data'].get('blocked')
    except:
        return False

@app.route('/register', methods=['POST'])
def register():
    email = request.json.get('email', '')
    if is_disposable(email):
        return jsonify({'error': 'Disposable email kabul edilmez'}), 400
    return jsonify({'message': 'Kayit basarili'})

emails = ['a@temp.com', 'b@gmail.com', 'c@guerrillamail.com']

r = requests.post('https://api.teknikzeka.net/tempmail/api/?action=bulk_check',
    json={'emails': emails},
    headers={'X-API-Key': 'sm_YOUR_API_KEY_HERE'})

result = r.json()
print(f"Toplam: {result['total']}, Engelli: {result['blocked_count']}")
for item in result['data']:
    status = "ENGELLI" if item['blocked'] else "TEMIZ"
    print(f"  {item['email']}: {status}")

{
  "success": true,
  "data": [
    {"email":"a@temp.com","domain":"temp.com","blocked":true,"disposable":true},
    {"email":"b@gmail.com","domain":"gmail.com","blocked":false,"disposable":false}
  ],
  "total": 2,
  "blocked_count": 1
}

using System.Net.Http;
using System.Text.Json;

var client = new HttpClient();
client.DefaultRequestHeaders.Add("X-API-Key", "sm_YOUR_API_KEY_HERE");

var email = "test@tempmail.com";
var url = $"https://api.teknikzeka.net/tempmail/api/?action=check&email={Uri.EscapeDataString(email)}";
var response = await client.GetStringAsync(url);
var json = JsonDocument.Parse(response);

var blocked = json.RootElement
    .GetProperty("data")
    .GetProperty("blocked")
    .GetBoolean();

Console.WriteLine(blocked ? "Disposable email!" : "Temiz email.");

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

public class DisposableEmailFilter : IAsyncActionFilter
{
    private readonly HttpClient _http;

    public DisposableEmailFilter(HttpClient http) => _http = http;

    public async Task OnActionExecutionAsync(
        ActionExecutingContext ctx, ActionExecutionDelegate next)
    {
        if (ctx.ActionArguments.TryGetValue("email", out var email))
        {
            _http.DefaultRequestHeaders.Clear();
            _http.DefaultRequestHeaders.Add("X-API-Key", "sm_YOUR_API_KEY_HERE");

            var url = $"https://api.teknikzeka.net/tempmail/api/?action=check&email={email}";
            var res = await _http.GetFromJsonAsync<JsonElement>(url);

            if (res.GetProperty("data").GetProperty("blocked").GetBoolean())
            {
                ctx.Result = new BadRequestObjectResult(
                    new { error = "Disposable email kabul edilmez" });
                return;
            }
        }
        await next();
    }
}

import java.net.http.*;
import java.net.URI;

var client = HttpClient.newHttpClient();
var email = "test@tempmail.com";
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.teknikzeka.net/tempmail/api/?action=check&email=" +
        URLEncoder.encode(email, "UTF-8")))
    .header("X-API-Key", "sm_YOUR_API_KEY_HERE")
    .build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
var json = new JSONObject(response.body());

boolean blocked = json.getJSONObject("data").getBoolean("blocked");
System.out.println(blocked ? "Disposable!" : "Temiz");

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

type CheckResponse struct {
    Success bool `json:"success"`
    Data    struct {
        Domain     string `json:"domain"`
        Blocked    bool   `json:"blocked"`
        Disposable bool   `json:"disposable"`
    } `json:"data"`
}

func checkEmail(email string) (*CheckResponse, error) {
    apiURL := "https://api.teknikzeka.net/tempmail/api/?action=check&email=" + url.QueryEscape(email)
    req, _ := http.NewRequest("GET", apiURL, nil)
    req.Header.Set("X-API-Key", "sm_YOUR_API_KEY_HERE")

    resp, err := http.DefaultClient.Do(req)
    if err != nil { return nil, err }
    defer resp.Body.Close()

    var result CheckResponse
    json.NewDecoder(resp.Body).Decode(&result)
    return &result, nil
}

func main() {
    res, _ := checkEmail("test@tempmail.com")
    if res.Data.Blocked {
        fmt.Println("Disposable email!")
    }
}

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

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

def check_email(email)
  uri = URI("https://api.teknikzeka.net/tempmail/api/?action=check&email=#{URI.encode_www_form_component(email)}")
  req = Net::HTTP::Get.new(uri)
  req['X-API-Key'] = 'sm_YOUR_API_KEY_HERE'

  res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |h| h.request(req) }
  JSON.parse(res.body)
end

result = check_email('test@tempmail.com')
puts result['data']['blocked'] ? 'Disposable!' : 'Temiz'
puts "Kullanim: #{result['usage']}"

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

curl -s -H "X-API-Key: sm_YOUR_API_KEY_HERE" \
  "https://api.teknikzeka.net/tempmail/api/?action=check&email=test@tempmail.com" | jq .

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

curl -s -X POST \
  -H "X-API-Key: sm_YOUR_API_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{"emails":["a@temp.com","b@gmail.com"]}' \
  "https://api.teknikzeka.net/tempmail/api/?action=bulk_check" | jq .

{
  "success": true,
  "data": [
    {"email":"a@temp.com","domain":"temp.com","blocked":true,"disposable":true},
    {"email":"b@gmail.com","domain":"gmail.com","blocked":false,"disposable":false}
  ],
  "total": 2,
  "blocked_count": 1
}

curl -s -H "X-API-Key: sm_YOUR_API_KEY_HERE" \
  "https://api.teknikzeka.net/tempmail/api/?action=usage" | jq .

$.ajax({
  url: 'https://api.teknikzeka.net/tempmail/api/',
  data: { action: 'check', email: $('#email').val() },
  headers: { 'X-API-Key': 'sm_YOUR_API_KEY_HERE' },
  success: function(r) {
    if (r.success && r.data.blocked) {
      alert('Gecici email tespit edildi!');
    } else {
      $('#registerForm')[0].submit();
    }
    // Kullanim bilgisi
    console.log('Kullanim:', r.usage);
  },
  error: function(xhr) {
    console.error('API Hatasi:', xhr.responseJSON);
  }
});

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

const API_KEY = 'sm_YOUR_API_KEY_HERE';
const API_URL = 'https://api.teknikzeka.net/tempmail/api/';

async function isDisposable(email) {
  const url = `${API_URL}?action=check&email=${encodeURIComponent(email)}`;
  const r = await fetch(url, {
    headers: { 'X-API-Key': API_KEY }
  }).then(r => r.json());
  return r.success && r.data.blocked;
}

// Express middleware
const checkDisposable = async (req, res, next) => {
  const { email } = req.body;
  if (await isDisposable(email)) {
    return res.status(400).json({
      error: 'Disposable email kabul edilmez'
    });
  }
  next();
};

app.post('/register', checkDisposable, (req, res) => {
  res.json({ message: 'Kayit basarili' });
});

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<Map<String, dynamic>> checkEmail(String email) async {
  final uri = Uri.parse(
    'https://api.teknikzeka.net/tempmail/api/?action=check&email='
    + Uri.encodeComponent(email)
  );
  final response = await http.get(uri, headers: {
    'X-API-Key': 'sm_YOUR_API_KEY_HERE'
  });
  return json.decode(response.body);
}

// Kullanim
final result = await checkEmail('test@tempmail.com');
if (result['success'] && result['data']['blocked']) {
  print('Disposable email!');
}
print('Kullanim: ${result["usage"]}');

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

import Foundation

func checkEmail(_ email: String) async throws -> Bool {
    let encoded = email.addingPercentEncoding(
        withAllowedCharacters: .urlQueryAllowed) ?? email
    let url = URL(string:
        "https://api.teknikzeka.net/tempmail/api/?action=check&email=\(encoded)")!

    var request = URLRequest(url: url)
    request.setValue("sm_YOUR_API_KEY_HERE",
        forHTTPHeaderField: "X-API-Key")

    let (data, _) = try await URLSession.shared.data(for: request)
    let json = try JSONSerialization.jsonObject(with: data)
        as! [String: Any]

    let dataObj = json["data"] as? [String: Any]
    return dataObj?["blocked"] as? Bool ?? false
}

// Kullanim
let blocked = try await checkEmail("test@tempmail.com")
print(blocked ? "Disposable!" : "Temiz")

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

import okhttp3.OkHttpClient
import okhttp3.Request
import org.json.JSONObject
import java.net.URLEncoder

fun checkEmail(email: String): Boolean {
    val encoded = URLEncoder.encode(email, "UTF-8")
    val request = Request.Builder()
        .url("https://api.teknikzeka.net/tempmail/api/?action=check&email=$encoded")
        .header("X-API-Key", "sm_YOUR_API_KEY_HERE")
        .build()

    val response = OkHttpClient().newCall(request).execute()
    val json = JSONObject(response.body?.string() ?: "{}")

    return json.optBoolean("success") &&
           json.optJSONObject("data")?.optBoolean("blocked") ?: false
}

// Kullanim
val blocked = checkEmail("test@tempmail.com")
println(if (blocked) "Disposable!" else "Temiz")

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}

use reqwest;
use serde_json::Value;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let email = "test@tempmail.com";
    let resp: Value = reqwest::Client::new()
        .get("https://api.teknikzeka.net/tempmail/api/")
        .query(&[("action", "check"), ("email", email)])
        .header("X-API-Key", "sm_YOUR_API_KEY_HERE")
        .send().await?
        .json().await?;

    let blocked = resp["success"].as_bool().unwrap_or(false)
        && resp["data"]["blocked"].as_bool().unwrap_or(false);

    println!("{}: {}", email,
        if blocked { "Disposable!" } else { "Temiz" });

    // Kullanim bilgisi
    println!("Kullanim: {}", resp["usage"]);
    Ok(())
}

{
  "success": true,
  "data": {
    "domain": "tempmail.com",
    "blocked": true,
    "disposable": true,
    "cached": false
  },
  "usage": {
    "hourly": "1/50",
    "daily": "1/500"
  }
}