> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mailbreeze.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Verify Email

> Verify a single email address

Verify a single email address synchronously. Results are returned immediately and cached for 24 hours.

## Request Body

<ParamField body="email" type="string" required>
  The email address to verify.
</ParamField>

## Examples

<CodeGroup>
  ```typescript JavaScript theme={null}
  import { MailBreeze } from "mailbreeze";

  const mailbreeze = new MailBreeze({ apiKey: "sk_live_xxx" });

  const result = await mailbreeze.verification.verify({ email: "user@example.com" });

  if (result.isValid) {
    console.log("Email is valid - safe to send");
  } else {
    console.log(`Invalid: ${result.reason}`);
  }

  // Check detailed information
  console.log(`Result: ${result.result}`);       // "valid", "invalid", "risky", "unknown"
  console.log(`Risk score: ${result.riskScore}`); // 0-100
  console.log(`Cached: ${result.cached}`);        // true if previously verified

  if (result.details) {
    console.log(`Disposable: ${result.details.isDisposable}`);
    console.log(`Free provider: ${result.details.isFreeProvider}`);
    console.log(`Role account: ${result.details.isRoleAccount}`);
  }
  ```

  ```python Python theme={null}
  from mailbreeze import MailBreeze

  client = MailBreeze(api_key="sk_live_xxx")

  result = await client.verification.verify(email="user@example.com")

  if result.is_valid:
      print("Email is valid - safe to send")
  else:
      print(f"Invalid: {result.reason}")

  # Check detailed information
  print(f"Result: {result.result}")        # "valid", "invalid", "risky", "unknown"
  print(f"Risk score: {result.risk_score}") # 0-100
  print(f"Cached: {result.cached}")         # True if previously verified

  if result.details:
      print(f"Disposable: {result.details.is_disposable}")
      print(f"Free provider: {result.details.is_free_provider}")
  ```

  ```go Go theme={null}
  client := mailbreeze.NewClient("sk_live_xxx")

  result, err := client.Verification.Verify(ctx, &mailbreeze.VerifyEmailParams{
      Email: "user@example.com",
  })
  if err != nil {
      log.Fatal(err)
  }

  if result.IsValid {
      fmt.Println("Email is valid - safe to send")
  } else {
      fmt.Printf("Invalid: %s\n", result.Reason)
  }

  // Check detailed information
  fmt.Printf("Result: %s\n", result.Result)
  fmt.Printf("Risk score: %d\n", result.RiskScore)
  fmt.Printf("Cached: %t\n", result.Cached)

  if result.Details != nil {
      fmt.Printf("Disposable: %t\n", result.Details.IsDisposable)
  }
  ```

  ```php PHP theme={null}
  $mailbreeze = new MailBreeze('sk_live_xxx');

  $response = $mailbreeze->verification->verify(['email' => 'user@example.com']);
  $result = $response['data'];

  if ($result['isValid']) {
      echo "Email is valid - safe to send\n";
  } else {
      echo "Invalid: " . $result['reason'] . "\n";
  }

  // Check detailed information
  echo "Result: " . $result['result'] . "\n";
  echo "Risk score: " . $result['riskScore'] . "\n";
  echo "Cached: " . ($result['cached'] ? 'true' : 'false') . "\n";

  if (isset($result['details'])) {
      echo "Disposable: " . ($result['details']['isDisposable'] ? 'true' : 'false') . "\n";
  }
  ```

  ```java Java theme={null}
  MailBreeze mailbreeze = MailBreeze.builder()
      .apiKey("sk_live_xxx")
      .build();

  VerifyEmailResult result = mailbreeze.verification().verify("user@example.com");

  if (result.isValid()) {
      System.out.println("Email is valid - safe to send");
  } else {
      System.out.println("Invalid: " + result.getReason());
  }

  // Check detailed information
  System.out.println("Result: " + result.getResult());
  System.out.println("Risk score: " + result.getRiskScore());
  System.out.println("Cached: " + result.isCached());

  if (result.getDetails() != null) {
      System.out.println("Disposable: " + result.getDetails().isDisposable());
  }
  ```

  ```rust Rust theme={null}
  let client = MailBreeze::new("sk_live_xxx")?;

  let result = client.verification.verify("user@example.com").await?;

  if result.is_valid {
      println!("Email is valid - safe to send");
  } else {
      println!("Invalid: {}", result.reason);
  }

  // Check detailed information
  println!("Result: {}", result.result);
  println!("Risk score: {:?}", result.risk_score);
  println!("Cached: {}", result.cached);

  if let Some(details) = result.details {
      println!("Disposable: {:?}", details.is_disposable);
  }
  ```

  ```bash cURL theme={null}
  curl -X POST https://api.mailbreeze.com/api/v1/email-verification/single \
    -H "Authorization: Bearer sk_live_xxx" \
    -H "Content-Type: application/json" \
    -d '{
      "email": "user@example.com"
    }'
  ```
</CodeGroup>

## Response

<ResponseField name="email" type="string">
  The email address that was verified.
</ResponseField>

<ResponseField name="status" type="string">
  Verification result status:

  * `clean` - Email is valid and safe to send to
  * `dirty` - Email is invalid or risky
  * `unknown` - Could not determine validity
</ResponseField>

```json Example Response theme={null}
{
  "success": true,
  "data": {
    "email": "user@example.com",
    "status": "clean"
  },
  "meta": {
    "timestamp": "2025-12-27T13:39:24.882Z",
    "requestId": "1bd79156-a875-430c-b8c7-75e9204267ea",
    "path": "/api/v1/email-verification/single"
  }
}
```

<Note>
  The response is wrapped in an envelope with `success`, `data`, and `meta` fields. SDKs automatically extract the `data` object, so you access fields directly (e.g., `result.isValid`).
</Note>

## Result Categories

| Result    | isValid | Description                    | Recommendation       |
| --------- | ------- | ------------------------------ | -------------------- |
| `valid`   | true    | Email exists and accepts mail  | Safe to send         |
| `invalid` | false   | Mailbox doesn't exist          | Do not send          |
| `risky`   | false   | May exist but has risk factors | Review manually      |
| `unknown` | false   | Could not verify               | Proceed with caution |

## Risk Factors

Emails may be marked as `risky` for:

* **Disposable email** - Temporary addresses that expire
* **Role accounts** - Generic addresses like admin@, support@
* **Catch-all domains** - Accept any address, can't verify mailbox
* **High spam complaint domain** - Domain has poor reputation

## Credits

* **New verification**: 1 credit deducted
* **Cached result**: 0 credits (results cached 24 hours)

## Errors

| Code                   | HTTP Status | Description                     |
| ---------------------- | ----------- | ------------------------------- |
| `INVALID_EMAIL`        | 400         | Email format is invalid         |
| `INSUFFICIENT_CREDITS` | 402         | Not enough verification credits |