Revenuecat Webhooks

RevenueCat Webhooks Skill

This skill covers everything needed to understand, implement, and maintain a RevenueCat webhook listener — with a focus on ASP.NET Core / C# (.NET) backends.

Quick Reference

• RevenueCat sends POST requests with a JSON body to your HTTPS endpoint
• Your server must return HTTP 200 within 60 seconds
• RevenueCat retries up to 5 times (delays: 5, 10, 20, 40, 80 minutes)
• Always make your handler idempotent — deduplication by event.id
• Available on the Pro plan only

---

1. Setup (Dashboard)

1. Go to Project → Integrations → Webhooks → Add new configuration 2. Name the webhook, enter your HTTPS URL 3. (Optional) Set an Authorization header — RevenueCat sends this with every request; validate it in your handler 4. Choose environment: Production, Sandbox, or Both 5. Optionally filter to specific apps or event types

---

2. Payload Structure

Every webhook is a POST with Content-Type: application/json:

{
  "api_version": "1.0",
  "event": {
    "type": "INITIAL_PURCHASE",
    "id": "UniqueEventID",
    "app_id": "yourAppID",
    "event_timestamp_ms": 1591121855319,
    "app_user_id": "yourCustomerAppUserID",
    "original_app_user_id": "OriginalAppUserID",
    "aliases": ["alias1", "alias2"],
    "product_id": "onemonth_no_trial",
    "entitlement_ids": ["pro_cat"],
    "period_type": "NORMAL",
    "purchased_at_ms": 1591121853000,
    "expiration_at_ms": 1591726653000,
    "store": "APP_STORE",
    "environment": "PRODUCTION",
    "currency": "USD",
    "price": 2.49,
    "price_in_purchased_currency": 2.49,
    "transaction_id": "170000869511114",
    "original_transaction_id": "1530648507000",
    "subscriber_attributes": {}
  }
}

For the full field reference, see → references/fields.md For sample payloads per event type, see → references/sample-events.md

---

3. All Event Types

Key access-control rules:

• Grant access on: INITIAL_PURCHASE, RENEWAL, UNCANCELLATION, SUBSCRIPTION_EXTENDED, TEMPORARY_ENTITLEMENT_GRANT
• Revoke access on: EXPIRATION only (NOT on CANCELLATION or SUBSCRIPTION_PAUSED)
• Use expiration_at_ms to determine if a subscription is still active

---

4. .NET Implementation

4a. Models (C#)

public class RevenueCatWebhookPayload
{
    [JsonPropertyName("api_version")]
    public string ApiVersion { get; set; } = string.Empty;

    [JsonPropertyName("event")]
    public RevenueCatEvent Event { get; set; } = new();
}

public class RevenueCatEvent
{
    [JsonPropertyName("type")]
    public string Type { get; set; } = string.Empty;

    [JsonPropertyName("id")]
    public string Id { get; set; } = string.Empty;

    [JsonPropertyName("app_id")]
    public string? AppId { get; set; }

    [JsonPropertyName("event_timestamp_ms")]
    public long EventTimestampMs { get; set; }

    [JsonPropertyName("app_user_id")]
    public string? AppUserId { get; set; }

    [JsonPropertyName("original_app_user_id")]
    public string? OriginalAppUserId { get; set; }

    [JsonPropertyName("aliases")]
    public List<string> Aliases { get; set; } = new();

    [JsonPropertyName("product_id")]
    public string? ProductId { get; set; }

    [JsonPropertyName("entitlement_ids")]
    public List<string>? EntitlementIds { get; set; }

    [JsonPropertyName("period_type")]
    public string? PeriodType { get; set; }

    [JsonPropertyName("purchased_at_ms")]
    public long? PurchasedAtMs { get; set; }

    [JsonPropertyName("expiration_at_ms")]
    public long? ExpirationAtMs { get; set; }

    [JsonPropertyName("store")]
    public string? Store { get; set; }

    [JsonPropertyName("environment")]
    public string? Environment { get; set; }

    [JsonPropertyName("currency")]
    public string? Currency { get; set; }

    [JsonPropertyName("price")]
    public double? Price { get; set; }

    [JsonPropertyName("price_in_purchased_currency")]
    public double? PriceInPurchasedCurrency { get; set; }

    [JsonPropertyName("transaction_id")]
    public string? TransactionId { get; set; }

    [JsonPropertyName("original_transaction_id")]
    public string? OriginalTransactionId { get; set; }

    [JsonPropertyName("cancel_reason")]
    public string? CancelReason { get; set; }

    [JsonPropertyName("expiration_reason")]
    public string? ExpirationReason { get; set; }

    [JsonPropertyName("is_trial_conversion")]
    public bool? IsTrialConversion { get; set; }

    [JsonPropertyName("new_product_id")]
    public string? NewProductId { get; set; }

    [JsonPropertyName("subscriber_attributes")]
    public Dictionary<string, SubscriberAttribute>? SubscriberAttributes { get; set; }

    [JsonPropertyName("transferred_from")]
    public List<string>? TransferredFrom { get; set; }

    [JsonPropertyName("transferred_to")]
    public List<string>? TransferredTo { get; set; }

    [JsonPropertyName("is_family_share")]
    public bool? IsFamilyShare { get; set; }

    [JsonPropertyName("country_code")]
    public string? CountryCode { get; set; }

    [JsonPropertyName("renewal_number")]
    public int? RenewalNumber { get; set; }
}

public class SubscriberAttribute
{
    [JsonPropertyName("value")]
    public string? Value { get; set; }

    [JsonPropertyName("updated_at_ms")]
    public long UpdatedAtMs { get; set; }
}

// Strongly-typed event type constants
public static class RevenueCatEventType
{
    public const string Test = "TEST";
    public const string InitialPurchase = "INITIAL_PURCHASE";
    public const string Renewal = "RENEWAL";
    public const string Cancellation = "CANCELLATION";
    public const string Uncancellation = "UNCANCELLATION";
    public const string NonRenewingPurchase = "NON_RENEWING_PURCHASE";
    public const string SubscriptionPaused = "SUBSCRIPTION_PAUSED";
    public const string Expiration = "EXPIRATION";
    public const string BillingIssue = "BILLING_ISSUE";
    public const string ProductChange = "PRODUCT_CHANGE";
    public const string Transfer = "TRANSFER";
    public const string SubscriptionExtended = "SUBSCRIPTION_EXTENDED";
    public const string TemporaryEntitlementGrant = "TEMPORARY_ENTITLEMENT_GRANT";
    public const string RefundReversed = "REFUND_REVERSED";
    public const string InvoiceIssuance = "INVOICE_ISSUANCE";
    public const string VirtualCurrencyTransaction = "VIRTUAL_CURRENCY_TRANSACTION";
    public const string ExperimentEnrollment = "EXPERIMENT_ENROLLMENT";
}

4b. Controller / Endpoint

[ApiController]
[Route("webhooks")]
public class RevenueCatWebhookController : ControllerBase
{
    private readonly IRevenueCatWebhookService _webhookService;
    private readonly IConfiguration _configuration;
    private readonly ILogger<RevenueCatWebhookController> _logger;

    public RevenueCatWebhookController(
        IRevenueCatWebhookService webhookService,
        IConfiguration configuration,
        ILogger<RevenueCatWebhookController> logger)
    {
        _webhookService = webhookService;
        _configuration = configuration;
        _logger = logger;
    }

    [HttpPost("revenuecat")]
    public async Task<IActionResult> HandleWebhook(
        [FromBody] RevenueCatWebhookPayload payload,
        CancellationToken cancellationToken)
    {
        // 1. Validate authorization header
        if (!ValidateAuthorization())
            return Unauthorized();

        // 2. Respond fast — queue for background processing
        _ = Task.Run(() => _webhookService.ProcessAsync(payload, cancellationToken), cancellationToken);

        // 3. Always return 200 quickly
        return Ok();
    }

    private bool ValidateAuthorization()
    {
        var expectedToken = _configuration["RevenueCat:WebhookAuthorizationHeader"];
        if (string.IsNullOrEmpty(expectedToken))
            return true; // No auth configured — skip validation

        if (!Request.Headers.TryGetValue("Authorization", out var receivedToken))
            return false;

        return receivedToken == expectedToken;
    }
}

4c. Service with Idempotency + Event Routing

public interface IRevenueCatWebhookService
{
    Task ProcessAsync(RevenueCatWebhookPayload payload, CancellationToken ct);
}

public class RevenueCatWebhookService : IRevenueCatWebhookService
{
    private readonly ISubscriptionRepository _subscriptions;
    private readonly IProcessedEventRepository _processedEvents;
    private readonly ILogger<RevenueCatWebhookService> _logger;

    public RevenueCatWebhookService(
        ISubscriptionRepository subscriptions,
        IProcessedEventRepository processedEvents,
        ILogger<RevenueCatWebhookService> logger)
    {
        _subscriptions = subscriptions;
        _processedEvents = processedEvents;
        _logger = logger;
    }

    public async Task ProcessAsync(RevenueCatWebhookPayload payload, CancellationToken ct)
    {
        var evt = payload.Event;

        // Idempotency check — skip duplicate events
        if (await _processedEvents.HasBeenProcessedAsync(evt.Id, ct))
        {
            _logger.LogInformation("Duplicate webhook event {EventId} — skipped", evt.Id);
            return;
        }

        _logger.LogInformation("Processing RevenueCat event {Type} for user {UserId}",
            evt.Type, evt.AppUserId);

        try
        {
            await (evt.Type switch
            {
                RevenueCatEventType.InitialPurchase => HandleInitialPurchaseAsync(evt, ct),
                RevenueCatEventType.Renewal => HandleRenewalAsync(evt, ct),
                RevenueCatEventType.Cancellation => HandleCancellationAsync(evt, ct),
                RevenueCatEventType.Uncancellation => HandleUncancellationAsync(evt, ct),
                RevenueCatEventType.Expiration => HandleExpirationAsync(evt, ct),
                RevenueCatEventType.BillingIssue => HandleBillingIssueAsync(evt, ct),
                RevenueCatEventType.ProductChange => HandleProductChangeAsync(evt, ct),
                RevenueCatEventType.NonRenewingPurchase => HandleNonRenewingPurchaseAsync(evt, ct),
                RevenueCatEventType.Transfer => HandleTransferAsync(evt, ct),
                RevenueCatEventType.SubscriptionExtended => HandleSubscriptionExtendedAsync(evt, ct),
                RevenueCatEventType.TemporaryEntitlementGrant => HandleTemporaryEntitlementAsync(evt, ct),
                RevenueCatEventType.Test => HandleTestAsync(evt, ct),
                _ => HandleUnknownAsync(evt, ct)
            });

            // Mark as processed only after successful handling
            await _processedEvents.MarkProcessedAsync(evt.Id, ct);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to process event {EventId} of type {Type}", evt.Id, evt.Type);
            throw;
        }
    }

    private async Task HandleInitialPurchaseAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Grant subscription/entitlements
        var expiresAt = evt.ExpirationAtMs.HasValue
            ? DateTimeOffset.FromUnixTimeMilliseconds(evt.ExpirationAtMs.Value)
            : (DateTimeOffset?)null;

        await _subscriptions.GrantAccessAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            productId: evt.ProductId!,
            entitlementIds: evt.EntitlementIds ?? new(),
            expiresAt: expiresAt,
            transactionId: evt.TransactionId,
            cancellationToken: ct);
    }

    private async Task HandleRenewalAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Extend/refresh subscription expiry
        var expiresAt = evt.ExpirationAtMs.HasValue
            ? DateTimeOffset.FromUnixTimeMilliseconds(evt.ExpirationAtMs.Value)
            : (DateTimeOffset?)null;

        await _subscriptions.RenewAccessAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            productId: evt.ProductId!,
            entitlementIds: evt.EntitlementIds ?? new(),
            expiresAt: expiresAt,
            isTrialConversion: evt.IsTrialConversion ?? false,
            cancellationToken: ct);
    }

    private async Task HandleCancellationAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Mark as cancelled — do NOT revoke access yet!
        // Access is revoked on EXPIRATION event.
        await _subscriptions.MarkCancelledAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            reason: evt.CancelReason,
            cancellationToken: ct);
    }

    private async Task HandleUncancellationAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Re-enable — user resubscribed before expiry
        await _subscriptions.MarkActiveAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            cancellationToken: ct);
    }

    private async Task HandleExpirationAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // REVOKE ACCESS HERE — this is the definitive "access ends" event
        await _subscriptions.RevokeAccessAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            reason: evt.ExpirationReason,
            cancellationToken: ct);
    }

    private async Task HandleBillingIssueAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Notify user about payment failure — do NOT revoke access
        await _subscriptions.RecordBillingIssueAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            gracePeriodEndsAt: evt.ExpirationAtMs.HasValue
                ? DateTimeOffset.FromUnixTimeMilliseconds(evt.ExpirationAtMs.Value)
                : null,
            cancellationToken: ct);
    }

    private async Task HandleProductChangeAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        await _subscriptions.UpdateProductAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            oldProductId: evt.ProductId!,
            newProductId: evt.NewProductId,
            cancellationToken: ct);
    }

    private async Task HandleNonRenewingPurchaseAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        await _subscriptions.RecordOneTimePurchaseAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            productId: evt.ProductId!,
            entitlementIds: evt.EntitlementIds ?? new(),
            cancellationToken: ct);
    }

    private async Task HandleTransferAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        if (evt.TransferredFrom != null && evt.TransferredTo != null)
        {
            await _subscriptions.TransferEntitlementsAsync(
                fromUserIds: evt.TransferredFrom,
                toUserIds: evt.TransferredTo,
                cancellationToken: ct);
        }
    }

    private async Task HandleSubscriptionExtendedAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        var newExpiry = evt.ExpirationAtMs.HasValue
            ? DateTimeOffset.FromUnixTimeMilliseconds(evt.ExpirationAtMs.Value)
            : (DateTimeOffset?)null;

        await _subscriptions.ExtendSubscriptionAsync(
            userId: evt.OriginalAppUserId ?? evt.AppUserId!,
            newExpiresAt: newExpiry,
            cancellationToken: ct);
    }

    private async Task HandleTemporaryEntitlementAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        // Short-term access during store outage — max 24 hours
        var expiresAt = evt.ExpirationAtMs.HasValue
            ? DateTimeOffset.FromUnixTimeMilliseconds(evt.ExpirationAtMs.Value)
            : DateTimeOffset.UtcNow.AddHours(24);

        await _subscriptions.GrantTemporaryAccessAsync(
            userId: evt.AppUserId!,
            expiresAt: expiresAt,
            cancellationToken: ct);
    }

    private Task HandleTestAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        _logger.LogInformation("RevenueCat TEST webhook received successfully");
        return Task.CompletedTask;
    }

    private Task HandleUnknownAsync(RevenueCatEvent evt, CancellationToken ct)
    {
        _logger.LogWarning("Unhandled RevenueCat event type: {Type}", evt.Type);
        return Task.CompletedTask;
    }
}

4d. Program.cs / DI Registration

builder.Services.AddScoped<IRevenueCatWebhookService, RevenueCatWebhookService>();
builder.Services.AddScoped<ISubscriptionRepository, SubscriptionRepository>();
builder.Services.AddScoped<IProcessedEventRepository, ProcessedEventRepository>();

4e. appsettings.json

{
  "RevenueCat": {
    "WebhookAuthorizationHeader": "YOUR_SECRET_HEADER_VALUE_FROM_DASHBOARD"
  }
}

---

5. Best Practices Checklist

---

6. User Identification

When looking up a user from a webhook, always search by both: 1. original_app_user_id — the canonical user ID 2. aliases array — all historical user IDs ever used

// Example lookup
var userId = evt.OriginalAppUserId;
var allIds = new List<string> { userId ?? "" }
    .Concat(evt.Aliases ?? new())
    .Where(id => !string.IsNullOrEmpty(id))
    .Distinct()
    .ToList();

---

7. Syncing Subscription Status (Recommended Pattern)

Rather than writing complex logic for each event type, the recommended approach is:

After receiving any webhook, call the GET /v1/subscribers/{app_user_id} REST API endpoint to get the full, canonical subscription state.

This avoids edge cases and keeps your database always consistent with RevenueCat's source of truth.

---

8. Testing

• Use RevenueCat Dashboard → Webhooks → Send Test Event to verify your endpoint
• Use sandbox purchases on device (events have environment: "SANDBOX")
• Failed/retrying events can be manually retried from the dashboard
• When testing locally, use a tunnel like ngrok to expose your endpoint

---

Reference Files

• references/fields.md — Complete field-by-field reference table
• references/sample-events.md — Full JSON sample payloads for all event types

RevenueCat Webhook Fields Reference

Common Fields (all events)

Subscription Lifecycle Fields

Cancellation and Expiration Reasons

Virtual Currency Transaction Fields

Experiment Enrollment Fields

Tips

• Trial detection: period_type == "TRIAL"
• Trial duration: expiration_at_ms - purchased_at_ms (in ms)
• Subscription active: expiration_at_ms > now
• Refund: CANCELLATION + cancel_reason == "CUSTOMER_SUPPORT" + price < 0
• Sandbox: environment == "SANDBOX"

RevenueCat Sample Webhook Payloads

INITIAL_PURCHASE

{
  "event": {
    "event_timestamp_ms": 1658726378679,
    "product_id": "com.subscription.weekly",
    "period_type": "NORMAL",
    "purchased_at_ms": 1658726374000,
    "expiration_at_ms": 1659331174000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "transaction_id": "123456789012345",
    "original_transaction_id": "123456789012345",
    "is_family_share": false,
    "country_code": "US",
    "app_user_id": "1234567890",
    "aliases": ["$RCAnonymousID:8069238d6049ce87cc529853916d624c"],
    "original_app_user_id": "$RCAnonymousID:87c6049c58069238dce29853916d624c",
    "currency": "USD",
    "price": 4.99,
    "price_in_purchased_currency": 4.99,
    "store": "APP_STORE",
    "tax_percentage": 0.0,
    "commission_percentage": 0.3,
    "type": "INITIAL_PURCHASE",
    "id": "12345678-1234-1234-1234-123456789012",
    "app_id": "1234567890"
  },
  "api_version": "1.0"
}

RENEWAL

{
  "event": {
    "event_timestamp_ms": 1658726405017,
    "product_id": "com.subscription.weekly",
    "period_type": "NORMAL",
    "purchased_at_ms": 1658755132000,
    "expiration_at_ms": 1659359932000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "transaction_id": "123456789012345",
    "original_transaction_id": "123456789012345",
    "is_family_share": false,
    "country_code": "DE",
    "app_user_id": "1234567890",
    "original_app_user_id": "$RCAnonymousID:87c6049c58069238dce29853916d624c",
    "currency": "EUR",
    "is_trial_conversion": false,
    "price": 8.14,
    "price_in_purchased_currency": 7.99,
    "store": "APP_STORE",
    "tax_percentage": 0.0,
    "commission_percentage": 0.3,
    "type": "RENEWAL",
    "id": "12345678-1234-1234-1234-123456789012",
    "app_id": "1234567890"
  },
  "api_version": "1.0"
}

CANCELLATION (user unsubscribed)

{
  "event": {
    "event_timestamp_ms": 1601337615995,
    "product_id": "com.revenuecat.myapp.weekly",
    "period_type": "NORMAL",
    "purchased_at_ms": 1601417766000,
    "expiration_at_ms": 1602022566000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "transaction_id": "100000000000002",
    "original_transaction_id": "100000000000000",
    "app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "aliases": [
      "$RCAnonymousID:12345678-1234-ABCD-1234-123456789123",
      "user_1234"
    ],
    "original_app_user_id": "$RCAnonymousID:12345678-1234-ABCD-1234-123456789123",
    "cancel_reason": "UNSUBSCRIBE",
    "currency": "USD",
    "price": 0.0,
    "store": "APP_STORE",
    "tax_percentage": 0.0,
    "commission_percentage": 0.3,
    "type": "CANCELLATION",
    "id": "12345678-ABCD-1234-ABCD-12345678912"
  },
  "api_version": "1.0"
}

CANCELLATION (refund — negative price)

{
  "event": {
    "event_timestamp_ms": 1601337615995,
    "product_id": "com.revenuecat.myapp.monthly",
    "period_type": "NORMAL",
    "cancel_reason": "CUSTOMER_SUPPORT",
    "currency": "USD",
    "price": -9.99,
    "price_in_purchased_currency": -9.99,
    "store": "APP_STORE",
    "type": "CANCELLATION",
    "id": "12345678-1234-1234-1234-12345678912"
  },
  "api_version": "1.0"
}

EXPIRATION

{
  "event": {
    "event_timestamp_ms": 1697451462232,
    "product_id": "com.subscription.weekly",
    "period_type": "NORMAL",
    "expiration_at_ms": 1697451423000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "app_user_id": "1234567890",
    "expiration_reason": "UNSUBSCRIBE",
    "currency": "USD",
    "price": 0.0,
    "store": "APP_STORE",
    "type": "EXPIRATION",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

UNCANCELLATION

{
  "event": {
    "event_timestamp_ms": 1663982135337,
    "product_id": "com.subscription.monthly",
    "expiration_at_ms": 1665235092000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["plus"],
    "app_user_id": "1234567890",
    "store": "APP_STORE",
    "type": "UNCANCELLATION",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

BILLING_ISSUE

{
  "event": {
    "event_timestamp_ms": 1601337601013,
    "product_id": "com.revenuecat.myapp.monthly",
    "period_type": "NORMAL",
    "entitlement_ids": ["pro"],
    "app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "original_app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "store": "APP_STORE",
    "type": "BILLING_ISSUE",
    "id": "12345678-1234-1234-1234-12345678912"
  },
  "api_version": "1.0"
}

NON_RENEWING_PURCHASE (one-time)

{
  "event": {
    "event_timestamp_ms": 1658726522314,
    "product_id": "2100_tokens",
    "period_type": "NORMAL",
    "purchased_at_ms": 1658726519000,
    "expiration_at_ms": null,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "country_code": "CA",
    "app_user_id": "1234567890",
    "currency": "CAD",
    "price": 25.487,
    "price_in_purchased_currency": 32.99,
    "store": "APP_STORE",
    "commission_percentage": 0.15,
    "type": "NON_RENEWING_PURCHASE",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

SUBSCRIPTION_PAUSED (Android only)

{
  "event": {
    "event_timestamp_ms": 1652796516000,
    "product_id": "premium",
    "auto_resume_at_ms": 1657951448845,
    "environment": "PRODUCTION",
    "entitlement_ids": ["Premium1"],
    "app_user_id": "1234567890",
    "store": "PLAY_STORE",
    "type": "SUBSCRIPTION_PAUSED",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

TRANSFER

{
  "event": {
    "app_id": "1234567890",
    "event_timestamp_ms": 78789789798798,
    "id": "CD489E0E-5D52-4E03-966B-A7F17788E432",
    "store": "APP_STORE",
    "transferred_from": ["00005A1C-6091-4F81-BE77-F0A83A271AB6"],
    "transferred_to": ["4BEDB450-8EF2-11E9-B475-0800200C9A66"],
    "type": "TRANSFER",
    "environment": "PRODUCTION"
  },
  "api_version": "1.0"
}

PRODUCT_CHANGE

{
  "event": {
    "event_timestamp_ms": 1601338594769,
    "product_id": "com.revenuecat.myapp.monthly",
    "new_product_id": "com.revenuecat.myapp.yearly",
    "environment": "PRODUCTION",
    "entitlement_ids": ["subscription"],
    "app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "original_app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "store": "PLAY_STORE",
    "type": "PRODUCT_CHANGE",
    "id": "12345678-1234-1234-1234-12345678912"
  },
  "api_version": "1.0"
}

SUBSCRIPTION_EXTENDED

{
  "event": {
    "event_timestamp_ms": 1697451462232,
    "product_id": "com.subscription.weekly",
    "expiration_at_ms": 1697451423000,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "app_user_id": "1234567890",
    "store": "APP_STORE",
    "type": "SUBSCRIPTION_EXTENDED",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

REFUND_REVERSED

{
  "event": {
    "product_id": "com.subscription.weekly",
    "app_user_id": "1234567890",
    "price": 5.0,
    "renewal_number": 3,
    "store": "APP_STORE",
    "type": "REFUND_REVERSED",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

TEMPORARY_ENTITLEMENT_GRANT

{
  "event": {
    "event_timestamp_ms": 1744824815307,
    "app_user_id": "41234567890",
    "store": "APP_STORE",
    "type": "TEMPORARY_ENTITLEMENT_GRANT",
    "id": "12345678-1234-1234-1234-123456789012",
    "app_id": "1234567890"
  },
  "api_version": "1.0"
}

Trial Started (INITIAL_PURCHASE with period_type TRIAL)

{
  "event": {
    "product_id": "com.subscription.yearly",
    "period_type": "TRIAL",
    "purchased_at_ms": 1658726358573,
    "expiration_at_ms": 1658992117958,
    "environment": "PRODUCTION",
    "entitlement_ids": ["pro"],
    "price": 0,
    "store": "PLAY_STORE",
    "type": "INITIAL_PURCHASE",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

INVOICE_ISSUANCE (Web Billing only)

{
  "event": {
    "event_timestamp_ms": 1745004447300,
    "product_id": "com.subscription.monthly",
    "environment": "PRODUCTION",
    "app_user_id": "41234567890",
    "currency": "USD",
    "price_in_purchased_currency": 9.0,
    "store": "RC_BILLING",
    "type": "INVOICE_ISSUANCE",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

VIRTUAL_CURRENCY_TRANSACTION

{
  "event": {
    "adjustments": [
      {
        "amount": 100,
        "currency": {
          "code": "CRD",
          "description": "The main currency unit",
          "name": "Credits"
        }
      }
    ],
    "app_user_id": "1234567890",
    "product_id": "1M_100credits",
    "source": "in_app_purchase",
    "store": "APP_STORE",
    "virtual_currency_transaction_id": "vatx123456789012345",
    "type": "VIRTUAL_CURRENCY_TRANSACTION",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}

EXPERIMENT_ENROLLMENT

{
  "event": {
    "event_timestamp_ms": 1658726378679,
    "app_user_id": "$RCAnonymousID:12345678-1234-1234-1234-123456789123",
    "experiment_id": "prexpca1234abcd",
    "experiment_variant": "b",
    "offering_id": "experiment_offering_b",
    "experiment_enrolled_at_ms": 1658726378679,
    "type": "EXPERIMENT_ENROLLMENT",
    "id": "12345678-1234-1234-1234-123456789012"
  },
  "api_version": "1.0"
}