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

# Send an event

> Events map to templates, so your application can say *what happened* and let LazyApp decide which template to send. `type` accepts the built-in library plus any event you have defined in the workspace.

Address the recipient with `recipient.phone_number`, or set `recipient.type` to `contact_id` and put the contact uuid in `recipient.value`.

Send `"deliver": false` to record an event without messaging the customer. An event type with no template mapping is refused unless you do. Define your own types with `PUT /v1/event-definitions/{type}`.

**Required scope:** `messages:send`



## OpenAPI

````yaml /api-reference/openapi.json post /v1/events
openapi: 3.1.0
info:
  title: LazyApp API
  version: v1
  description: >-
    One WhatsApp API for developers, SaaS platforms and businesses.


    Every endpoint is Bearer-authenticated with a LazyApp API key, returns JSON,
    and is scoped to the workspace and mode (`live` or `test`) the key belongs
    to.


    Live keys need the Pro plan. A live key on a workspace below Pro gets `402`
    with `code: plan_limit_reached` on every request. Test keys work on every
    plan, so you can build against the test number before you upgrade.


    LazyApp adds 0% to Meta's message rates. Meta bills each message to the
    business's own Meta payment method; your LazyApp plan is billed separately.
  contact:
    name: LazyApp support
    url: https://lazyapp.in
servers:
  - url: https://lazyapp.in
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Messages
    description: Send and schedule WhatsApp messages.
  - name: Contacts
    description: The people you message, and their identifiers.
  - name: Conversations
    description: Threads and their message history.
  - name: Calls
    description: WhatsApp call history for the workspace.
  - name: Templates
    description: Create, submit and sync message templates.
  - name: Media
    description: Upload, retrieve and delete media.
  - name: Broadcasts
    description: Template sends to many contacts at once.
  - name: Events
    description: Say what happened; LazyApp picks the template.
  - name: Flows
    description: WhatsApp Flows and their responses.
  - name: Webhooks
    description: Register endpoints and inspect deliveries.
  - name: Workflows
    description: Automations and their executions.
  - name: Verify
    description: One-time passcodes over WhatsApp.
  - name: Capabilities
    description: What each connected number supports.
  - name: Catalog
    description: Proxy Meta Commerce catalog products for a connection.
  - name: Platform
    description: Manage customers if you run a platform on LazyApp.
  - name: Meta-compatible proxy
    description: Drop-in endpoints for existing Cloud API integrations.
  - name: Connections
    description: >-
      Your WhatsApp numbers and the account behind them: health, limits,
      registration, display name, blue tick, QR codes, conversation starters,
      opt-in links, business profile and blocked users.
  - name: Billing
    description: >-
      Meta's message rates, which LazyApp passes on with 0% added, and the
      billing facts behind them.
  - name: Analytics
    description: Workspace messaging aggregates.
  - name: Groups
    description: WhatsApp group chats on a connection Meta has enabled.
  - name: Funding
    description: Local funding status and recorded WhatsApp charges.
  - name: Connections
    description: 'WhatsApp connections: block users, business profile, insights.'
  - name: Payments
    description: >-
      WhatsApp payments in India: ask for payment, follow it, update the order
      and refund.
paths:
  /v1/events:
    post:
      tags:
        - Events
      summary: Send an event
      description: >-
        Events map to templates, so your application can say *what happened* and
        let LazyApp decide which template to send. `type` accepts the built-in
        library plus any event you have defined in the workspace.


        Address the recipient with `recipient.phone_number`, or set
        `recipient.type` to `contact_id` and put the contact uuid in
        `recipient.value`.


        Send `"deliver": false` to record an event without messaging the
        customer. An event type with no template mapping is refused unless you
        do. Define your own types with `PUT /v1/event-definitions/{type}`.


        **Required scope:** `messages:send`
      parameters:
        - name: Idempotency-Key
          in: header
          description: >-
            Optional. Makes this write safe to retry: the same key replays the
            first response instead of acting twice.
          schema:
            type: string
            maxLength: 255
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                type:
                  type: string
                  maxLength: 64
                  example: order.shipped
                recipient:
                  type: object
                  properties:
                    type:
                      type: string
                      enum:
                        - phone_number
                        - contact_id
                    value:
                      type: string
                      maxLength: 64
                      description: >-
                        The contact uuid when `type` is `contact_id`. With
                        `type` `phone_number` (the default) you may put the
                        number here instead of in `phone_number`.
                    phone_number:
                      type: string
                      maxLength: 32
                      description: >-
                        Required unless addressing by `contact_id`, or giving
                        the number in `value`.
                properties:
                  type: object
                  properties: {}
                idempotency_key:
                  type: string
                  maxLength: 191
                deliver:
                  type: boolean
                  default: true
                  description: >-
                    `false` records the event in the history and starts
                    `api_event` workflows without sending a message, for things
                    like a qualified lead or a check-in. Answered with 202.
              required:
                - type
                - recipient
      responses:
        '201':
          description: Accepted. Returns the message the event produced.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/EventAccepted'
        '202':
          description: 'Recorded without sending (`deliver: false`).'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/EventRecorded'
        '401':
          description: Missing or invalid API key.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '402':
          $ref: '#/components/responses/PlanLimitReached'
        '403':
          description: >-
            The key lacks the required scope, or is restricted from this phone
            number.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '422':
          description: Validation failed.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ValidationError'
        '429':
          description: Rate limit exceeded.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    EventAccepted:
      type: object
      properties:
        uuid:
          type: string
          description: The message the event produced.
        event_uuid:
          type: string
          nullable: true
          description: The recorded business event.
        request_id:
          type: string
          nullable: true
        status:
          type: string
        type:
          type: string
        provider_message_id:
          type: string
          nullable: true
        error_message:
          type: string
          nullable: true
    EventRecorded:
      type: object
      properties:
        uuid:
          type: string
          nullable: true
          description: 'Always null: no message was sent.'
        event_uuid:
          type: string
        status:
          type: string
          enum:
            - recorded
        type:
          type: string
    Error:
      type: object
      properties:
        message:
          type: string
          description: Human-readable description of what went wrong.
        code:
          type: string
          description: >-
            Stable machine-readable reason, when the failure is one a client can
            branch on.
      required:
        - message
    ValidationError:
      type: object
      properties:
        message:
          type: string
        errors:
          type: object
          additionalProperties:
            type: array
            items:
              type: string
          description: Field name to list of failures.
      required:
        - message
  responses:
    PlanLimitReached:
      description: >-
        The workspace's plan does not allow this. A live key on a workspace
        below Pro gets this on every request, because the live API is a Pro
        feature. Upgrade in **Billing** to use live keys. Test keys are never
        limited, on any plan.


        `code` is always `plan_limit_reached`. Show `message` to the person: it
        names the plan to move to.


        Other plan limits use the same code in the console, but the API reports
        them differently today: a broadcast larger than the month's remaining
        Live broadcast sends is refused with `422` and the reason in `message`,
        and connecting a number beyond the plan's number capacity fails
        validation (`422`) on `phone_number_id`.
      content:
        application/json:
          schema:
            type: object
            properties:
              message:
                type: string
                description: >-
                  A sentence you can show to the person. Says which plan to move
                  to.
              code:
                type: string
                enum:
                  - plan_limit_reached
            required:
              - message
              - code
          example:
            message: >-
              The API is on the Pro plan. Upgrade in Billing to use live keys.
              Test keys keep working.
            code: plan_limit_reached
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Your API key, e.g. `sk_live_...` or `sk_test_...`.

````

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