speedyindex 0.1.0__tar.gz

speedyindex-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,35 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: python -m pip install --upgrade build
+      - run: PYTHONPATH=src python -m unittest discover -s tests -v
+      - 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   # Trusted Publishing: no API token stored anywhere
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

speedyindex-0.1.0/.gitignore

@@ -0,0 +1,4 @@
+dist/
+__pycache__/
+*.egg-info/
+.venv/

speedyindex-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpeedyIndex
+
+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.

speedyindex-0.1.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.5
+Name: speedyindex
+Version: 0.1.0
+Summary: Python client and CLI for the SpeedyIndex API: Google, Bing and Yandex index checks, link indexing tasks and reports.
+Project-URL: Homepage, https://en.speedyindex.com/
+Project-URL: Documentation, https://en.speedyindex.com/api.php
+Project-URL: Source, https://github.com/uskotoivo81-netizen/speedyindex-python
+Author: SpeedyIndex
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backlinks,bing,google index checker,indexing,search console,seo,speedyindex,yandex
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# speedyindex — Python client for the SpeedyIndex API
+
+`speedyindex` is a small, dependency-free Python client and command-line tool for SpeedyIndex, a service for link indexing and Google, Bing and Yandex index checking. It wraps the public [SpeedyIndex API](https://en.speedyindex.com/api.php) v2, so you can check whether a list of URLs is indexed, submit links for indexing and pull reports from scripts, cron jobs or CI.
+
+- Standard library only (`urllib`), Python 3.8+
+- Index checks for Google, Bing and Yandex
+- Link indexing tasks for Google and Yandex, with optional drip-feed
+- Task status, task list and full reports
+- Backlink checks: find links to your domains on donor pages
+- `speedyindex` CLI for quick jobs from the shell
+
+## Install
+
+```bash
+pip install speedyindex
+```
+
+## API key
+
+Every request needs an API key. You can find it in your SpeedyIndex dashboard or in the SpeedyIndex Telegram bot settings. The client reads it from the `SPEEDYINDEX_API_KEY` environment variable:
+
+```bash
+export SPEEDYINDEX_API_KEY="your-key"
+```
+
+Keep the key out of source code and commit history; use environment variables or your CI secret store.
+
+## Quick start (Python)
+
+```python
+from speedyindex import SpeedyIndex
+
+si = SpeedyIndex()  # reads SPEEDYINDEX_API_KEY
+
+print(si.balance())
+
+# Check which URLs are in Google's index
+task = si.create_task(
+    ["https://example.com/", "https://example.com/blog/post-1"],
+    engine="google",
+    task_type="checker",
+    title="blog check",
+)
+print(task)
+
+# Later: progress and the full report
+task_id = si.list_tasks(engine="google")["result"][0]["id"]  # newest task
+status = si.task_status([task_id], engine="google", task_type="checker")
+report = si.full_report(task_id, engine="google", task_type="checker")
+```
+
+Submit links for indexing, spread over several days:
+
+```python
+si.create_task(urls, engine="google", task_type="indexer", drip_feed=True, drip_feed_days=7)
+```
+
+Check donor pages for links to your site:
+
+```python
+si.create_backlink_check(["https://donor.example/page"], target_domains=["mysite.com"])
+```
+
+## Command line
+
+```bash
+speedyindex balance
+speedyindex check urls.txt --engine google --title "weekly check"
+speedyindex check urls.txt --engine bing
+speedyindex index urls.txt --engine google --drip-feed-days 5
+speedyindex status 65f8c7315752853b9171860a --type checker
+speedyindex report 65f8c7315752853b9171860a --type checker > report.json
+speedyindex tasks --engine google --page 0
+speedyindex backlinks donors.txt --target mysite.com
+```
+
+`urls.txt` holds one URL per line; empty lines and lines starting with `#` are skipped, duplicates are removed. Use `-` to read URLs from stdin:
+
+```bash
+cat sitemap-urls.txt | speedyindex check - --engine google
+```
+
+## Limits the client enforces
+
+| Rule | Value |
+|---|---|
+| URLs per task | up to 10,000 |
+| Task IDs per status request | up to 1,000 |
+| Drip-feed days | 2–30, and at least as many URLs as days |
+| Bing | `checker` tasks only |
+| Google `indexer` | always sent with `pay_per_indexed: true` (the only mode the API accepts) |
+
+API error codes are raised as `SpeedyIndexError` with `.code`: `1` means the balance is too low, `2` means a validation error.
+
+## Tips before you run an index check
+
+- Clean the list first: remove UTM parameters, fragments and duplicates.
+- Check status codes and `noindex` before submitting: a 404 or a `noindex` page will not be indexed whatever you do.
+- Google's own [URL Inspection tool](https://support.google.com/webmasters/answer/9012289) remains the reference for a single URL on a site you own.
+
+## License
+
+MIT

speedyindex-0.1.0/README.md

@@ -0,0 +1,103 @@
+# speedyindex — Python client for the SpeedyIndex API
+
+`speedyindex` is a small, dependency-free Python client and command-line tool for SpeedyIndex, a service for link indexing and Google, Bing and Yandex index checking. It wraps the public [SpeedyIndex API](https://en.speedyindex.com/api.php) v2, so you can check whether a list of URLs is indexed, submit links for indexing and pull reports from scripts, cron jobs or CI.
+
+- Standard library only (`urllib`), Python 3.8+
+- Index checks for Google, Bing and Yandex
+- Link indexing tasks for Google and Yandex, with optional drip-feed
+- Task status, task list and full reports
+- Backlink checks: find links to your domains on donor pages
+- `speedyindex` CLI for quick jobs from the shell
+
+## Install
+
+```bash
+pip install speedyindex
+```
+
+## API key
+
+Every request needs an API key. You can find it in your SpeedyIndex dashboard or in the SpeedyIndex Telegram bot settings. The client reads it from the `SPEEDYINDEX_API_KEY` environment variable:
+
+```bash
+export SPEEDYINDEX_API_KEY="your-key"
+```
+
+Keep the key out of source code and commit history; use environment variables or your CI secret store.
+
+## Quick start (Python)
+
+```python
+from speedyindex import SpeedyIndex
+
+si = SpeedyIndex()  # reads SPEEDYINDEX_API_KEY
+
+print(si.balance())
+
+# Check which URLs are in Google's index
+task = si.create_task(
+    ["https://example.com/", "https://example.com/blog/post-1"],
+    engine="google",
+    task_type="checker",
+    title="blog check",
+)
+print(task)
+
+# Later: progress and the full report
+task_id = si.list_tasks(engine="google")["result"][0]["id"]  # newest task
+status = si.task_status([task_id], engine="google", task_type="checker")
+report = si.full_report(task_id, engine="google", task_type="checker")
+```
+
+Submit links for indexing, spread over several days:
+
+```python
+si.create_task(urls, engine="google", task_type="indexer", drip_feed=True, drip_feed_days=7)
+```
+
+Check donor pages for links to your site:
+
+```python
+si.create_backlink_check(["https://donor.example/page"], target_domains=["mysite.com"])
+```
+
+## Command line
+
+```bash
+speedyindex balance
+speedyindex check urls.txt --engine google --title "weekly check"
+speedyindex check urls.txt --engine bing
+speedyindex index urls.txt --engine google --drip-feed-days 5
+speedyindex status 65f8c7315752853b9171860a --type checker
+speedyindex report 65f8c7315752853b9171860a --type checker > report.json
+speedyindex tasks --engine google --page 0
+speedyindex backlinks donors.txt --target mysite.com
+```
+
+`urls.txt` holds one URL per line; empty lines and lines starting with `#` are skipped, duplicates are removed. Use `-` to read URLs from stdin:
+
+```bash
+cat sitemap-urls.txt | speedyindex check - --engine google
+```
+
+## Limits the client enforces
+
+| Rule | Value |
+|---|---|
+| URLs per task | up to 10,000 |
+| Task IDs per status request | up to 1,000 |
+| Drip-feed days | 2–30, and at least as many URLs as days |
+| Bing | `checker` tasks only |
+| Google `indexer` | always sent with `pay_per_indexed: true` (the only mode the API accepts) |
+
+API error codes are raised as `SpeedyIndexError` with `.code`: `1` means the balance is too low, `2` means a validation error.
+
+## Tips before you run an index check
+
+- Clean the list first: remove UTM parameters, fragments and duplicates.
+- Check status codes and `noindex` before submitting: a 404 or a `noindex` page will not be indexed whatever you do.
+- Google's own [URL Inspection tool](https://support.google.com/webmasters/answer/9012289) remains the reference for a single URL on a site you own.
+
+## License
+
+MIT

speedyindex-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "speedyindex"
+version = "0.1.0"
+description = "Python client and CLI for the SpeedyIndex API: Google, Bing and Yandex index checks, link indexing tasks and reports."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.8"
+authors = [{ name = "SpeedyIndex" }]
+keywords = ["seo", "google index checker", "indexing", "backlinks", "speedyindex", "search console", "bing", "yandex"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Internet :: WWW/HTTP :: Indexing/Search",
+  "Environment :: Console",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://en.speedyindex.com/"
+Documentation = "https://en.speedyindex.com/api.php"
+Source = "https://github.com/uskotoivo81-netizen/speedyindex-python"
+
+[project.scripts]
+speedyindex = "speedyindex.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/speedyindex"]

speedyindex-0.1.0/src/speedyindex/__init__.py

@@ -0,0 +1,6 @@
+"""Python client and CLI for the SpeedyIndex API v2."""
+
+from .client import DEFAULT_BASE_URL, SpeedyIndex, SpeedyIndexError
+
+__all__ = ["SpeedyIndex", "SpeedyIndexError", "DEFAULT_BASE_URL"]
+__version__ = "0.1.0"

speedyindex-0.1.0/src/speedyindex/cli.py

@@ -0,0 +1,86 @@
+"""Command-line interface: ``speedyindex <command>``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import List, Optional
+
+from . import __version__
+from .client import SpeedyIndex, SpeedyIndexError
+
+
+def _read_urls(path: str) -> List[str]:
+    stream = sys.stdin if path == "-" else open(path, encoding="utf-8")
+    with stream:
+        return [line.strip() for line in stream if line.strip()]
+
+
+def _print(data) -> None:
+    print(json.dumps(data, indent=2, ensure_ascii=False))
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="speedyindex", description="SpeedyIndex API v2 command-line client")
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    p.add_argument("--api-key", help="API key (default: SPEEDYINDEX_API_KEY env var)")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    sub.add_parser("balance", help="show account balance")
+
+    for name, ttype in (("check", "checker"), ("index", "indexer")):
+        s = sub.add_parser(name, help=f"create a {ttype} task from a file of URLs (one per line, '-' for stdin)")
+        s.add_argument("file")
+        s.add_argument("--engine", default="google", choices=["google", "yandex", "bing"])
+        s.add_argument("--title")
+        s.add_argument("--drip-feed-days", type=int, help="spread submission over N days (2-30)")
+        s.set_defaults(task_type=ttype)
+
+    s = sub.add_parser("status", help="status of one or more tasks")
+    s.add_argument("task_ids", nargs="+")
+    s.add_argument("--engine", default="google")
+    s.add_argument("--type", dest="task_type", default="checker", choices=["checker", "indexer"])
+
+    s = sub.add_parser("report", help="full report of a task")
+    s.add_argument("task_id")
+    s.add_argument("--engine", default="google")
+    s.add_argument("--type", dest="task_type", default="checker", choices=["checker", "indexer"])
+
+    s = sub.add_parser("tasks", help="list tasks")
+    s.add_argument("--engine", default="google")
+    s.add_argument("--page", type=int, default=0)
+
+    s = sub.add_parser("backlinks", help="check donor pages for links to your domains")
+    s.add_argument("file")
+    s.add_argument("--target", action="append", required=True, help="your domain, repeatable")
+    return p
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        client = SpeedyIndex(api_key=args.api_key)
+        if args.command == "balance":
+            _print(client.balance())
+        elif args.command in ("check", "index"):
+            _print(client.create_task(
+                _read_urls(args.file), engine=args.engine, task_type=args.task_type, title=args.title,
+                drip_feed=bool(args.drip_feed_days), drip_feed_days=args.drip_feed_days,
+            ))
+        elif args.command == "status":
+            _print(client.task_status(args.task_ids, engine=args.engine, task_type=args.task_type))
+        elif args.command == "report":
+            _print(client.full_report(args.task_id, engine=args.engine, task_type=args.task_type))
+        elif args.command == "tasks":
+            _print(client.list_tasks(engine=args.engine, page=args.page))
+        elif args.command == "backlinks":
+            _print(client.create_backlink_check(_read_urls(args.file), args.target))
+    except (SpeedyIndexError, ValueError, OSError) as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

speedyindex-0.1.0/src/speedyindex/client.py

@@ -0,0 +1,183 @@
+"""Minimal client for the SpeedyIndex API v2 (standard library only)."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any, Dict, Iterable, List, Optional
+
+DEFAULT_BASE_URL = "https://api.speedyindex.com"
+ENGINES = ("google", "yandex", "bing")
+TASK_TYPES = ("indexer", "checker")
+MAX_URLS_PER_TASK = 10_000
+MAX_TASK_IDS = 1_000
+
+
+class SpeedyIndexError(Exception):
+    """Raised when the API returns a non-zero code or an HTTP error."""
+
+    def __init__(self, message: str, code: Optional[int] = None, payload: Any = None):
+        super().__init__(message)
+        self.code = code
+        self.payload = payload
+
+
+def _check_engine(engine: str, task_type: Optional[str] = None) -> None:
+    if engine not in ENGINES:
+        raise ValueError(f"engine must be one of {ENGINES}, got {engine!r}")
+    if task_type is not None:
+        if task_type not in TASK_TYPES:
+            raise ValueError(f"task_type must be one of {TASK_TYPES}, got {task_type!r}")
+        if engine == "bing" and task_type != "checker":
+            raise ValueError("Bing supports only the 'checker' task type")
+
+
+def _clean_urls(urls: Iterable[str]) -> List[str]:
+    seen = set()
+    result = []
+    for url in urls:
+        url = url.strip()
+        if url and not url.startswith("#") and url not in seen:
+            seen.add(url)
+            result.append(url)
+    return result
+
+
+class SpeedyIndex:
+    """Client for the SpeedyIndex API v2.
+
+    The API key is read from ``api_key`` or the ``SPEEDYINDEX_API_KEY``
+    environment variable. It is sent in the ``Authorization`` header.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 60.0,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("SPEEDYINDEX_API_KEY")
+        if not self.api_key:
+            raise SpeedyIndexError(
+                "No API key: pass api_key=... or set SPEEDYINDEX_API_KEY"
+            )
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    # -- transport -------------------------------------------------------
+    def _request(self, method: str, path: str, body: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        data = json.dumps(body).encode("utf-8") if body is not None else None
+        req = urllib.request.Request(self.base_url + path, data=data, method=method)
+        req.add_header("Authorization", self.api_key)
+        req.add_header("Accept", "application/json")
+        req.add_header("User-Agent", "speedyindex-python")
+        if data is not None:
+            req.add_header("Content-Type", "application/json")
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8")
+        except urllib.error.HTTPError as exc:
+            raise SpeedyIndexError(f"HTTP {exc.code} for {path}", code=exc.code) from exc
+        try:
+            payload = json.loads(raw)
+        except ValueError as exc:
+            raise SpeedyIndexError(f"Non-JSON response for {path}", payload=raw) from exc
+        code = payload.get("code") if isinstance(payload, dict) else None
+        if code not in (0, None):
+            messages = {1: "insufficient balance", 2: "validation error"}
+            raise SpeedyIndexError(
+                f"API error {code}: {messages.get(code, 'see payload')}", code=code, payload=payload
+            )
+        return payload
+
+    # -- account ---------------------------------------------------------
+    def balance(self) -> Dict[str, Any]:
+        """GET /v2/account - current balance."""
+        return self._request("GET", "/v2/account")["balance"]
+
+    # -- tasks -----------------------------------------------------------
+    def create_task(
+        self,
+        urls: Iterable[str],
+        engine: str = "google",
+        task_type: str = "checker",
+        title: Optional[str] = None,
+        pay_per_indexed: Optional[bool] = None,
+        drip_feed: bool = False,
+        drip_feed_days: Optional[int] = None,
+    ) -> Dict[str, Any]:
+        """POST /v2/task/<engine>/<type>/create.
+
+        For ``google``/``indexer`` the API accepts only ``pay_per_indexed=True``,
+        so it is set automatically. Up to 10,000 URLs per request.
+        """
+        _check_engine(engine, task_type)
+        url_list = _clean_urls(urls)
+        if not url_list:
+            raise ValueError("urls is empty")
+        if len(url_list) > MAX_URLS_PER_TASK:
+            raise ValueError(f"max {MAX_URLS_PER_TASK} URLs per task, got {len(url_list)}")
+        body: Dict[str, Any] = {"urls": url_list}
+        if title:
+            body["title"] = title
+        if engine == "google" and task_type == "indexer":
+            pay_per_indexed = True
+        if pay_per_indexed is not None:
+            body["pay_per_indexed"] = pay_per_indexed
+        if drip_feed:
+            if not drip_feed_days or not 2 <= drip_feed_days <= 30:
+                raise ValueError("drip_feed_days must be between 2 and 30")
+            if len(url_list) < drip_feed_days:
+                raise ValueError("number of URLs must be >= drip_feed_days")
+            body["drip_feed"] = True
+            body["drip_feed_days"] = drip_feed_days
+        return self._request("POST", f"/v2/task/{engine}/{task_type}/create", body)
+
+    def list_tasks(self, engine: str = "google", page: int = 0) -> Dict[str, Any]:
+        """GET /v2/task/<engine>/list/<page> - 1000 tasks per page, newest first."""
+        _check_engine(engine)
+        return self._request("GET", f"/v2/task/{engine}/list/{int(page)}")
+
+    def task_status(self, task_ids: Iterable[str], engine: str = "google", task_type: str = "checker") -> Dict[str, Any]:
+        """POST /v2/task/<engine>/<type>/status - up to 1000 task IDs."""
+        _check_engine(engine, task_type)
+        ids = list(task_ids)
+        if len(ids) > MAX_TASK_IDS:
+            raise ValueError(f"max {MAX_TASK_IDS} task IDs per request")
+        return self._request("POST", f"/v2/task/{engine}/{task_type}/status", {"task_ids": ids})
+
+    def full_report(self, task_id: str, engine: str = "google", task_type: str = "checker") -> Dict[str, Any]:
+        """POST /v2/task/<engine>/<type>/fullreport - indexed and unindexed links."""
+        _check_engine(engine, task_type)
+        return self._request("POST", f"/v2/task/{engine}/{task_type}/fullreport", {"task_id": task_id})
+
+    # -- single link -----------------------------------------------------
+    def index_url(self, url: str, engine: str = "google") -> Dict[str, Any]:
+        """POST /v2/<engine>/url - submit one link (google or yandex)."""
+        if engine not in ("google", "yandex"):
+            raise ValueError("single-link submission supports google and yandex")
+        return self._request("POST", f"/v2/{engine}/url", {"url": url})
+
+    # -- backlink checker ------------------------------------------------
+    def create_backlink_check(self, urls: Iterable[str], target_domains: Iterable[str]) -> Dict[str, Any]:
+        """POST /v2/task/backlink/checker/create - look for links to your domains on donor pages."""
+        url_list = _clean_urls(urls)
+        if not url_list:
+            raise ValueError("urls is empty")
+        if len(url_list) > MAX_URLS_PER_TASK:
+            raise ValueError(f"max {MAX_URLS_PER_TASK} URLs per task")
+        return self._request(
+            "POST",
+            "/v2/task/backlink/checker/create",
+            {"urls": url_list, "target_domains": list(target_domains)},
+        )
+
+    def backlink_report(self, task_id: str, page: int = 0, limit: int = 50) -> Dict[str, Any]:
+        """POST /v2/task/backlink/checker/report - per-donor details."""
+        return self._request(
+            "POST",
+            "/v2/task/backlink/checker/report",
+            {"task_id": task_id, "page": page, "limit": limit},
+        )

speedyindex-0.1.0/tests/test_client.py

@@ -0,0 +1,78 @@
+import json
+import unittest
+from unittest import mock
+
+from speedyindex import SpeedyIndex, SpeedyIndexError
+from speedyindex.cli import main
+
+
+class FakeResp:
+    def __init__(self, payload):
+        self._b = json.dumps(payload).encode()
+
+    def read(self):
+        return self._b
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+
+class ClientTests(unittest.TestCase):
+    def setUp(self):
+        self.si = SpeedyIndex(api_key="k")
+
+    def _capture(self, payload):
+        calls = []
+
+        def fake(req, timeout=None):
+            calls.append(req)
+            return FakeResp(payload)
+
+        return calls, mock.patch("urllib.request.urlopen", fake)
+
+    def test_balance_and_auth_header(self):
+        calls, p = self._capture({"code": 0, "balance": {"tokens": 1}})
+        with p:
+            self.assertEqual(self.si.balance(), {"tokens": 1})
+        self.assertEqual(calls[0].get_header("Authorization"), "k")
+        self.assertTrue(calls[0].full_url.endswith("/v2/account"))
+
+    def test_google_indexer_forces_pay_per_indexed_and_dedupes(self):
+        calls, p = self._capture({"code": 0, "task_id": "x"})
+        with p:
+            self.si.create_task(["https://a/", "https://a/", "#c", "https://b/"], task_type="indexer")
+        body = json.loads(calls[0].data)
+        self.assertEqual(body["urls"], ["https://a/", "https://b/"])
+        self.assertTrue(body["pay_per_indexed"])
+        self.assertTrue(calls[0].full_url.endswith("/v2/task/google/indexer/create"))
+
+    def test_validation(self):
+        with self.assertRaises(ValueError):
+            self.si.create_task(["https://a/"], engine="bing", task_type="indexer")
+        with self.assertRaises(ValueError):
+            self.si.create_task(["https://a/"], drip_feed=True, drip_feed_days=2)
+        with self.assertRaises(ValueError):
+            self.si.create_task([])
+
+    def test_api_error(self):
+        _, p = self._capture({"code": 1})
+        with p, self.assertRaises(SpeedyIndexError) as ctx:
+            self.si.balance()
+        self.assertEqual(ctx.exception.code, 1)
+
+    def test_missing_key(self):
+        with mock.patch.dict("os.environ", {}, clear=True):
+            with self.assertRaises(SpeedyIndexError):
+                SpeedyIndex()
+
+    def test_cli_balance(self):
+        _, p = self._capture({"code": 0, "balance": {"tokens": 5}})
+        with p, mock.patch.dict("os.environ", {"SPEEDYINDEX_API_KEY": "k"}):
+            self.assertEqual(main(["balance"]), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()