For Agents

Agent-first, human-friendly email ops.

SendyKit wraps around Sendy without modifying core, giving humans and agents a modern API, CLI, analytics, AI, health diagnostics, and managed email operations. The current paid-agent path is Stripe-native machine payments for premium actions. Sending still requires verified-domain trust.

See Pricing Read the Docs
402
Payment Required Flow
Stripe
Machine-Payment Path
$1
One-Time Verification
$0.01
Send / Email
Protocol Flow

Premium actions get paid. Sending gets trust-gated.

01

Premium action hits the API

An agent hits a premium SendyKit endpoint and receives a 402 response that explains the machine-payment requirement.

02

Stripe machine-payment proof

The agent retries with an X-Stripe-Machine-Payment proof or intent reference. That is the current customer path for premium actions.

03

One-time sender verification

For sending, the agent still needs verified domain ownership and the sender-trust path before using shared delivery infrastructure.

04

Trusted send path

After DNS confirmation, the agent can send through the verified, reputation-protected path with warm-up and abuse controls still in force.

Pricing

Machine-paid premium actions. Verified access for sending.

Machine-Paid Actions
TierPriceExamples
Read$0.0001 / reqCampaigns, subscribers, analytics
Write$0.001 / reqDraft campaigns, subscriber updates
AI$0.005 / reqAuthoring, subject lines, variants
Analytics$0.0005 / reqReports, dashboards, summaries
Bulk$0.05 / reqImports, batch actions

Current target: Stripe-native machine payments for premium agent work. Market it as machine payments, not as a separate raw protocol path.

  • Best for drafts, reads, analytics, and orchestration
  • Designed for agents that need a serious control surface
  • Matches the current implementation target and auth matrix
Verified Sender
TierPriceRequires
Send$0.01 / emailVerified domain + sender token
Verify$1 one-timeDNS ownership proof + DKIM path

Once verified, agents send through a trust-gated path with warm-up limits, reputation scoring, and isolated IP protection.

  • Weekly DNS re-checks keep sender tokens honest
  • New senders start on isolated IP pools
  • AUP and deliverability guardrails stay in force
Trust Model

What keeps the send path honest.

Sender token

Verification returns a sender token tied to DNS ownership. Remove the DNS records and the token can be suspended automatically.

Warm-up limits

New senders start small. Limits expand with clean behavior instead of letting fresh domains spray shared infrastructure on day one.

Reputation scoring

Bounces, complaints, spam traps, and unhealthy unsubscribe rates reduce sender trust. Clean sending earns more headroom.

Isolated IP pools

New verified senders start on an isolated pool so bad actors cannot immediately poison the reputation of paying SaaS tenants.

AUP stays explicit

Acceptable-use requirements should be surfaced clearly in the payment and verification flow, not buried in a fake growth-hack promise.

Human-friendly reality

If an agent cannot place DNS records itself, it can still hand the exact records to a human and resume after verification. No fake purity tests.

Code Examples

Use the API from whatever your agent already speaks.

Python

import requests

response = requests.post(
    "https://app.sendykit.dev/sendykit/api/v2/ai/generate-email",
    headers={
        "X-API-Key": "sk_live_...",
        "X-Stripe-Machine-Payment": "payment_proof_or_intent_ref",
        "Content-Type": "application/json",
    },
    json={"brief": "Launch email for SaaS Growth"},
)
print(response.json())

Node.js

const res = await fetch(
  "https://app.sendykit.dev/sendykit/api/v2/ai/subject-lines",
  {
    method: "POST",
    headers: {
      "X-API-Key": "sk_live_...",
      "X-Stripe-Machine-Payment": "payment_proof_or_intent_ref",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ context: "Managed email ops" }),
  }
);
console.log(await res.json());

Go

req, _ := http.NewRequest(
  http.MethodPost,
  "https://app.sendykit.dev/sendykit/api/v2/ai/rewrite-for-email",
  strings.NewReader(`{"text":"Ship the release today"}`),
)
req.Header.Set("X-API-Key", "sk_live_...")
req.Header.Set("X-Stripe-Machine-Payment", "payment_proof_or_intent_ref")
req.Header.Set("Content-Type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil { log.Fatal(err) }
Reality Check

Agent first does not mean anonymous anything-goes.

What is current

  • API + CLI are first-class surfaces
  • Premium actions use Stripe machine payments
  • Premium send still needs verified domain trust
  • Website copy should not pretend a separate raw protocol path is live

What is not negotiable

  • Sending requires verified domain ownership
  • DKIM path and sender token must remain valid
  • AUP, warm-up, and reputation guardrails apply
  • Bad actors do not get a free shared-IP attack lane

Use the control surface now. Earn the send path once.

That is the honest agent story: API and CLI for real automation, Stripe machine payments for premium actions, and explicit trust controls for anything that touches delivery reputation.

->