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

> ## Agent Instructions
> Reconify's API reference is read-only for customer data. Do not invent endpoints or authentication behavior beyond the OpenAPI contract.
> The public OpenAPI document contains only the external /v1 contract. Dashboard business routes are intentionally excluded.

# Submit monitoring events

> Durably acknowledge a batch of 1–500 flow-monitoring events. Each event is validated independently; accepted and rejected indexes are returned together.



## OpenAPI

````yaml /openapi/reconify.openapi.json post /v1/events
openapi: 3.1.0
info:
  description: Public event ingestion and issue operations for Reconify.
  title: Reconify API
  version: 1.0.0
servers:
  - description: Reconify API root
    url: https://api.reconifyhq.com
security: []
tags:
  - description: Submit events through the public v1 ingestion API.
    name: Event Ingestion API
  - description: Public API metadata and health checks.
    name: API Metadata
  - description: Read received events and evidence linked to issues.
    name: Event Reads
  - description: Discover and coordinate evidence-backed monitoring issues.
    name: Issue Operations
  - description: Read organization details and assignable member IDs.
    name: Organization
paths:
  /v1/events:
    post:
      tags:
        - Event Ingestion API
      summary: Submit monitoring events
      description: >-
        Durably acknowledge a batch of 1–500 flow-monitoring events. Each event
        is validated independently; accepted and rejected indexes are returned
        together.
      operationId: ingest-monitoring-events
      requestBody:
        content:
          application/json:
            example:
              events:
                - amount: '150.00'
                  currency: USD
                  data:
                    provider: stripe
                    provider_reference: pi_123
                  flow: payment_to_wallet
                  id: evt_01J3Y0M8VJQ5W1R3E4J4K7N8P9
                  occurred_at: '2026-01-01T00:00:00Z'
                  reference: order-123
                  type: payment.succeeded
            schema:
              $ref: '#/components/schemas/MonitoringBatchRequest'
        required: true
      responses:
        '202':
          content:
            application/json:
              example:
                results:
                  - event_id: evt_01J3Y0M8VJQ5W1R3E4J4K7N8P9
                    index: 0
                    status: accepted
              schema:
                $ref: '#/components/schemas/MonitoringBatchResponse'
          description: Accepted
        '400':
          content:
            application/json:
              example:
                code: malformed_request
                message: request body must contain an events array
              schema:
                $ref: '#/components/schemas/Error'
          description: Bad Request
        '401':
          content:
            application/json:
              example:
                code: unauthorized
                message: authentication required
              schema:
                $ref: '#/components/schemas/Error'
          description: Unauthorized
        '403':
          content:
            application/json:
              example:
                code: forbidden
                message: wallet integrity monitoring is not enabled
              schema:
                $ref: '#/components/schemas/Error'
          description: Forbidden
        '413':
          content:
            application/json:
              example:
                code: request_too_large
                message: request exceeds the 5 MiB limit
              schema:
                $ref: '#/components/schemas/Error'
          description: Request Entity Too Large
        '422':
          content:
            application/json:
              example:
                results:
                  - code: invalid_event
                    field: amount
                    index: 0
                    message: amount is required for this event type
                    status: rejected
              schema:
                $ref: '#/components/schemas/MonitoringBatchResponse'
          description: Unprocessable Entity
        '503':
          content:
            application/json:
              example:
                code: database_unavailable
                message: monitoring ingestion is unavailable
              schema:
                $ref: '#/components/schemas/Error'
          description: Service Unavailable
      security:
        - organizationApiKey: []
components:
  schemas:
    MonitoringBatchRequest:
      additionalProperties: false
      properties:
        events:
          description: One to 500 events to validate and ingest.
          items:
            $ref: '#/components/schemas/MonitoringEvent'
          maxItems: 500
          minItems: 1
          type: array
      required:
        - events
      type: object
    MonitoringBatchResponse:
      properties:
        results:
          description: Results in the same order as the submitted events.
          items:
            $ref: '#/components/schemas/MonitoringResult'
          type: array
      required:
        - results
      type: object
    Error:
      properties:
        code:
          description: Stable machine-readable error code.
          type: string
        detail:
          description: Human-readable details about the request failure.
          type: string
        message:
          description: Short human-readable explanation.
          type: string
        status:
          description: HTTP status code for the problem.
          type: integer
        title:
          description: General category of the problem.
          type: string
      type: object
    MonitoringEvent:
      additionalProperties: false
      description: >-
        A monitoring event. Batches are limited to 500 events, requests to
        5242880 bytes, and individual events to 262144 bytes. Amount and
        currency are required for all event types except payment.failed and
        payout.failed; wallet events also require data.wallet_id.
      properties:
        amount:
          description: Decimal amount in the event currency.
          pattern: ^(0|[1-9][0-9]*)(\.[0-9]+)?$
          type: string
        currency:
          description: Three-letter uppercase ISO currency code.
          pattern: ^[A-Z]{3}$
          type: string
        data:
          $ref: '#/components/schemas/MonitoringEventData'
          description: Optional provider, wallet, failure, or retry context.
        flow:
          description: Monitoring flow that defines the expected evidence sequence.
          enum:
            - payment_to_wallet
            - wallet_to_wallet
            - wallet_to_payout
          type: string
        id:
          description: Optional stable ULID used to identify the event across retries.
          pattern: ^evt_[0-9A-Z]{26}$
          type: string
        metadata:
          additionalProperties:
            type:
              - string
              - number
              - boolean
          description: Optional flat key-value context retained with the event.
          maxProperties: 20
          type: object
        occurred_at:
          description: Time when the event occurred in the source system.
          format: date-time
          type: string
        reference:
          description: Stable business reference used to correlate the operation.
          minLength: 1
          type: string
        type:
          description: Lifecycle event type, such as payment.succeeded.
          enum:
            - payment.failed
            - payment.initiated
            - payment.succeeded
            - payout.failed
            - payout.initiated
            - payout.succeeded
            - wallet.credited
            - wallet.debited
            - wallet.refunded
          type: string
      required:
        - flow
        - type
        - reference
      type: object
    MonitoringResult:
      properties:
        code:
          description: Stable machine-readable code for a rejected item.
          enum:
            - invalid_event
            - unknown_field
            - idempotency_conflict
            - duplicate
            - malformed_request
          type: string
        event_id:
          description: Reconify event identifier when the event was stored.
          type: string
        field:
          description: Request field associated with the rejection.
          type: string
        index:
          description: Zero-based position of the event in the request.
          minimum: 0
          type: integer
        message:
          description: Short human-readable explanation.
          type: string
        status:
          description: Whether the event was accepted, duplicated, or rejected.
          enum:
            - accepted
            - duplicate
            - rejected
          type: string
        warnings:
          description: Non-fatal normalization or validation warnings.
          items:
            type: string
          type: array
      required:
        - index
        - status
      type: object
    MonitoringEventData:
      additionalProperties: false
      properties:
        failure_code:
          description: Stable provider or source code for a failed event.
          type: string
        failure_message:
          description: Human-readable failure context from the source system.
          type: string
        provider:
          description: Provider that originated or processed the event.
          type: string
        provider_reference:
          description: Provider-side identifier for the payment or payout.
          type: string
        retryable:
          description: Whether the source considers the failed event retryable.
          type: boolean
        wallet_id:
          description: Wallet identifier associated with a wallet event.
          type: string
      type: object
  securitySchemes:
    organizationApiKey:
      description: Organization API key. Use a write-scoped key for event ingestion.
      scheme: bearer
      type: http

````