mailtester-ninja 1.0.0__tar.gz

mailtester_ninja-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,20 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+permissions:
+  contents: read
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python }}
+      - run: pip install -e ".[test]"
+      - run: pytest -q

mailtester_ninja-1.0.0/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish to PyPI
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[test]" build
+      - run: pytest -q
+      - run: python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

mailtester_ninja-1.0.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/

mailtester_ninja-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MailTester Ninja (Unlimited & Limited)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mailtester_ninja-1.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.5
+Name: mailtester-ninja
+Version: 1.0.0
+Summary: Official client for the MailTester Ninja email verification API: check in real time if an email address is valid and deliverable.
+Project-URL: Homepage, https://mailtester.ninja
+Project-URL: Documentation, https://mailtester.ninja/api/
+Project-URL: Source, https://github.com/mailtester-ninja/mailtester-python
+Project-URL: Issues, https://github.com/mailtester-ninja/mailtester-python/issues
+Project-URL: OpenAPI specification, https://mailtester.ninja/openapi.json
+Author-email: MailTester Ninja <contact@mailtester.ninja>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: catch-all,disposable email,email,email checker,email validation,email verification,email verifier,mailtester,smtp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Communications :: Email
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# MailTester Ninja for Python
+
+Official client for the [MailTester Ninja](https://mailtester.ninja) email verification API. Check in real time whether an email address is valid and deliverable: each address is checked against the recipient's mail server, and nothing is stored.
+
+- No dependencies (standard library only), typed, Python 3.9+
+- Free to try: no signup with `key="free"`, or a [free API token](https://mailtester.ninja/free-email-verification-api/) for 50 checks a day
+
+```bash
+pip install mailtester-ninja
+```
+
+## Quickstart
+
+```python
+from mailtester_ninja import MailTester
+
+mt = MailTester()  # reads MAILTESTER_KEY, falls back to "free"
+
+result = mt.verify("info@apple.com")
+print(result.code, result.message)  # ok Accepted
+```
+
+## Reading the verdict
+
+Branch on `code`, show `message` to people.
+
+| `code` | Meaning | Typical `message` |
+|--------|---------|-------------------|
+| `ok` | Valid and deliverable | Accepted |
+| `ko` | Invalid, will bounce | Rejected, No MX, Disposable, Limited |
+| `mb` | Uncertain: catch-all domain, or the server could not be probed | Catch-All, MX Error, Timeout, SPAM Block, Greylisted |
+
+A catch-all domain is never reported as valid. Shortcuts: `result.is_valid`, `result.is_invalid`, `result.is_uncertain`, and `mt.is_deliverable(email)`.
+
+## Verify a list
+
+`verify_many` checks one address at a time and paces the calls for you: 30 seconds apart on the free tier, 1 second with a paid key (override with `delay`). Errors are reported per address, the loop keeps going.
+
+```python
+for email, result, error in mt.verify_many(["info@apple.com", "someone@example.com"]):
+    if error:
+        print(email, "no verdict:", error.message)
+    else:
+        print(email, result.code, result.message)
+```
+
+## Errors
+
+An error is never a verdict: do not drop an address because of it.
+
+| Exception | When |
+|-----------|------|
+| `MailTesterKeyError` | The key is invalid or disabled. |
+| `MailTesterRateLimitError` | A limit was reached (HTTP 429). `retry_after` is set on the free tier. |
+| `MailTesterError` | Any other HTTP or network error (`status` when there is one). |
+
+## Keys and limits
+
+| Key | Daily checks | Pace |
+|-----|--------------|------|
+| `free` | 10 per IP | 1 request every 30 s |
+| Free token `mtf_...` ([get one](https://mailtester.ninja/free-email-verification-api/)) | 50 per token | 1 request every 30 s |
+| Paid key `sub_...` ([plans](https://mailtester.ninja/verify-emails-unlimited/)) | 100,000 to 200,000+ | daily limit / 8640 per 10 s (Pro 11, Ultimate 23) |
+
+Options: `MailTester(key=None, base_url=..., timeout=60.0)`. The key defaults to the `MAILTESTER_KEY` environment variable, then to `free`.
+
+## Links
+
+- [API documentation](https://mailtester.ninja/api/) and [OpenAPI 3.1 specification](https://mailtester.ninja/openapi.json)
+- [Integrations](https://mailtester.ninja/integrations/): n8n, Zapier, Make, Clay, Google Sheets
+- [Code examples](https://github.com/mailtester-ninja/mailtester-api-examples) for other languages
+- [JavaScript and TypeScript client](https://www.npmjs.com/package/@mailtester-ninja/client)
+
+## License
+
+MIT

mailtester_ninja-1.0.0/README.md

@@ -0,0 +1,76 @@
+# MailTester Ninja for Python
+
+Official client for the [MailTester Ninja](https://mailtester.ninja) email verification API. Check in real time whether an email address is valid and deliverable: each address is checked against the recipient's mail server, and nothing is stored.
+
+- No dependencies (standard library only), typed, Python 3.9+
+- Free to try: no signup with `key="free"`, or a [free API token](https://mailtester.ninja/free-email-verification-api/) for 50 checks a day
+
+```bash
+pip install mailtester-ninja
+```
+
+## Quickstart
+
+```python
+from mailtester_ninja import MailTester
+
+mt = MailTester()  # reads MAILTESTER_KEY, falls back to "free"
+
+result = mt.verify("info@apple.com")
+print(result.code, result.message)  # ok Accepted
+```
+
+## Reading the verdict
+
+Branch on `code`, show `message` to people.
+
+| `code` | Meaning | Typical `message` |
+|--------|---------|-------------------|
+| `ok` | Valid and deliverable | Accepted |
+| `ko` | Invalid, will bounce | Rejected, No MX, Disposable, Limited |
+| `mb` | Uncertain: catch-all domain, or the server could not be probed | Catch-All, MX Error, Timeout, SPAM Block, Greylisted |
+
+A catch-all domain is never reported as valid. Shortcuts: `result.is_valid`, `result.is_invalid`, `result.is_uncertain`, and `mt.is_deliverable(email)`.
+
+## Verify a list
+
+`verify_many` checks one address at a time and paces the calls for you: 30 seconds apart on the free tier, 1 second with a paid key (override with `delay`). Errors are reported per address, the loop keeps going.
+
+```python
+for email, result, error in mt.verify_many(["info@apple.com", "someone@example.com"]):
+    if error:
+        print(email, "no verdict:", error.message)
+    else:
+        print(email, result.code, result.message)
+```
+
+## Errors
+
+An error is never a verdict: do not drop an address because of it.
+
+| Exception | When |
+|-----------|------|
+| `MailTesterKeyError` | The key is invalid or disabled. |
+| `MailTesterRateLimitError` | A limit was reached (HTTP 429). `retry_after` is set on the free tier. |
+| `MailTesterError` | Any other HTTP or network error (`status` when there is one). |
+
+## Keys and limits
+
+| Key | Daily checks | Pace |
+|-----|--------------|------|
+| `free` | 10 per IP | 1 request every 30 s |
+| Free token `mtf_...` ([get one](https://mailtester.ninja/free-email-verification-api/)) | 50 per token | 1 request every 30 s |
+| Paid key `sub_...` ([plans](https://mailtester.ninja/verify-emails-unlimited/)) | 100,000 to 200,000+ | daily limit / 8640 per 10 s (Pro 11, Ultimate 23) |
+
+Options: `MailTester(key=None, base_url=..., timeout=60.0)`. The key defaults to the `MAILTESTER_KEY` environment variable, then to `free`.
+
+## Links
+
+- [API documentation](https://mailtester.ninja/api/) and [OpenAPI 3.1 specification](https://mailtester.ninja/openapi.json)
+- [Integrations](https://mailtester.ninja/integrations/): n8n, Zapier, Make, Clay, Google Sheets
+- [Code examples](https://github.com/mailtester-ninja/mailtester-api-examples) for other languages
+- [JavaScript and TypeScript client](https://www.npmjs.com/package/@mailtester-ninja/client)
+
+## License
+
+MIT

mailtester_ninja-1.0.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["hatchling>=1.27"]
+build-backend = "hatchling.build"
+
+[project]
+name = "mailtester-ninja"
+version = "1.0.0"
+description = "Official client for the MailTester Ninja email verification API: check in real time if an email address is valid and deliverable."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "MailTester Ninja", email = "contact@mailtester.ninja" }]
+keywords = ["email", "email verification", "email validation", "email verifier", "email checker", "smtp", "catch-all", "disposable email", "mailtester"]
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Communications :: Email",
+  "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[project.urls]
+Homepage = "https://mailtester.ninja"
+Documentation = "https://mailtester.ninja/api/"
+Source = "https://github.com/mailtester-ninja/mailtester-python"
+Issues = "https://github.com/mailtester-ninja/mailtester-python/issues"
+"OpenAPI specification" = "https://mailtester.ninja/openapi.json"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mailtester_ninja"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]

mailtester_ninja-1.0.0/src/mailtester_ninja/__init__.py

@@ -0,0 +1,23 @@
+"""Official Python client for the MailTester Ninja email verification API."""
+
+from .client import (
+    DEFAULT_BASE_URL,
+    FREE_KEY,
+    MailTester,
+    MailTesterError,
+    MailTesterKeyError,
+    MailTesterRateLimitError,
+    VerificationResult,
+    __version__,
+)
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "FREE_KEY",
+    "MailTester",
+    "MailTesterError",
+    "MailTesterKeyError",
+    "MailTesterRateLimitError",
+    "VerificationResult",
+    "__version__",
+]

mailtester_ninja-1.0.0/src/mailtester_ninja/client.py

@@ -0,0 +1,190 @@
+"""Official Python client for the MailTester Ninja email verification API.
+
+https://mailtester.ninja/api/
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any, Dict, Iterable, Iterator, Optional
+
+__version__ = "1.0.0"
+
+DEFAULT_BASE_URL = "https://happy.mailtester.ninja"
+FREE_KEY = "free"  # keyless free tier: 10 checks a day per IP, one request every 30 seconds
+
+
+class MailTesterError(Exception):
+    """Any error returned by the API or the network. Never a verdict: do not drop the address on it."""
+
+    def __init__(self, message: str, status: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+
+
+class MailTesterKeyError(MailTesterError):
+    """The key is invalid or disabled (``code`` "--")."""
+
+
+class MailTesterRateLimitError(MailTesterError):
+    """A limit was reached (HTTP 429). ``retry_after`` is set when the API says how long to wait."""
+
+    def __init__(self, message: str, retry_after: Optional[int] = None) -> None:
+        super().__init__(message, 429)
+        self.retry_after = retry_after
+
+
+@dataclass(frozen=True)
+class VerificationResult:
+    """Verdict for one address.
+
+    ``code``: "ok" valid and deliverable, "ko" invalid, "mb" uncertain (catch-all or not probeable).
+    ``message``: human-readable label (Accepted, Rejected, Catch-All, No MX, Disposable, Timeout...).
+    """
+
+    code: str
+    message: str
+    email: str
+    user: str = ""
+    domain: Optional[str] = None
+    mx: str = ""
+    connections: int = 0
+    limit: int = 0
+    rate: int = 0
+    raw: Dict[str, Any] = field(default_factory=dict, repr=False, compare=False)
+
+    @property
+    def is_valid(self) -> bool:
+        return self.code == "ok"
+
+    @property
+    def is_invalid(self) -> bool:
+        return self.code == "ko"
+
+    @property
+    def is_uncertain(self) -> bool:
+        return self.code == "mb"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "VerificationResult":
+        def as_int(value: Any) -> int:
+            try:
+                return int(value or 0)
+            except (TypeError, ValueError):
+                return 0
+
+        return cls(
+            code=str(data.get("code", "")),
+            message=str(data.get("message", "")),
+            email=str(data.get("email", "")),
+            user=str(data.get("user") or ""),
+            domain=data.get("domain"),
+            mx=str(data.get("mx") or ""),
+            connections=as_int(data.get("connections")),
+            limit=as_int(data.get("limit")),
+            rate=as_int(data.get("rate")),
+            raw=dict(data),
+        )
+
+
+def _retry_after(message: str) -> Optional[int]:
+    match = re.search(r"retry in (\d+)\s*s", message, re.IGNORECASE)
+    return int(match.group(1)) if match else None
+
+
+class MailTester:
+    """Client for the MailTester Ninja API.
+
+    ``key``: "free" (no signup), a free token "mtf_..." from
+    https://mailtester.ninja/free-email-verification-api/, or a subscription key "sub_...".
+    Defaults to the MAILTESTER_KEY environment variable, then to "free".
+    """
+
+    def __init__(self, key: Optional[str] = None, base_url: str = DEFAULT_BASE_URL, timeout: float = 60.0) -> None:
+        raw_key = key if key is not None else (os.environ.get("MAILTESTER_KEY") or FREE_KEY)
+        self.key = raw_key.strip().strip("{}")
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    @property
+    def is_free(self) -> bool:
+        """True on the free tier ("free" or a free token), limited to one request every 30 seconds."""
+        return self.key == FREE_KEY or self.key.startswith("mtf_")
+
+    def _get(self, email: str) -> "tuple[int, str]":
+        query = urllib.parse.urlencode({"email": email.strip(), "key": self.key})
+        request = urllib.request.Request(
+            f"{self.base_url}/ninja?{query}",
+            headers={"Accept": "application/json", "User-Agent": f"mailtester-ninja-python/{__version__}"},
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                return response.status, response.read().decode("utf-8", "replace")
+        except urllib.error.HTTPError as err:
+            return err.code, err.read().decode("utf-8", "replace")
+        except (urllib.error.URLError, OSError) as err:
+            reason = getattr(err, "reason", err)
+            raise MailTesterError(f"Network error: {reason}") from err
+
+    def verify(self, email: str) -> VerificationResult:
+        """Verify one address. Returns a verdict, raises a MailTesterError when there is none."""
+        status, text = self._get(email)
+        try:
+            body = json.loads(text)
+        except ValueError:
+            body = None
+        if not isinstance(body, dict):
+            body = None
+        message = str(body.get("message", "")) if body else text.strip()
+        if status == 429:
+            raise MailTesterRateLimitError(message, _retry_after(message))
+        if status >= 400:
+            raise MailTesterError(message or f"HTTP {status}", status)
+        if body is None:
+            raise MailTesterError("Unexpected response from the API", status)
+        if body.get("code") == "--":
+            raise MailTesterKeyError(message, status)
+        return VerificationResult.from_dict(body)
+
+    def is_deliverable(self, email: str) -> bool:
+        """True only when the address is clearly valid and deliverable ("ok")."""
+        return self.verify(email).is_valid
+
+    def verify_many(
+        self, emails: Iterable[str], delay: Optional[float] = None, retry_on_limit: bool = True
+    ) -> Iterator["tuple[str, Optional[VerificationResult], Optional[MailTesterError]]"]:
+        """Verify a list one address at a time, pacing the calls to respect the rate limit.
+
+        Yields ``(email, result, None)`` or ``(email, None, error)`` for each non-empty address.
+        ``delay`` defaults to 30 seconds on the free tier and 1 second with a paid key.
+        """
+        pause = delay if delay is not None else (30.0 if self.is_free else 1.0)
+        first = True
+        for raw in emails:
+            email = str(raw).strip()
+            if not email:
+                continue
+            if not first and pause > 0:
+                time.sleep(pause)
+            first = False
+            try:
+                yield email, self.verify(email), None
+            except MailTesterRateLimitError as err:
+                if retry_on_limit and err.retry_after is not None:
+                    time.sleep(err.retry_after + 1)
+                    try:
+                        yield email, self.verify(email), None
+                    except MailTesterError as err2:
+                        yield email, None, err2
+                else:
+                    yield email, None, err
+            except MailTesterError as err:
+                yield email, None, err

mailtester_ninja-1.0.0/tests/test_client.py

@@ -0,0 +1,132 @@
+import io
+import json
+import os
+import urllib.error
+
+import pytest
+
+from mailtester_ninja import (
+    MailTester,
+    MailTesterError,
+    MailTesterKeyError,
+    MailTesterRateLimitError,
+    VerificationResult,
+)
+
+OK = {"code": "ok", "message": "Accepted", "domain": "apple.com", "mx": "mx-in.g.apple.com",
+      "connections": 1, "limit": 100000, "rate": 1, "email": "info@apple.com", "user": "Info"}
+
+
+def fake(replies, calls=None):
+    replies = list(replies)
+
+    def _get(self, email):
+        if calls is not None:
+            calls.append(email)
+        return replies.pop(0) if len(replies) > 1 else replies[0]
+    return _get
+
+
+def test_verify_returns_result(monkeypatch):
+    monkeypatch.setattr(MailTester, "_get", fake([(200, json.dumps(OK))]))
+    r = MailTester("sub_1").verify("info@apple.com")
+    assert isinstance(r, VerificationResult)
+    assert r.code == "ok" and r.message == "Accepted" and r.is_valid
+    assert r.limit == 100000 and r.raw["mx"] == "mx-in.g.apple.com"
+
+
+def test_key_handling(monkeypatch):
+    monkeypatch.delenv("MAILTESTER_KEY", raising=False)
+    assert MailTester().key == "free" and MailTester().is_free
+    assert MailTester("{sub_abc}").key == "sub_abc"
+    assert MailTester("mtf_x").is_free and not MailTester("sub_x").is_free
+    monkeypatch.setenv("MAILTESTER_KEY", "sub_env")
+    assert MailTester().key == "sub_env"
+
+
+def test_request_url_and_headers(monkeypatch):
+    seen = {}
+
+    class Resp(io.BytesIO):
+        status = 200
+        def __enter__(self):
+            return self
+        def __exit__(self, *a):
+            return False
+
+    def urlopen(req, timeout=None):
+        seen["url"] = req.full_url
+        seen["accept"] = req.get_header("Accept")
+        return Resp(json.dumps(OK).encode())
+
+    monkeypatch.setattr("urllib.request.urlopen", urlopen)
+    MailTester("sub_1").verify(" info@apple.com ")
+    assert seen["url"] == "https://happy.mailtester.ninja/ninja?email=info%40apple.com&key=sub_1"
+    assert seen["accept"] == "application/json"
+
+
+def test_http_error_body_is_read(monkeypatch):
+    def urlopen(req, timeout=None):
+        raise urllib.error.HTTPError(req.full_url, 403, "Forbidden", {}, io.BytesIO(b"Missing email param"))
+    monkeypatch.setattr("urllib.request.urlopen", urlopen)
+    with pytest.raises(MailTesterError) as e:
+        MailTester("sub_1").verify("")
+    assert e.value.status == 403 and e.value.message == "Missing email param"
+
+
+def test_network_error(monkeypatch):
+    def urlopen(req, timeout=None):
+        raise urllib.error.URLError("unreachable")
+    monkeypatch.setattr("urllib.request.urlopen", urlopen)
+    with pytest.raises(MailTesterError, match="Network error"):
+        MailTester("sub_1").verify("a@b.com")
+
+
+def test_invalid_key(monkeypatch):
+    body = dict(OK, code="--", message="Invalid Key", domain=None, limit=0)
+    monkeypatch.setattr(MailTester, "_get", fake([(200, json.dumps(body))]))
+    with pytest.raises(MailTesterKeyError):
+        MailTester("bad").verify("info@apple.com")
+
+
+def test_free_limit(monkeypatch):
+    body = dict(OK, code="--", message="Free API: one request every 30 s, retry in 29 s. Unlimited speed: https://mailtester.ninja/verify-emails-unlimited/")
+    monkeypatch.setattr(MailTester, "_get", fake([(429, json.dumps(body))]))
+    with pytest.raises(MailTesterRateLimitError) as e:
+        MailTester("free").verify("info@apple.com")
+    assert e.value.retry_after == 29 and e.value.status == 429
+
+
+def test_paid_rate_limit_plain_text(monkeypatch):
+    monkeypatch.setattr(MailTester, "_get", fake([(429, "Too Many Requests - Your rate is now 25")]))
+    with pytest.raises(MailTesterRateLimitError) as e:
+        MailTester("sub_1").verify("a@b.com")
+    assert e.value.retry_after is None and "Too Many Requests" in e.value.message
+
+
+def test_is_deliverable(monkeypatch):
+    monkeypatch.setattr(MailTester, "_get", fake([(200, json.dumps(dict(OK, code="ko", message="Rejected")))]))
+    assert MailTester("sub_1").is_deliverable("a@b.com") is False
+
+
+def test_verify_many_continues_after_errors(monkeypatch):
+    calls = []
+    replies = [(200, json.dumps(OK)), (403, "Missing email param"), (200, json.dumps(dict(OK, code="mb", message="Catch-All")))]
+    monkeypatch.setattr(MailTester, "_get", fake(replies, calls))
+    out = list(MailTester("sub_1").verify_many(["info@apple.com", "  ", "x@y.com", "c@d.com"], delay=0))
+    assert [e for e, _, _ in out] == ["info@apple.com", "x@y.com", "c@d.com"]
+    assert out[0][1].code == "ok" and isinstance(out[1][2], MailTesterError) and out[2][1].message == "Catch-All"
+
+
+def test_verify_many_retries_after_free_limit(monkeypatch):
+    limited = dict(OK, code="--", message="Free API: one request every 30 s, retry in 0 s.")
+    monkeypatch.setattr(MailTester, "_get", fake([(429, json.dumps(limited)), (200, json.dumps(OK))]))
+    monkeypatch.setattr("time.sleep", lambda s: None)
+    out = list(MailTester("free").verify_many(["info@apple.com"], delay=0))
+    assert len(out) == 1 and out[0][1].code == "ok"
+
+
+@pytest.mark.skipif(os.environ.get("MAILTESTER_LIVE") != "1", reason="live test: set MAILTESTER_LIVE=1")
+def test_live_free_tier():
+    r = MailTester(os.environ.get("MAILTESTER_KEY") or "free").verify("info@apple.com")
+    assert r.code in ("ok", "ko", "mb")