> ## Documentation Index
> Fetch the complete documentation index at: https://docs.erdo.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# GetSendingDomainAPI reads one sending domain, named by the domain itself.


> Mirrors erdo\_get\_sending\_domain — the endpoint to poll while a customer's DNS change propagates.




## OpenAPI

````yaml /api/openapi.json get /v1/sending-domains/{domain}
openapi: 3.0.0
info:
  title: Erdo API
  description: >-
    Erdo's REST API: query and write datasets, run agents, manage threads,
    integrations, pages, evals, workstreams, and experiments. Authenticate with
    a Bearer API key (erdo_api_...) or scoped token (erdo_token_...).
  version: '2026-08-07'
servers:
  - url: https://api.erdo.ai
    description: Production
security:
  - bearerAuth: []
paths:
  /v1/sending-domains/{domain}:
    get:
      summary: >
        GetSendingDomainAPI reads one sending domain, named by the domain
        itself.
      description: >
        Mirrors erdo\_get\_sending\_domain — the endpoint to poll while a
        customer's DNS change propagates.
      operationId: GET:mcp.GetSendingDomainAPI
      parameters:
        - allowEmptyValue: true
          explode: false
          in: path
          name: domain
          required: true
          schema:
            type: string
          style: simple
      responses:
        '200':
          content:
            application/json:
              schema:
                properties:
                  created_at:
                    title: |
                      CreatedAt is when the domain was registered (RFC 3339).
                    type: string
                  dns_records:
                    description: >
                      provider. Kept after verification too, so a domain that
                      regresses can be compared against what should exist.
                    items:
                      $ref: '#/components/schemas/mcp.SendingDomainDNSRecord'
                    title: >
                      DNSRecords is the set of records the customer must have at
                      their DNS
                    type: array
                  domain:
                    description: >
                      punycode) — an apex ("acme.com") or a subdomain
                      ("hello.acme.com"). It is the identifier every other
                      sending-domain endpoint takes.
                    title: >
                      Domain is the customer domain mail is sent from,
                      normalized (lowercase,
                    type: string
                  error_reason:
                    description: |
                      (e.g. the DKIM record was not found); empty otherwise.
                    title: >
                      ErrorReason is the human-readable reason when status is
                      failed or disabled
                    type: string
                  existing_mx_detected:
                    description: >
                      at a mailbox provider (Google Workspace, Microsoft 365)
                      when it was registered. Adding Erdo's MX to that same name
                      would break the customer's existing mail, so receiving
                      must instead be set up on a subdomain ("hello.acme.com")
                      or left off — say so rather than handing over the MX
                      record.
                    title: >
                      ExistingMXDetected is true when the domain already had MX
                      records pointing
                    type: boolean
                  forward_to_email:
                    description: >
                      business reads its own mail in the place it already works.
                      Empty means replies are stored in Erdo only.
                    title: >
                      ForwardToEmail is the real mailbox a received reply is
                      copied to, so the
                    type: string
                  from_email:
                    description: |
                      active — from\_local\_part@domain.
                    title: >
                      FromEmail is the address outbound mail is sent from once
                      the domain is
                    type: string
                  from_local_part:
                    title: >
                      FromLocalPart is the part before the @ ("hello" by
                      default).
                    type: string
                  from_name:
                    description: |
                      means the address shows alone.
                    title: >
                      FromName is the display name on the From header (e.g.
                      "Acme Sales"). Empty
                    type: string
                  last_checked_at:
                    description: |
                      provider (RFC 3339); empty if never checked yet.
                    title: >
                      LastCheckedAt is when the status was last reconciled
                      against the mail
                    type: string
                  receiving_enabled:
                    description: >
                      Erdo. It requires the MX record among dns\_records, which
                      cannot coexist with an existing mailbox provider's MX on
                      the same name — see existing\_mx\_detected.
                    title: >
                      ReceivingEnabled is whether replies to from_email are
                      accepted back into
                    type: boolean
                  registered_receiving:
                    description: >
                      the provider, fixed for the registration's life. False
                      means receiving can never be enabled on this registration
                      — to receive, remove the domain and register it (or a
                      subdomain) again.
                    title: >
                      RegisteredReceiving is the capability the domain was
                      registered with at
                    type: boolean
                  status:
                    description: >
                      customer to create the listed DNS records), "active"
                      (verified — mail now leaves from this domain), "failed" (a
                      record is missing or wrong; see error\_reason), or
                      "disabled" (deregistered upstream). Only "active" changes
                      what recipients see; every other state means sends still
                      go out as hello@mail.erdo.ai.
                    title: >
                      Status is the domain's lifecycle state: "pending_dns"
                      (waiting for the
                    type: string
                  updated_at:
                    title: >
                      UpdatedAt is when the registration last changed (RFC
                      3339).
                    type: string
                type: object
          description: Success response
        default:
          $ref: '#/components/responses/APIError'
components:
  schemas:
    mcp.SendingDomainDNSRecord:
      description: >
        provider for a sending domain to verify. Fields are spelled out (never
        embedded) so the OpenAPI spec carries them.
      properties:
        name:
          description: >
            domain's DNS zone (e.g. "send.hello" for a domain hello.acme.com),
            which is the form most DNS hosts expect typed in.
          title: |
            Name is the record name as the provider states it — relative to the
          type: string
        type:
          description: |
            (receiving).
          title: |
            Type is the record type to create: "TXT" (DKIM/SPF/DMARC) or "MX"
          type: string
        value:
          title: |
            Value is the record's target/content.
          type: string
      title: >
        SendingDomainDNSRecord is one DNS record the customer must create at
        their DNS
      type: object
  responses:
    APIError:
      content:
        application/json:
          schema:
            externalDocs:
              url: https://pkg.go.dev/encore.dev/beta/errs#Error
            properties:
              code:
                description: Error code
                example: not_found
                externalDocs:
                  url: https://pkg.go.dev/encore.dev/beta/errs#ErrCode
                type: string
              details:
                description: Error details
                type: object
              message:
                description: Error message
                type: string
            title: APIError
            type: object
      description: Error response
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: An Erdo API key (erdo_api_...) or scoped token (erdo_token_...).

````