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

# Count Attendees

> **Tool name:** `search_attendee_count` · **Behaviour:** 🔒 Read-only

Count event registrations matching filters. Same filters as search_attendees, but returns only the number of matching registrations — no row data, no pagination. Prefer this over search_attendees when the user only needs a count (e.g. 'how many people registered', 'how many are still pending').

**MCP-only:** this tool has no equivalent Public API endpoint.



## OpenAPI

````yaml https://api.prod.zuddl.com/api/v3/api-docs/mcp-tools post /tools/search_attendee_count
openapi: 3.1.0
info:
  title: Zuddl MCP Tools Reference
  description: >-
    The Zuddl MCP server lets AI assistants such as Claude and ChatGPT work with
    your Zuddl organization through the [Model Context
    Protocol](https://modelcontextprotocol.io). This reference lists every tool
    the server offers. It is generated from the live server, so it always
    matches what your assistant sees.


    # Connecting


    Add `https://setup.zuddl.com/api/mcp` as a remote MCP server in your
    assistant. It signs you in to Zuddl with OAuth and then calls tools on your
    behalf, with your permissions. AI features must be enabled for your
    organization.


    # Calling a tool


    Assistants call a tool with a JSON-RPC `tools/call` request whose `name` is
    the tool name and whose `arguments` match the request body documented on the
    tool's page. The `/tools/<name>` paths in this reference identify tools;
    they are not HTTP endpoints.


    # Behaviour labels


    | Label | Meaning |

    | --- | --- |

    | 🔒 Read-only | Reads data and changes nothing. |

    | ✏️ Write | Creates or updates data, but does not delete it. |

    | ⚠️ Destructive | Deletes or removes data. Most assistants ask you to
    approve these calls. |

    | 🔁 Idempotent | Calling it again with the same arguments has no further
    effect. |


    A tool that mirrors a Public API endpoint links to that endpoint's page.
    MCP-only tools have no Public API equivalent.
  version: 1.0.0
servers:
  - url: https://setup.zuddl.com/api/mcp
    description: Zuddl MCP server
security:
  - oauth: []
tags:
  - name: Events
  - name: Attendees
  - name: Sessions
  - name: Speakers
  - name: Sponsors
  - name: Locations
  - name: Teams
  - name: Brand Kits
  - name: Registration flows & tickets
  - name: Analytics
paths:
  /tools/search_attendee_count:
    post:
      tags:
        - Attendees
      summary: Count Attendees
      description: >-
        **Tool name:** `search_attendee_count` · **Behaviour:** 🔒 Read-only


        Count event registrations matching filters. Same filters as
        search_attendees, but returns only the number of matching registrations
        — no row data, no pagination. Prefer this over search_attendees when the
        user only needs a count (e.g. 'how many people registered', 'how many
        are still pending').


        **MCP-only:** this tool has no equivalent Public API endpoint.
      operationId: search_attendee_count
      requestBody:
        description: The tool's `arguments`, as sent in a JSON-RPC `tools/call` request.
        content:
          application/json:
            schema:
              type: object
              additionalProperties: false
              properties:
                eventIds:
                  type: array
                  description: >-
                    One or more Zuddl event IDs to scope the search to. Omit to
                    search across all events the caller is authorized for.
                  items:
                    type: string
                filters:
                  type: array
                  description: >
                    Filter criteria. ALL criteria are combined with AND; for an
                    OR across different fields, call this tool once per
                    condition. To match any of several values of the SAME field,
                    use one criterion with the in operation (e.g. status in
                    [PENDING, APPROVED]). Each criterion applies one operation
                    to one field. Only the field/operation combinations listed
                    below are valid:

                    - email (operations: eq, in, like, ilike): Attendee email
                    address. Use this when the user provides an email — it
                    identifies a unique attendee.

                    - firstName (operations: ilike, not_ilike): Attendee first
                    name. Combine with `lastName` for a precise full-name
                    search; for a single name token whose position is unknown
                    use the virtual `name` field instead.

                    - lastName (operations: ilike, not_ilike): Attendee last
                    name. Combine with `firstName` for a precise full-name
                    search; for a single name token whose position is unknown
                    use the virtual `name` field instead.

                    - ticketTypeId (operations: eq, in): Ticket type ID (UUID).
                    Only use when the user asks about a specific ticket type;
                    resolve names to IDs with search_ticket_type first.

                    - flowId (operations: eq, in): Registration flow ID (UUID).
                    Scopes results to attendees registered through specific
                    registration flows; resolve names to IDs with search_flow
                    first.

                    - bio (operations: eq, like, ilike): Attendee bio / about
                    text.

                    - designation (operations: eq, like, ilike): Attendee job
                    title / designation (e.g. 'CTO', 'Product Manager').

                    - company (operations: eq, like, ilike): Attendee company
                    name. With the ilike operation, matching also checks the
                    email domain, since the company name often appears there
                    (e.g. 'Acme' matches jane@acme.com).

                    - phoneNumber (operations: eq): Attendee phone number (exact
                    match only).

                    - country (operations: eq, like, ilike, in): Country the
                    attendee provided at registration.

                    - ipCity (operations: eq, in, like, ilike): City derived
                    from the attendee's IP address at registration time.

                    - ipState (operations: eq, in, like, ilike): State/region
                    derived from the attendee's IP address at registration time.

                    - ipCountry (operations: eq, in, like, ilike): Country
                    derived from the attendee's IP address at registration time.

                    - status (operations: eq, in): Registration status. Omit to
                    include all statuses. Values: one of PENDING, REJECTED,
                    APPROVED, DELETED, APPROVED_NOT_REGISTERED, INCOMPLETE.

                    - source (operations: eq, in): How the registration was
                    created (e.g. self sign-up vs. imported). Values: one of
                    LANDING_PAGE_V1, LANDING_PAGE_V2, DUDA_REGISTRATION_FORM,
                    DUDA_TICKETING_BUYER, DUDA_TICKETING_MAPPING,
                    EMBED_REGISTRATION_FORM, TICKETING_BUYER, TICKETING_MAPPING,
                    BULK_IMPORT, ATTENDEE_INVITE, ATTENDEE_ADD_FORM, HUBSPOT,
                    SALESFORCE, MARKETO, EXPLARA, PROTECH, CERTAIN, UNKNOWN,
                    REGISTRATION_WEBHOOK, ANDROID_ORGANIZER_APP,
                    IOS_ORGANIZER_APP, AVENTRI, EVENT_BRITE, PARDOT, EMBED_FLOW,
                    TEAM_OR_PLAN_CHANGE_INTERNAL, SPEAKER_ADD_FORM,
                    BULK_SPEAKER_IMPORT, CREATE_EVENT, MOVE_EVENT, ADD_TO_TEAM,
                    LEAD_SCAN, PARENT_EVENT, EVENT_REGISTRATION_API_V1,
                    ZOOM_IMPORT.

                    - sourceType (operations: eq, in): Source type of the
                    registration. Values: one of ATTENDEE_SIDE, ORGANIZER_SIDE,
                    INTEGRATION, UNKNOWN, LEAD_CAPTURE, ZUDDL_API.

                    - createdBy (operations: eq): Account ID of the user who
                    created the registration (exact match).

                    - createdAt (operations: eq, gt, lt, gte, lte, between):
                    When the registration was created. ISO-8601 with offset,
                    e.g. 2026-05-01T00:00:00Z. Use gte/lte for open ranges or
                    between for a closed range. Values: ISO-8601 date-time with
                    offset, e.g. 2026-05-01T00:00:00Z.

                    - name (operations: ilike): Attendee name matched against
                    first name OR last name. Accepts a full name: it is split on
                    whitespace and every part must match the first or last name,
                    in any order. Use when it's unclear how the name splits into
                    first and last name. If multiple attendees match, ask the
                    user to clarify by email.
                  items:
                    type: object
                    additionalProperties: false
                    properties:
                      field:
                        type: string
                        enum:
                          - email
                          - firstName
                          - lastName
                          - ticketTypeId
                          - flowId
                          - bio
                          - designation
                          - company
                          - phoneNumber
                          - country
                          - ipCity
                          - ipState
                          - ipCountry
                          - status
                          - source
                          - sourceType
                          - createdBy
                          - createdAt
                          - name
                      operation:
                        type: string
                        description: >-
                          eq = equals, in = any of the values, like =
                          case-sensitive substring match, ilike =
                          case-insensitive substring match, not_like = negated
                          like, not_ilike = negated ilike, gt / gte / lt / lte =
                          comparison, between = inclusive range.
                        enum:
                          - eq
                          - in
                          - like
                          - ilike
                          - not_ilike
                          - gt
                          - lt
                          - gte
                          - lte
                          - between
                      values:
                        type: array
                        description: >-
                          Exactly 1 value for every operation except: in (1 or
                          more) and between (exactly 2).
                        items:
                          type: string
                        minItems: 1
                    required:
                      - field
                      - operation
                      - values
        required: true
      responses:
        '200':
          description: A JSON-RPC `tools/call` result. The tool's output is in `content`.
components:
  securitySchemes:
    oauth:
      type: http
      description: >-
        OAuth 2.1 access token. MCP clients obtain it themselves (dynamic client
        registration + PKCE) when you connect them to the server URL above.
      scheme: bearer

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.