limitry.client.Events

class limitry.client.Events[source]

Bases: object

Operations for events.

__init__(client)[source]

Initialize Events operations.

Parameters:

client (Client) – The Limitry client instance

Return type:

None

Methods

__init__(client)

Initialize Events operations.

ingest(request)

Ingest a usage event.

ingest_batch(request)

Ingest multiple usage events.

list([customer_id, event_type, model, ...])

List usage events.
__init__(client)[source]

Initialize Events operations.

Parameters:

client (Client) – The Limitry client instance

Return type:

None

async list(customer_id=None, event_type=None, model=None, limit=None, cursor=None)[source]

List usage events.

Retrieve a paginated list of usage events with optional filtering.

Use cursor-based pagination by passing the nextCursor from the previous response. You can filter events by customer, event type, or model.

Pagination: - Use the cursor parameter from the previous response’s nextCursor field - The hasMore field indicates if there are more results - Maximum limit is 100 events per request.

Parameters:

  • customer_id (Optional[str]) – Filter events by customer ID

  • event_type (Optional[str]) – Filter events by type (e.g., “model_call”, “embedding”)

  • model (Optional[str]) – Filter events by model name (e.g., “gpt-4”, “claude-3”)

  • limit (Optional[str]) – Maximum number of events to return (1-100, default: 50) (default: “50”)

  • cursor (Optional[str]) – Pagination cursor from the previous response

Returns:

List of events

Return type:

PaginatedResponse[Event]

Example:

items = await client.events.list()
for item in items.data:
    print(item)
Raises:
Parameters:

  • customer_id (str | None)

  • event_type (str | None)

  • model (str | None)

  • limit (str | None)

  • cursor (str | None)

Return type:

PaginatedResponse[Event]

async ingest(request)[source]

Ingest a usage event.

Record a single usage event for metering and analytics.

This endpoint only records the event without checking quotas or rate limits. For quota enforcement and rate limiting, use POST /v1/track instead.

When to use this endpoint: - Recording events for analytics only - Post-event tracking after successful operations - Bulk ingestion without enforcement

When to use /v1/track instead: - Need quota enforcement before processing - Need rate limit checking - Want all-in-one tracking with enforcement.

Parameters:

request (EventsPostRequest) – EventsPostRequest object

Returns:

Event ingested successfully

Return type:

EventsPostResponse

Example:

request = EventsPostRequest(
    customerId="customerid_123",
    eventType="example",
    model="example",
    provider="provider_123"
    # ... other properties
)

result = await client.events.ingest(
    request
)
print(result)
Raises:
Parameters:

request (EventsPostRequest)

Return type:

EventsPostResponse

async ingest_batch(request)[source]

Ingest multiple usage events.

Record multiple usage events in a single request for efficient bulk ingestion.

Limits: - Maximum 1000 events per batch - Events are processed asynchronously - All events must be valid or the entire batch will be rejected

Use cases: - Bulk import of historical data - Batch processing of events - High-throughput event ingestion

For quota enforcement and rate limiting, use POST /v1/track instead.

Parameters:

request (EventsBatchPostRequest) – EventsBatchPostRequest object

Returns:

Events ingested successfully

Return type:

EventsBatchPostResponse

Example:

request = EventsBatchPostRequest(
    events=[]
)

result = await client.events.ingest_batch(
    request
)
print(result)
Raises:
Parameters:

request (EventsBatchPostRequest)

Return type:

EventsBatchPostResponse