substack-api-mcp 1.0.2__py3-none-any.whl

substack_api_mcp/substack/tools/list_subscribers.py

@@ -0,0 +1,82 @@
+"""List subscribers."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.helpers import limit
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import next_cursor, offset_cursor, publication
+from substack_api_mcp.substack.subscribers import plan_of, subscriber_page
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "plan": {
+            "type": "string",
+            "enum": ["all", "free", "paid", "comp", "founding"],
+            "description": "all, free, paid, comp or founding. Default: all.",
+        },
+        "since": {
+            "type": "string",
+            "format": "date",
+            "description": "Only subscribers who joined on or after this date.",
+        },
+        "limit": {"type": "integer", "description": "1 to 500. Default: 100."},
+        "cursor": {"type": "string", "description": "Next page cursor from the previous call."},
+    },
+    "required": [],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "subscribers": [
+        {"email": "maya@example.com", "plan": "free", "joined_at": "2026-10-04T09:12:00Z", "activity_rating": 4},
+        {"email": "jon@example.com", "plan": "paid", "joined_at": "2026-10-02T17:40:00Z", "activity_rating": 5},
+    ],
+    "next_cursor": None,
+}
+
+
+@tool(
+    name="list_subscribers",
+    title="List subscribers",
+    access="read",
+    confirm=False,
+    description="Subscribers with plan, start date and activity rating.",
+    details=(
+        "Lists subscribers, newest first, from the subscriber dashboard. Activity rating is the 0 to 5 score "
+        "Substack shows there. Pages hold up to 500 rows; pass next_cursor back as cursor. The plan and since "
+        "filters apply inside each page, so a filtered page can be short or empty while next_cursor still "
+        "points further. Someone added a minute ago may not show yet: Substack fills the table in the "
+        "background. paid includes founding members."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="GET /subscribers",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def list_subscribers(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    pub = await publication(ctx)
+    wanted = limit(args, 100, 500)
+    offset = offset_cursor(args.get("cursor"))
+    plan = args.get("plan") or "all"
+    since = args.get("since")
+    rows = await subscriber_page(ctx, pub, offset, wanted, since)
+    subscribers = []
+    for row in rows:
+        row_plan = plan_of(row)
+        if plan != "all" and row_plan != plan and not (plan == "paid" and row_plan == "founding"):
+            continue
+        subscribers.append(
+            {
+                "email": row.get("user_email_address"),
+                "plan": row_plan,
+                "joined_at": row.get("subscription_created_at"),
+                "activity_rating": row.get("activity_rating"),
+            }
+        )
+    return {"subscribers": subscribers, "next_cursor": next_cursor(offset, len(rows), wanted)}

substack_api_mcp/substack/tools/list_subscriptions.py

@@ -0,0 +1,76 @@
+"""List subscriptions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import WEB, call
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {"type": "object", "properties": {}, "required": [], "additionalProperties": False}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "subscriptions": [
+        {
+            "publication_id": "5262902",
+            "name": "Brain Health Decoded",
+            "url": "https://example.substack.com",
+            "plan": "free",
+            "emails": True,
+            "since": "2026-10-18T13:46:36.900Z",
+        }
+    ]
+}
+
+
+@tool(
+    name="list_subscriptions",
+    title="List subscriptions",
+    access="read",
+    confirm=False,
+    description="Publications you subscribe to, with your plan and whether their emails reach you.",
+    details=(
+        "Returns every publication your account subscribes to, as Settings > Subscriptions lists them: name, "
+        "link, plan (free, paid, comp, founding or gift, as Substack names the membership) and whether you "
+        "get its emails. Your own publications are left out."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="GET /subscriptions",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def list_subscriptions(ctx: ToolContext, _args: dict[str, Any]) -> Any:
+
+    answer = await call(ctx, "GET", f"{WEB}/api/v1/subscriptions/page_v2")
+    pubs = {pub.get("id"): pub for pub in answer.get("publications") or []}
+    own = {row.get("publication_id") for row in answer.get("publicationUsers") or []}
+    subscriptions = []
+    for row in answer.get("subscriptions") or []:
+        pub = pubs.get(row.get("publication_id")) or {}
+        if row.get("publication_id") in own:
+            continue
+        domain = pub.get("custom_domain") or (f"{pub['subdomain']}.substack.com" if pub.get("subdomain") else None)
+        subscriptions.append(
+            {
+                "publication_id": str(row.get("publication_id") or ""),
+                "name": pub.get("name") or "",
+                "url": f"https://{domain}" if domain else None,
+                "plan": _plan(row),
+                "emails": not row.get("email_disabled"),
+                "since": row.get("created_at"),
+            }
+        )
+    return {"subscriptions": subscriptions}
+
+
+def _plan(row: dict[str, Any]) -> str:
+    if row.get("gift_user_id"):
+        return "gift"
+    if row.get("is_founding"):
+        return "founding"
+    state = str(row.get("membership_state") or "")
+    if state == "free_signup":
+        return "free"
+    return "comp" if "comp" in state else "paid" if state else "free"

substack_api_mcp/substack/tools/list_traffic_sources.py

@@ -0,0 +1,89 @@
+"""List traffic sources."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
+from zoneinfo import ZoneInfo
+
+from substack_api_mcp.core.helpers import limit
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, next_cursor, offset_cursor, publication
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "period": {"type": "string", "enum": ["7d", "30d", "90d", "365d"], "description": "Default: 30d."},
+        "limit": {"type": "integer", "minimum": 1, "maximum": 50, "description": "Default: 20."},
+        "cursor": {"type": "string", "description": "next_cursor from the previous page."},
+    },
+    "required": [],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "period": "30d",
+    "sources": [
+        {
+            "source": "substack app",
+            "category": "Substack",
+            "views": 8120,
+            "visitors": 3011,
+            "free_signups": 41,
+            "paid_subscriptions": 3,
+        }
+    ],
+    "next_cursor": None,
+}
+
+
+@tool(
+    name="list_traffic_sources",
+    title="List traffic sources",
+    access="read",
+    confirm=False,
+    description="Where your publication's visitors came from in a period, most views first.",
+    details=(
+        "Returns Analytics > Traffic > Traffic sources: each source (the app, email, a website, search, "
+        "social) with its category, views, unique visitors and the free and paid subscribers it brought. "
+        "Sorted by views; page with next_cursor."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="GET /traffic-sources",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def list_traffic_sources(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    period = args.get("period") or "30d"
+    wanted = limit(args, 20, 50)  # Substack answers 400 above 50 (22.10.2026)
+    offset = offset_cursor(args.get("cursor"))
+    pub = await publication(ctx)
+    today = datetime.now(ZoneInfo("Europe/Warsaw")).date()
+    params = {
+        "from_date": (today - timedelta(days=int(period[:-1]))).isoformat(),
+        "to_date": today.isoformat(),
+        "order_by": "views",
+        "order_direction": "desc",
+        "offset": offset,
+        "limit": wanted,
+    }
+    answer = await call(ctx, "GET", f"{pub['base']}/api/v1/publication/stats/visitor_sources", params=params)
+    rows = answer.get("rows") or []
+    return {
+        "period": period,
+        "sources": [
+            {
+                "source": row.get("source") or "",
+                "category": row.get("source_category") or "",
+                "views": int(row.get("views") or 0),
+                "visitors": int(row.get("users") or 0),
+                "free_signups": int(row.get("free_signup") or 0),
+                "paid_subscriptions": int(row.get("subscribed") or 0),
+            }
+            for row in rows
+        ],
+        "next_cursor": next_cursor(offset, len(rows), wanted),
+    }

substack_api_mcp/substack/tools/pin_comment.py

@@ -0,0 +1,46 @@
+"""Pin comment."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, comment_id, publication
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "comment_id": {"type": "string", "description": "Comment ID from list_comments."},
+        "unpin": {"type": "boolean", "description": "Unpin instead. Default: false."},
+    },
+    "required": ["comment_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"comment_id": "364149469", "pinned": True}
+
+
+@tool(
+    name="pin_comment",
+    title="Pin comment",
+    access="write",
+    confirm=False,
+    description="Pin a comment to the top of your post's comments, or unpin it.",
+    details=(
+        "Pins one comment on a post of your publication above all others, as Pin in the comment menu does, "
+        "or unpins it. A comment on someone else's post returns an error."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="PUT /comments/{comment_id}/pin",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def pin_comment(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    pub = await publication(ctx)
+    cid = comment_id(args["comment_id"])
+    pinned = not args.get("unpin")
+    await call(ctx, "PATCH", f"{pub['base']}/api/v1/comment/{cid}/pin", body={"pinned": pinned})
+    return {"comment_id": str(cid), "pinned": pinned}

substack_api_mcp/substack/tools/publish_note.py

@@ -0,0 +1,83 @@
+"""Publish Note."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.errors import ErrorCode, ToolError
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import WEB, call, draft, post_id, post_url, publication
+from substack_api_mcp.substack.markdown import to_note_doc
+from substack_api_mcp.substack.publishing import future_time
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "body": {"type": "string", "description": "Note text, up to 1,000 characters."},
+        "link_post_id": {"type": "string", "description": "Attach one of your published posts as a link card."},
+        "publish_at": {
+            "type": "string",
+            "format": "date-time",
+            "description": "ISO 8601 with time zone. Omit to post now.",
+        },
+    },
+    "required": ["body"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "note_id": "5521098",
+    "status": "published",
+    "published_at": "2026-10-11T10:05:00Z",
+    "url": "https://substack.com/@yourname/note/c-5521098",
+}
+
+
+@tool(
+    name="publish_note",
+    title="Publish Note",
+    access="write",
+    confirm=True,
+    description=(
+        "Short post in Substack Notes, now or at a set time, optionally with a link card to one of your posts."
+    ),
+    details=(
+        "Posts a Note under your name. Without publish_at it goes out now; with it, the Note waits in your "
+        "scheduled Notes, status is scheduled and published_at is that time. Text is 1 to 1,000 characters. "
+        "link_post_id must be a published post. By default you confirm each call; you can switch that off "
+        "for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /notes",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def publish_note(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    text = args["body"].strip()
+    if not text or len(text) > 1000:
+        raise ToolError("body must be 1 to 1,000 characters.", ErrorCode.INVALID_INPUT)
+    pub = await publication(ctx)
+    doc = to_note_doc(text)
+    note: dict[str, Any] = {"bodyJson": doc, "tabId": "for-you", "surface": "feed", "replyMinimumRole": "everyone"}
+    if args.get("link_post_id"):
+        url = post_url(pub, await draft(ctx, pub, post_id(args["link_post_id"])))
+        if not url:
+            raise ToolError("link_post_id must be a published post.", ErrorCode.INVALID_INPUT)
+        card = await call(ctx, "POST", f"{WEB}/api/v1/comment/attachment", body={"url": url, "type": "link"})
+        note["attachmentIds"] = [card["id"]]
+    if args.get("publish_at"):
+        # A scheduled Note is a draft Note with its time: Notes > Scheduled.
+        note["trigger_at"] = future_time(args["publish_at"]).strftime("%Y-%m-%dT%H:%M:%S.000Z")
+        saved = await call(ctx, "POST", f"{WEB}/api/v1/comment/draft", body=note)
+    else:
+        saved = await call(ctx, "POST", f"{WEB}/api/v1/comment/feed", body=note)
+    scheduled = bool(args.get("publish_at"))
+    return {
+        "note_id": str(saved["id"]),
+        "status": "scheduled" if scheduled else "published",
+        "published_at": args["publish_at"] if scheduled else saved.get("date"),
+        "url": f"{WEB}/@{pub['handle']}/note/c-{saved['id']}",
+    }

substack_api_mcp/substack/tools/publish_post.py

@@ -0,0 +1,72 @@
+"""Publish post."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, draft, post_id, publication, require_draft
+from substack_api_mcp.substack.publishing import check_ready, set_options
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "post_id": {"type": "string", "description": "Post ID from list_posts."},
+        "send_email": {"type": "boolean", "description": "Email it to subscribers. Default: true."},
+        "section_id": {
+            "type": "string",
+            "description": "Section ID from list_sections, or main. Default: the draft's section, else main.",
+        },
+    },
+    "required": ["post_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {
+    "post_id": "148420031",
+    "status": "published",
+    "published_at": "2026-10-11T10:02:00Z",
+    "emailed": True,
+    "url": "https://yourname.substack.com/p/notes-on-pricing",
+}
+
+
+@tool(
+    name="publish_post",
+    title="Publish post",
+    access="write",
+    confirm=True,
+    description="Publish a draft now.",
+    details=(
+        "Publishes a draft immediately, on the web and, unless send_email is false, by email, to the audience set"
+        " on the draft. Substack's own pre-publish check runs first; a missing title or an empty body stops the "
+        "call. A sent email cannot be recalled. On a publication with sections the post goes to section_id, else "
+        "to the section already set on the draft, else to the main publication. By default you confirm each call;"
+        " you can switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /posts/{post_id}/publish",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def publish_post(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    pub = await publication(ctx)
+    pid = post_id(args["post_id"])
+    post = await draft(ctx, pub, pid)
+    require_draft(post)
+    send_email = args.get("send_email", True)
+    await set_options(ctx, pub, post, send_email, args.get("section_id"))
+    await check_ready(ctx, pub, pid, None)
+    body = {"send": send_email, "share_automatically": False}
+    published = await call(ctx, "POST", f"{pub['base']}/api/v1/drafts/{pid}/publish", body=body)
+    slug = published.get("slug")
+    return {
+        "post_id": str(pid),
+        "status": "published",
+        "published_at": published.get("post_date"),
+        "emailed": bool(published.get("should_send_email", send_email)),
+        "url": f"{pub['base']}/p/{slug}" if slug else None,
+    }

substack_api_mcp/substack/tools/recommend_publication.py

@@ -0,0 +1,66 @@
+"""Recommend publication."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.errors import ErrorCode, ToolError
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, publication
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "publication_id": {"type": "string", "description": "Publication ID, e.g. from search_substack posts."},
+        "blurb": {"type": "string", "description": "Why you recommend it, shown to your readers (optional)."},
+        "remove": {"type": "boolean", "description": "Stop recommending it instead. Default: false."},
+    },
+    "required": ["publication_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"publication_id": "5262902", "name": "Brain Health Decoded", "recommended": True}
+
+
+@tool(
+    name="recommend_publication",
+    title="Recommend publication",
+    access="write",
+    confirm=True,
+    description="Recommend another publication to your readers, or stop recommending it.",
+    details=(
+        "Adds a publication to your Recommendations, as Growth > Recommendations does: Substack suggests it "
+        "to people who subscribe to you and notifies its author. blurb is the short reason readers see. With "
+        "remove it takes the recommendation back. By default you confirm each call; you can switch that off "
+        "for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="PUT /recommendations/{publication_id}",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def recommend_publication(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    target = str(args["publication_id"]).strip()
+    if not target.isdigit():
+        raise ToolError("publication_id must be a numeric publication ID.", ErrorCode.INVALID_INPUT)
+    pub = await publication(ctx)
+    if int(target) == pub["id"]:
+        raise ToolError("A publication cannot recommend itself.", ErrorCode.INVALID_INPUT)
+    body: dict[str, Any] = {
+        "recommended_publication_id": int(target),
+        "recommending_publication_id": pub["id"],
+        "source": "publisher_dashboard",
+    }
+    if args.get("remove"):
+        await call(ctx, "DELETE", f"{pub['base']}/api/v1/recommendations", body=body)
+        return {"publication_id": target, "name": None, "recommended": False}
+    blurb = str(args.get("blurb") or "").strip()
+    if blurb and len(blurb) < 2:
+        raise ToolError("blurb must be at least 2 characters.", ErrorCode.INVALID_INPUT)
+    body |= {"list_ids": [], "list_assignment": "add", **({"description": blurb} if blurb else {})}
+    saved = await call(ctx, "PUT", f"{pub['base']}/api/v1/recommendations", body=body)
+    name = (saved.get("recommendedPublication") or {}).get("name")
+    return {"publication_id": target, "name": name, "recommended": True}

substack_api_mcp/substack/tools/remove_comment.py

@@ -0,0 +1,45 @@
+"""Remove comment."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, comment_id, publication
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {"comment_id": {"type": "string", "description": "Comment ID from list_comments."}},
+    "required": ["comment_id"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"comment_id": "364149469", "status": "moderator_removed"}
+
+
+@tool(
+    name="remove_comment",
+    title="Remove comment",
+    access="write",
+    confirm=True,
+    description="Remove someone's comment from your post as the publication's moderator.",
+    details=(
+        "Hides a comment on a post of your publication, as Remove in the comment menu does: readers see "
+        "that a moderator removed it, the text is gone, replies under it stay. Use delete_comment for your "
+        "own comments. A comment on someone else's post returns an error. By default you confirm each call; "
+        "you can switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="POST /comments/{comment_id}/remove",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def remove_comment(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    pub = await publication(ctx)
+    cid = comment_id(args["comment_id"])
+    body = {"status": "moderator_removed"}
+    answer = await call(ctx, "PATCH", f"{pub['base']}/api/v1/comment/{cid}/status", body=body)
+    return {"comment_id": str(cid), "status": answer.get("status") or "moderator_removed"}

substack_api_mcp/substack/tools/remove_subscriber.py

@@ -0,0 +1,57 @@
+"""Remove subscriber."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, Any
+
+from substack_api_mcp.core.errors import ErrorCode, ToolError
+from substack_api_mcp.core.tools import tool
+from substack_api_mcp.substack.client import call, publication
+from substack_api_mcp.substack.subscribers import find_subscriber
+
+if TYPE_CHECKING:
+    from substack_api_mcp.core.context import ToolContext
+
+INPUT_SCHEMA: dict[str, Any] = {
+    "type": "object",
+    "properties": {"email": {"type": "string", "description": "Subscriber's email address."}},
+    "required": ["email"],
+    "additionalProperties": False,
+}
+
+EXAMPLE_RESPONSE: dict[str, Any] = {"email": "reader@example.com", "removed": True}
+
+
+@tool(
+    name="remove_subscriber",
+    title="Remove subscriber",
+    access="write",
+    confirm=True,
+    description="Remove one email from your subscriber list.",
+    details=(
+        "Removes a subscriber from your list, as Remove in the subscriber's menu does: they get no more emails "
+        "from you and no notice. A paid subscription is cancelled and Substack refunds the unused part. An "
+        "email not on your list returns an error; add_subscriber takes about a minute before the address is "
+        "listed. By default you confirm each call; you can switch that off for this tool."
+    ),
+    input_schema=INPUT_SCHEMA,
+    route="DELETE /subscribers/{email}",
+    example_response=EXAMPLE_RESPONSE,
+)
+async def remove_subscriber(ctx: ToolContext, args: dict[str, Any]) -> Any:
+
+    email = str(args["email"]).strip()
+    if not re.fullmatch(r"[^@\s/]+@[^@\s/]+\.[^@\s/]+", email):
+        raise ToolError("email must be one email address.", ErrorCode.INVALID_INPUT)
+    pub = await publication(ctx)
+    row = await find_subscriber(ctx, pub, email)
+    if not row:
+        # Substack answers 200 to a removal of an address it does not have, so the table decides.
+        raise ToolError(
+            "This email is not on your subscriber list. One added in the last few minutes may not be listed "
+            "yet; try again shortly.",
+            ErrorCode.TARGET_ERROR,
+        )
+    await call(ctx, "DELETE", f"{pub['base']}/api/v1/subscriber-stats/remove/{row['user_email_address']}")
+    return {"email": row["user_email_address"], "removed": True}