diff --git a/.sampo/changesets/quiet-beacon-push.md b/.sampo/changesets/quiet-beacon-push.md
new file mode 100644
index 000000000..313d4787a
--- /dev/null
+++ b/.sampo/changesets/quiet-beacon-push.md
@@ -0,0 +1,5 @@
+---
+pypi/posthog: minor
+---
+
+Add `posthog.push.send()`, `AsyncPosthog.push.send()` and the standalone `Push` and `AsyncPush` classes to send transactional push notifications from a PostHog push template to every device of one person. Sends use the client's `secret_key` (a project secret API key with the `transactional_push:write` scope), `app_host`, and email request timeout and retries.
diff --git a/posthog/async_client.py b/posthog/async_client.py
index 7e5c3b3ff..c2e82c213 100644
--- a/posthog/async_client.py
+++ b/posthog/async_client.py
@@ -69,6 +69,7 @@
 )
 from .consumer import MAX_MSG_SIZE
 from .emails import AsyncEmails, _client_emails, _validate_options
+from .push import AsyncPush
 from .feature_flag_evaluations import (
     FeatureFlagEvaluations,
     _EvaluatedFlagRecord,
@@ -306,6 +307,27 @@ def emails(self) -> AsyncEmails:
             )
         return self._emails
 
+    @property
+    def push(self) -> AsyncPush:
+        """
+        Send transactional push notifications from PostHog push templates.
+
+        Needs ``secret_key``, a project secret API key with the ``transactional_push:write``
+        scope. Sends go where ``emails`` sends go and use the same timeout and
+        retries. A disabled or shut-down client sends nothing. See ``posthog.push``
+        for setup.
+
+        Examples:
+            ```python
+            await client.push.send(
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                distinct_id="user_123",
+                template_data={"order_id": "1042"},
+            )
+            ```
+        """
+        return AsyncPush._over(self.emails)
+
     def _admit_email_send(self) -> Optional[Callable[[], None]]:
         # Shutdown waits for in-flight operations before it closes the email transport.
         if not self._accepting or self._closed:
diff --git a/posthog/client.py b/posthog/client.py
index 35380d979..f81f6b9f3 100644
--- a/posthog/client.py
+++ b/posthog/client.py
@@ -79,6 +79,7 @@
     tag as _context_tag,
 )
 from posthog.emails import Emails, _client_emails, _no_op, _validate_options
+from posthog.push import Push
 from posthog.exception_capture import ExceptionCapture
 from posthog._logging import _configure_posthog_logging
 from posthog.exception_utils import (
@@ -1726,6 +1727,27 @@ def emails(self) -> Emails:
             )
         return self._emails
 
+    @property
+    def push(self) -> Push:
+        """
+        Send transactional push notifications from PostHog push templates.
+
+        Needs ``secret_key``, a project secret API key with the ``transactional_push:write``
+        scope. Sends go where ``emails`` sends go and use the same timeout and
+        retries. A disabled or shut-down client sends nothing. See ``posthog.push``
+        for setup.
+
+        Examples:
+            ```python
+            client.push.send(
+                template_id="0190f6d2-7c1e-7b3a-9f5e-1c2d3e4f5a6b",
+                distinct_id="user_123",
+                template_data={"order_id": "1042"},
+            )
+            ```
+        """
+        return Push._over(self.emails)
+
     @property
     def queue(self) -> Queue:
         """The analytics lane's queue (kept for backwards compatibility)."""
diff --git a/posthog/emails.py b/posthog/emails.py
index 42e70b971..b8a324fb7 100644
--- a/posthog/emails.py
+++ b/posthog/emails.py
@@ -920,6 +920,16 @@ def _deliver(self, prepared: _PreparedSend, secret_key: str) -> SendEmailResult:
             prepared.max_retries,
         )
 
+    def _queue(
+        self, prepared: _PreparedSend, not_done: str, key_needed: str
+    ) -> SendEmailResult:
+        # posthog.push sends through this, so a push gets the same host, key, timeout and retries.
+        finish = self._start(not_done)
+        try:
+            return self._deliver(prepared, self._secret_key(key_needed))
+        finally:
+            finish()
+
     def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         """Read what happened to an email that :meth:`send` queued.
 
@@ -1104,6 +1114,15 @@ async def _deliver(
             prepared.max_retries,
         )
 
+    async def _queue(
+        self, prepared: _PreparedSend, not_done: str, key_needed: str
+    ) -> SendEmailResult:
+        finish = self._start(not_done)
+        try:
+            return await self._deliver(prepared, self._secret_key(key_needed))
+        finally:
+            finish()
+
     async def get(self, message_id: Union[str, UUID]) -> EmailStatus:
         """Read what happened to an email that :meth:`send` queued.
 
@@ -1234,7 +1253,7 @@ def _client_emails(
     if not is_cloud:
         # A custom host is often an ingestion proxy, which must not receive the secret key.
         emails._host_error = (
-            "The client's host is not PostHog Cloud, so the client can't tell where to send email. "
+            "The client's host is not PostHog Cloud, so the client can't tell where to send requests. "
             "Set app_host to your PostHog app host on the client."
         )
     emails._parent_disabled = is_disabled
diff --git a/posthog/push.py b/posthog/push.py
new file mode 100644
index 000000000..e2b1438cd
--- /dev/null
+++ b/posthog/push.py
@@ -0,0 +1,360 @@
+"""Transactional push notifications, sent from a push template in PostHog.
+
+Setup:
+
+1. In PostHog, open the push notification under Workflows, make it sendable
+   from the API, and copy its ID. ``template_id`` is that UUID.
+2. Create a project secret API key (``phs_...``) with the
+   ``transactional_push:write`` scope in your project settings.
+3. Send from the client you already use, or from :class:`Push` in a process
+   that only sends notifications:
+
+```python
+from posthog import Posthog
+
+posthog = Posthog("phc_...", secret_key="phs_...", host="https://eu.i.posthog.com")
+result = posthog.push.send(
+    template_id="<template UUID>",
+    distinct_id="user_123",
+    template_data={"order_id": "1042"},  # fills {{ variables.order_id }}
+    idempotency_key="order-shipped:1042",
+)
+print(result.id)  # the queued send
+```
+
+The notification goes to every device the person registered for the
+template's push channels. A person with no registered device gets nothing,
+and the send shows as skipped in the template's sends. The template can't
+read the person's properties, so pass everything it needs in
+``template_data``.
+
+Sends go where ``posthog.emails`` sends go, and use the client's
+``email_request_timeout_seconds`` and ``email_request_max_retries``. For
+async code, use ``AsyncPosthog`` or :class:`AsyncPush` with
+``posthog[async]`` installed.
+
+Errors: a send that is not queued raises :class:`PushError`. Branch on
+``code``, such as ``transactional_push_paused`` when the template's workflow
+is turned off.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Any, Mapping, Optional, Union
+from uuid import UUID, uuid4
+
+import requests
+
+from .emails import (
+    AsyncEmails,
+    EmailError,
+    Emails,
+    _IDEMPOTENCY_KEY,
+    _PreparedSend,
+    _retry_limit,
+)
+from .request import DatetimeSerializer
+from .utils import clean
+
+__all__ = ["AsyncPush", "Push", "PushError", "SendPushResult"]
+
+_SEND_PATH = "/api/projects/@current/messaging/send/push/"
+_MAX_DISTINCT_ID_LENGTH = 400
+_NOT_DONE = "no push notification was sent"
+_KEY_NEEDED = (
+    "Sending push notifications needs secret_key, a project secret API key with the "
+    "transactional_push:write scope."
+)
+
+
+class PushError(Exception):
+    """PostHog did not queue the push notification, or the client could not tell whether it did.
+
+    Branch on ``code``, PostHog's stable error code, or on ``name``, a coarse
+    category of the failure. The message never contains the secret key or the
+    request body.
+
+    Attributes:
+        name: A coarse category of the failure.
+        code: PostHog's stable error code.
+        message: What went wrong.
+        status_code: The HTTP status of the response, or ``None`` when none arrived.
+        why: PostHog's explanation of the failure, when it gave one.
+        fix: What to change to fix it, when PostHog said.
+        docs_url: A docs page about the error, when PostHog gave one.
+        field: The request field the error is about, when there is one.
+        retry_after: Seconds to wait before retrying, when PostHog said.
+    """
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        code: str,
+        message: str,
+        status_code: Optional[int] = None,
+        why: Optional[str] = None,
+        fix: Optional[str] = None,
+        docs_url: Optional[str] = None,
+        field: Optional[str] = None,
+        retry_after: Optional[float] = None,
+    ) -> None:
+        super().__init__(message)
+        self.name = name
+        self.code = code
+        self.message = message
+        self.status_code = status_code
+        self.why = why
+        self.fix = fix
+        self.docs_url = docs_url
+        self.field = field
+        self.retry_after = retry_after
+
+    @classmethod
+    def _from_email_error(cls, error: EmailError) -> PushError:
+        return cls(
+            name=error.name,
+            code=error.code,
+            message=error.message,
+            status_code=error.status_code,
+            why=error.why,
+            fix=error.fix,
+            docs_url=error.docs_url,
+            field=error.field,
+            retry_after=error.retry_after,
+        )
+
+
+@dataclass(frozen=True)
+class SendPushResult:
+    """The queued push notification. ``id`` is its message ID.
+
+    A result means PostHog queued the notification, not that a device received it.
+
+    Attributes:
+        id: The send's message ID.
+        replayed: ``True`` when PostHog had already accepted this
+            ``idempotency_key`` and returned the first send's result.
+    """
+
+    id: str
+    replayed: bool = False
+
+
+def _prepare(
+    template_id: Union[str, UUID],
+    distinct_id: str,
+    template_data: Optional[Mapping[str, Any]],
+    idempotency_key: Optional[str],
+    max_retries: Optional[int],
+) -> _PreparedSend:
+    if (
+        not isinstance(distinct_id, str)
+        or not distinct_id
+        or len(distinct_id) > _MAX_DISTINCT_ID_LENGTH
+    ):
+        raise ValueError(
+            f"distinct_id must be the person's distinct ID, a nonempty string of at most "
+            f"{_MAX_DISTINCT_ID_LENGTH} characters."
+        )
+    if idempotency_key is None:
+        idempotency_key = str(uuid4())
+    elif not isinstance(idempotency_key, str) or not _IDEMPOTENCY_KEY.match(
+        idempotency_key
+    ):
+        raise ValueError(
+            "idempotency_key must be 1 to 255 visible ASCII characters without spaces."
+        )
+    max_retries = _retry_limit(max_retries)
+    try:
+        template_uuid = (
+            template_id if isinstance(template_id, UUID) else UUID(template_id)
+        )
+    except (TypeError, ValueError, AttributeError):
+        raise ValueError("template_id must be the push template's UUID.") from None
+    if template_data is not None and not isinstance(template_data, Mapping):
+        raise TypeError("template_data must be a mapping.")
+    payload = {
+        "template_id": str(template_uuid),
+        "distinct_id": distinct_id,
+        "message_data": clean(dict(template_data or {})),
+    }
+    return _PreparedSend(
+        path=_SEND_PATH,
+        body=json.dumps(payload, cls=DatetimeSerializer).encode("utf-8"),
+        idempotency_key=idempotency_key,
+        max_retries=max_retries,
+    )
+
+
+def _result(result: Any) -> SendPushResult:
+    return SendPushResult(id=result.id, replayed=result.replayed)
+
+
+class Push:
+    """Sends transactional push notifications from PostHog push templates.
+
+    ``host`` is your PostHog app host. PostHog Cloud ingestion hosts map to the
+    app host, so ``us.i.posthog.com`` sends to ``us.posthog.com``. Any other
+    host is used as given.
+
+    Each send retries network errors, rate limits and an unavailable service up
+    to ``max_retries`` times, with the same idempotency key. ``timeout`` is in
+    seconds, per request. Pass ``session`` to send through your own
+    ``requests.Session``, for example a test double.
+    """
+
+    def __init__(
+        self,
+        secret_key: Optional[str],
+        *,
+        host: Optional[str] = None,
+        timeout: float = 15,
+        max_retries: int = 2,
+        disabled: bool = False,
+        session: Optional[requests.Session] = None,
+    ) -> None:
+        self._emails = Emails(
+            secret_key,
+            host=host,
+            timeout=timeout,
+            max_retries=max_retries,
+            disabled=disabled,
+            session=session,
+        )
+
+    @classmethod
+    def _over(cls, emails: Emails) -> Push:
+        push = cls.__new__(cls)
+        push._emails = emails
+        return push
+
+    def send(
+        self,
+        *,
+        template_id: Union[str, UUID],
+        distinct_id: str,
+        template_data: Optional[Mapping[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+        max_retries: Optional[int] = None,
+    ) -> SendPushResult:
+        """Queue one push notification to every device of one person.
+
+        Args:
+            template_id: The UUID of a push template made transactional in PostHog.
+            distinct_id: The distinct ID of the person to notify.
+            template_data: Values for the template's ``{{ variables.* }}``
+                placeholders. Values are encoded the way capture encodes
+                properties.
+            idempotency_key: 1 to 255 visible ASCII characters. A send with a
+                key that PostHog has already accepted queues nothing and returns
+                the first send's result. Without it, the client makes a key
+                that covers its own retries. Pass a key derived from what the
+                notification is for, such as ``order-shipped:1042``, to cover
+                retries outside this call, too.
+            max_retries: Overrides the client's maximum number of retries for
+                this send. ``0`` turns retries off.
+
+        Returns:
+            The queued notification. A result means PostHog queued it, not
+            that a device received it.
+
+        Raises:
+            PushError: PostHog did not queue the notification, or the client
+                could not tell whether it did.
+            TypeError, ValueError: An argument has the wrong type or format.
+        """
+        prepared = _prepare(
+            template_id, distinct_id, template_data, idempotency_key, max_retries
+        )
+        try:
+            return _result(self._emails._queue(prepared, _NOT_DONE, _KEY_NEEDED))
+        except EmailError as error:
+            raise PushError._from_email_error(error) from error.__cause__
+
+    def close(self) -> None:
+        """Close the HTTP connections this client opened. A ``session`` you passed in stays open."""
+        self._emails.close()
+
+    def __enter__(self) -> Push:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        self.close()
+
+
+class AsyncPush:
+    """The async counterpart of :class:`Push`. Needs ``posthog[async]``.
+
+    Pass ``http_client`` to send through your own ``httpx.AsyncClient``, for
+    example one with an ``httpx.MockTransport`` in tests.
+    """
+
+    def __init__(
+        self,
+        secret_key: Optional[str],
+        *,
+        host: Optional[str] = None,
+        timeout: float = 15,
+        max_retries: int = 2,
+        disabled: bool = False,
+        http_client: Any = None,
+    ) -> None:
+        self._emails = AsyncEmails(
+            secret_key,
+            host=host,
+            timeout=timeout,
+            max_retries=max_retries,
+            disabled=disabled,
+            http_client=http_client,
+        )
+
+    @classmethod
+    def _over(cls, emails: AsyncEmails) -> AsyncPush:
+        push = cls.__new__(cls)
+        push._emails = emails
+        return push
+
+    async def send(
+        self,
+        *,
+        template_id: Union[str, UUID],
+        distinct_id: str,
+        template_data: Optional[Mapping[str, Any]] = None,
+        idempotency_key: Optional[str] = None,
+        max_retries: Optional[int] = None,
+    ) -> SendPushResult:
+        """Queue one push notification to every device of one person.
+
+        Takes the same arguments and raises the same errors as :meth:`Push.send`.
+        """
+        prepared = _prepare(
+            template_id, distinct_id, template_data, idempotency_key, max_retries
+        )
+        try:
+            return _result(await self._emails._queue(prepared, _NOT_DONE, _KEY_NEEDED))
+        except EmailError as error:
+            raise PushError._from_email_error(error) from error.__cause__
+
+    async def aclose(self) -> None:
+        """Close the HTTP connections this client opened. An ``http_client`` you passed in stays open."""
+        await self._emails.aclose()
+
+    async def __aenter__(self) -> AsyncPush:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[BaseException]],
+        exc: Optional[BaseException],
+        traceback: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
diff --git a/posthog/test/test_push.py b/posthog/test/test_push.py
new file mode 100644
index 000000000..50a986f44
--- /dev/null
+++ b/posthog/test/test_push.py
@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from typing import Any
+from unittest import mock
+
+import httpx
+import pytest
+import requests
+from parameterized import parameterized
+
+from posthog import AsyncPosthog, Posthog
+from posthog.push import Push, PushError, SendPushResult
+from posthog.test.test_emails import (
+    SECRET_KEY,
+    TEMPLATE_ID,
+    FakeAdapter,
+    Reply,
+    accepted,
+)
+from posthog.version import VERSION
+
+SEND_URL = "https://us.posthog.com/api/projects/@current/messaging/send/push/"
+
+
+def push_with(replies: list[Reply], **options: Any) -> tuple[Push, FakeAdapter]:
+    adapter = FakeAdapter(replies)
+    session = requests.Session()
+    session.mount("https://", adapter)
+    return Push(SECRET_KEY, session=session, **options), adapter
+
+
+def send(push: Push, **overrides: Any) -> SendPushResult:
+    return push.send(
+        **{"template_id": TEMPLATE_ID, "distinct_id": "user_123", **overrides}
+    )
+
+
+@pytest.fixture(autouse=True)
+def no_sleep():
+    with (
+        mock.patch("posthog.emails.time.sleep") as sleep,
+        mock.patch("posthog.emails.random.uniform", return_value=1.0),
+    ):
+        yield sleep
+
+
+def test_send_posts_the_template_person_and_data_to_the_app_host():
+    push, adapter = push_with([accepted(replayed=True)])
+
+    result = send(
+        push,
+        template_id=TEMPLATE_ID.upper(),
+        template_data={
+            "order_id": "1042",
+            "shipped_at": datetime(2026, 11, 20, tzinfo=timezone.utc),
+        },
+        idempotency_key="order-shipped:1042",
+    )
+
+    assert result == SendPushResult(id="msg_1", replayed=True)
+    (request,) = adapter.requests
+    assert request.url == SEND_URL
+    assert request.method == "POST"
+    assert request.headers["Authorization"] == f"Bearer {SECRET_KEY}"
+    assert request.headers["Idempotency-Key"] == "order-shipped:1042"
+    assert request.headers["User-Agent"] == f"posthog-python/{VERSION}"
+    assert json.loads(request.body) == {
+        "template_id": TEMPLATE_ID,
+        "distinct_id": "user_123",
+        "message_data": {"order_id": "1042", "shipped_at": "2026-11-20T00:00:00+00:00"},
+    }
+
+
+def test_retries_an_unavailable_pipeline_with_the_same_generated_key():
+    push, adapter = push_with([(503, {"code": "delivery_unavailable"}, {}), accepted()])
+
+    assert send(push).id == "msg_1"
+
+    keys = [request.headers["Idempotency-Key"] for request in adapter.requests]
+    assert len(keys) == 2 and keys[0] == keys[1]
+
+
+def test_a_server_refusal_raises_a_push_error_with_its_details():
+    push, _ = push_with(
+        [
+            (
+                400,
+                {
+                    "code": "transactional_push_paused",
+                    "detail": "The workflow is turned off.",
+                    "fix": "Turn it on.",
+                    "attr": "template_id",
+                },
+                {},
+            )
+        ]
+    )
+
+    with pytest.raises(PushError) as raised:
+        send(push)
+
+    assert raised.value.name == "validation_error"
+    assert raised.value.code == "transactional_push_paused"
+    assert raised.value.message == "The workflow is turned off."
+    assert raised.value.status_code == 400
+    assert raised.value.fix == "Turn it on."
+    assert raised.value.field == "template_id"
+
+
+@parameterized.expand(
+    [
+        ("template_name", {"template_id": "order-shipped"}, ValueError),
+        ("empty_distinct_id", {"distinct_id": ""}, ValueError),
+        ("long_distinct_id", {"distinct_id": "a" * 401}, ValueError),
+        ("template_data_list", {"template_data": ["1042"]}, TypeError),
+        ("key_with_space", {"idempotency_key": "order 1042"}, ValueError),
+        ("negative_retries", {"max_retries": -1}, ValueError),
+    ]
+)
+def test_rejects_invalid_arguments_before_sending(_name, overrides, error):
+    push, adapter = push_with([])
+
+    with pytest.raises(error):
+        send(push, **overrides)
+
+    assert adapter.requests == []
+
+
+def test_client_push_goes_where_emails_go_and_refuses_after_shutdown():
+    client = Posthog(
+        "phc_test",
+        secret_key=SECRET_KEY,
+        host="https://ph.example.com",
+        app_host="https://posthog.example.com",
+        email_request_max_retries=0,
+        sync_mode=True,
+    )
+    with mock.patch.object(
+        requests.Session,
+        "request",
+        return_value=_response(503, {"code": "delivery_unavailable"}),
+    ) as request:
+        with pytest.raises(PushError) as raised:
+            send(client.push)
+    assert raised.value.code == "delivery_unavailable"
+    assert request.call_count == 1
+    assert (
+        request.call_args.args[1]
+        == "https://posthog.example.com/api/projects/@current/messaging/send/push/"
+    )
+
+    client.shutdown()
+
+    with pytest.raises(PushError) as raised:
+        send(client.push)
+    assert raised.value.code == "client_closed"
+    assert "push notification" in raised.value.message
+
+
+def test_a_proxy_host_without_app_host_never_gets_the_secret_key():
+    client = Posthog(
+        "phc_test", secret_key=SECRET_KEY, host="https://ph.example.com", sync_mode=True
+    )
+
+    with mock.patch.object(requests.Session, "request") as request:
+        with pytest.raises(PushError) as raised:
+            send(client.push)
+
+    assert raised.value.code == "missing_app_host"
+    request.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_async_client_push_retries_with_the_same_key():
+    seen: list[httpx.Request] = []
+    replies = [
+        httpx.Response(503, json={"code": "delivery_unavailable"}),
+        httpx.Response(202, json={"message_id": "msg_1", "replayed": False}),
+    ]
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        seen.append(request)
+        return replies.pop(0)
+
+    client = AsyncPosthog("phc_test", secret_key=SECRET_KEY)
+    client.emails._client = httpx.AsyncClient(transport=httpx.MockTransport(handler))
+
+    with mock.patch("posthog.emails.asyncio.sleep"):
+        result = await client.push.send(template_id=TEMPLATE_ID, distinct_id="user_123")
+
+    assert result == SendPushResult(id="msg_1")
+    assert [str(request.url) for request in seen] == [SEND_URL, SEND_URL]
+    assert seen[0].headers["Idempotency-Key"] == seen[1].headers["Idempotency-Key"]
+    await client.shutdown()
+
+
+def _response(status: int, body: dict[str, Any]) -> requests.Response:
+    reply = requests.Response()
+    reply.status_code = status
+    reply._content = json.dumps(body).encode()
+    return reply
diff --git a/references/public_api_snapshot.txt b/references/public_api_snapshot.txt
index bfffd5d64..80dcc7720 100644
--- a/references/public_api_snapshot.txt
+++ b/references/public_api_snapshot.txt
@@ -270,6 +270,7 @@ alias posthog.client.OptionalCaptureArgs -> posthog.args.OptionalCaptureArgs
 alias posthog.client.OptionalSetArgs -> posthog.args.OptionalSetArgs
 alias posthog.client.Poller -> posthog.poller.Poller
 alias posthog.client.PostHogMetrics -> posthog.metrics_capture.PostHogMetrics
+alias posthog.client.Push -> posthog.push.Push
 alias posthog.client.QuotaLimitError -> posthog.request.QuotaLimitError
 alias posthog.client.RedisFlagCache -> posthog.utils.RedisFlagCache
 alias posthog.client.RequestsConnectionError -> posthog.request.RequestsConnectionError
@@ -764,6 +765,7 @@ attribute posthog.async_client.AsyncClient.migrated_from = migrated_from
 attribute posthog.async_client.AsyncClient.on_error = on_error
 attribute posthog.async_client.AsyncClient.personal_api_key = self.secret_key
 attribute posthog.async_client.AsyncClient.project_root = os.getcwd()
+attribute posthog.async_client.AsyncClient.push: AsyncPush
 attribute posthog.async_client.AsyncClient.raw_host = normalize_host(host)
 attribute posthog.async_client.AsyncClient.secret_key = (resolved_secret_key.strip() if isinstance(resolved_secret_key, str) else resolved_secret_key) or None
 attribute posthog.async_client.AsyncClient.send = send
@@ -838,6 +840,7 @@ attribute posthog.client.Client.poll_interval = poll_interval
 attribute posthog.client.Client.poller: Optional[Poller] = None
 attribute posthog.client.Client.privacy_mode = privacy_mode
 attribute posthog.client.Client.project_root = project_root
+attribute posthog.client.Client.push: Push
 attribute posthog.client.Client.queue: Queue
 attribute posthog.client.Client.raw_host = normalize_host(host)
 attribute posthog.client.Client.secret_key = (resolved_secret_key.strip() if isinstance(resolved_secret_key, str) else resolved_secret_key) or None
@@ -1141,6 +1144,17 @@ attribute posthog.poller.Poller.stopped = threading.Event()
 attribute posthog.privacy_mode = False
 attribute posthog.project_api_key = None
 attribute posthog.project_root = None
+attribute posthog.push.PushError.code = code
+attribute posthog.push.PushError.docs_url = docs_url
+attribute posthog.push.PushError.field = field
+attribute posthog.push.PushError.fix = fix
+attribute posthog.push.PushError.message = message
+attribute posthog.push.PushError.name = name
+attribute posthog.push.PushError.retry_after = retry_after
+attribute posthog.push.PushError.status_code = status_code
+attribute posthog.push.PushError.why = why
+attribute posthog.push.SendPushResult.id: str
+attribute posthog.push.SendPushResult.replayed: bool = False
 attribute posthog.release_id.RELEASE_ID_ENV_VAR = 'POSTHOG_RELEASE_ID'
 attribute posthog.request.AI_EVENTS_ENDPOINT = '/i/v0/ai/batch/'
 attribute posthog.request.APIError.message = message
@@ -1381,6 +1395,10 @@ class posthog.mcp.types.ToolInputOptions(should_record_input_key: Optional[Shoul
 class posthog.mcp.types.UserIdentity(distinct_id: str, properties: Optional[JsonRecord] = None, groups: Optional[Dict[str, str]] = None)
 class posthog.metrics_capture.PostHogMetrics(client, config: Optional[dict] = None)
 class posthog.poller.Poller(interval, execute, *args, **kwargs)
+class posthog.push.AsyncPush(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, http_client: Any = None)
+class posthog.push.Push(secret_key: Optional[str], *, host: Optional[str] = None, timeout: float = 15, max_retries: int = 2, disabled: bool = False, session: Optional[requests.Session] = None)
+class posthog.push.PushError(*, name: str, code: str, message: str, status_code: Optional[int] = None, why: Optional[str] = None, fix: Optional[str] = None, docs_url: Optional[str] = None, field: Optional[str] = None, retry_after: Optional[float] = None)
+class posthog.push.SendPushResult(id: str, replayed: bool = False)
 class posthog.request.APIError(status: Union[int, str], message: str, retry_after: Optional[float] = None)
 class posthog.request.DatetimeSerializer 
 class posthog.request.GetResponse(data: Any, etag: Optional[str] = None, not_modified: bool = False)
@@ -1905,6 +1923,10 @@ method posthog.metrics_capture.PostHogMetrics.histogram(name: str, value: float,
 method posthog.metrics_capture.PostHogMetrics.reset() -> None
 method posthog.poller.Poller.run()
 method posthog.poller.Poller.stop()
+method posthog.push.AsyncPush.aclose() -> None
+method posthog.push.AsyncPush.send(*, template_id: Union[str, UUID], distinct_id: str, template_data: Optional[Mapping[str, Any]] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendPushResult
+method posthog.push.Push.close() -> None
+method posthog.push.Push.send(*, template_id: Union[str, UUID], distinct_id: str, template_data: Optional[Mapping[str, Any]] = None, idempotency_key: Optional[str] = None, max_retries: Optional[int] = None) -> SendPushResult
 method posthog.request.DatetimeSerializer.default(obj: Any)
 method posthog.request.DatetimeSerializer.encode(o: Any) -> str
 method posthog.request.HTTPAdapterWithSocketOptions.init_poolmanager(*args, **kwargs)
@@ -2014,6 +2036,7 @@ module posthog.mcp.types
 module posthog.mcp.version
 module posthog.metrics_capture
 module posthog.poller
+module posthog.push
 module posthog.release_id
 module posthog.request
 module posthog.tracing