# Create Checkout Session Source: https://docs.getmeasure.com/api-references/checkout/create-checkout-session https://api.getmeasure.com/api/v1/docs/api_spec.json POST /companies/{company_id}/checkout Create a customer-specific checkout session link to purchase a set of plans # Get Checkout Session Source: https://docs.getmeasure.com/api-references/checkout/get-checkout-session https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/checkout/{id} Retrieve a checkout session by ID # Create Contract Source: https://docs.getmeasure.com/api-references/contracts/create-contract https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/contracts Create a signature-enabled contract link to purchase a set of plans # Find Contracts Source: https://docs.getmeasure.com/api-references/contracts/find-contracts https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/contracts/find Search contracts with given parameters # Get Contract Source: https://docs.getmeasure.com/api-references/contracts/get-contract https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/contracts/{id} Retrieve a contract by ID # Update Contract Source: https://docs.getmeasure.com/api-references/contracts/update-contract https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/contracts/{id} Update a specific contract # Create Credit Note Source: https://docs.getmeasure.com/api-references/credit-notes/create-credit-note https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credit_notes Create a credit note against an invoice # Find Credit Notes Source: https://docs.getmeasure.com/api-references/credit-notes/find-credit-notes https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credit_notes/find Search credit notes with given parameters # Get Credit Note Source: https://docs.getmeasure.com/api-references/credit-notes/get-credit-note https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/credit_notes/{id} Retrieve a credit note by ID # Update Credit Note Source: https://docs.getmeasure.com/api-references/credit-notes/update-credit-note https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/credit_notes/{id} Update the note, internal note, or internal reason on a credit note # Apply Credit to Open Invoices Source: https://docs.getmeasure.com/api-references/credits/apply-credit-to-open-invoices https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credits/{id}/apply_to_open_invoices Apply a credit to one or more open invoices. If no invoice UUIDs are provided, the credit is applied to open invoices oldest-first until exhausted. # Check Balance Source: https://docs.getmeasure.com/api-references/credits/check-balance https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/credits/check_balance/{customer_id} Check credits balance for customer # Consume Credits Source: https://docs.getmeasure.com/api-references/credits/consume-credits https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credits/consume Consume credits with given parameters # Create Credit Source: https://docs.getmeasure.com/api-references/credits/create-credit https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credits Create a credit with given parameters # Find Credit Logs Source: https://docs.getmeasure.com/api-references/credits/find-credit-logs https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credits/logs/find Search credit logs with given parameters # Find Credits Source: https://docs.getmeasure.com/api-references/credits/find-credits https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/credits/find Search credits with given parameters # Get Credit Source: https://docs.getmeasure.com/api-references/credits/get-credit https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/credits/{id} Retrieve a credit by ID # Revoke Credit Source: https://docs.getmeasure.com/api-references/credits/revoke-credit https://api.getmeasure.com/api/v1/docs/api_spec.json delete /companies/{company_id}/credits/{id} Revoke a credit by ID # Update Credit Source: https://docs.getmeasure.com/api-references/credits/update-credit https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/credits/{id} Update a credit's name, expiration date, or product restrictions # Get Customer Portal Link Source: https://docs.getmeasure.com/api-references/customer-dashboards/get-customer-portal-link https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/customer_dashboards/{customer_id}/portal Retrieve a customer portal link for a specific customer # Add Payment Method Link Source: https://docs.getmeasure.com/api-references/customers/add-payment-method-link https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/customers/{customer_id}/add_payment_method_link Get a link to a hosted page which allows a customer to add a payment method. # Create Customer Source: https://docs.getmeasure.com/api-references/customers/create-customer https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/customers Create a customer with given parameters # Delete Payment Method Source: https://docs.getmeasure.com/api-references/customers/delete-payment-method https://api.getmeasure.com/api/v1/docs/api_spec.json delete /companies/{company_id}/customers/{customer_id}/payment_methods/{id} Deletes a customer payment method if it is not being used. If the payment method is still being used, an error will be returned # Find Customers Source: https://docs.getmeasure.com/api-references/customers/find-customers https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/customers/find Search customers with given parameters # Get Customer Source: https://docs.getmeasure.com/api-references/customers/get-customer https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/customers/{customer_id} Retrieve a customer by ID or external identifier # Get Payment Methods Source: https://docs.getmeasure.com/api-references/customers/get-payment-methods https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/customers/{customer_id}/payment_methods Get all payment methods for this customer from your payment provider (such as Stripe) # Get Payment Provider Intent Source: https://docs.getmeasure.com/api-references/customers/get-payment-provider-intent https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/customers/{customer_id}/payment_methods/setup_intent Get an intent for a customer to add a payment method for a payment provider (such as Stripe). # Start Managing Customer Source: https://docs.getmeasure.com/api-references/customers/start-managing-customer https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/customers/{customer_id}/start_managing Start managing a customer in Measure that was previous managed externally. # Update Customer Source: https://docs.getmeasure.com/api-references/customers/update-customer https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/customers/{customer_id} Update a customer by ID or external identifier # Update Payment Method Source: https://docs.getmeasure.com/api-references/customers/update-payment-method https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/customers/{customer_id}/payment_methods/{id} Update payment methods for this customer from your payment provider (such as Stripe). This endpoint also gives you the option to change all the subscriptions to use this endpoint # Create Entitlement Source: https://docs.getmeasure.com/api-references/entitlements/create-entitlement https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/entitlements Create an entitlement with given parameters # Delete Entitlement Source: https://docs.getmeasure.com/api-references/entitlements/delete-entitlement https://api.getmeasure.com/api/v1/docs/api_spec.json delete /companies/{company_id}/entitlements/{id} Delete an entitlement by ID # Find Entitlements Source: https://docs.getmeasure.com/api-references/entitlements/find-entitlements https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/entitlements/find Search entitlements with given parameters # Get Entitlement Source: https://docs.getmeasure.com/api-references/entitlements/get-entitlement https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/entitlements/{id} Retrieve an entitlement by ID # Update Entitlement Source: https://docs.getmeasure.com/api-references/entitlements/update-entitlement https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/entitlements/{id} Update an entitlement by ID # Ingest Usage Events Source: https://docs.getmeasure.com/api-references/events/ingest-usage-events https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/events/ingest Send bulk billable usage events for metrics calculation # Finalize Draft Invoice Source: https://docs.getmeasure.com/api-references/invoices/finalize-draft-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/{uuid}/finalize Finalize a draft invoice by UUID # Find Invoices Source: https://docs.getmeasure.com/api-references/invoices/find-invoices https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/find Search invoices with given parameters # Generate Invoice PDF Source: https://docs.getmeasure.com/api-references/invoices/generate-invoice-pdf https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/invoices/{uuid}/pdf Returns the invoice as a PDF file # Get Invoice Source: https://docs.getmeasure.com/api-references/invoices/get-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/invoices/{uuid} Retrieve an invoice by UUID # Get Invoice Link Source: https://docs.getmeasure.com/api-references/invoices/get-invoice-link https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/invoices/{uuid}/link Generates a link to the invoice with an embedded authentication token # Mark Invoice As Paid Source: https://docs.getmeasure.com/api-references/invoices/mark-invoice-as-paid https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/{uuid}/mark_paid Mark an invoice as paid by UUID # Next Invoice Source: https://docs.getmeasure.com/api-references/invoices/next-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/next Retrieve the upcoming invoice for the given subscription including any upcoming one time charges. # Send Email for Invoice Source: https://docs.getmeasure.com/api-references/invoices/send-email-for-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/{uuid}/send_email Send Email for Invoice by UUID # Update Invoice Source: https://docs.getmeasure.com/api-references/invoices/update-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/invoices/{uuid} Update invoice properties by UUID. To update status, refer to specific status update endpoints # Void Invoice Source: https://docs.getmeasure.com/api-references/invoices/void-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/invoices/{uuid}/void Void an invoice by UUID # Get Metrics Data Source: https://docs.getmeasure.com/api-references/metrics/get-metrics-data https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/report/cached_metrics Retrieve a specific metrics data # Create Object Source: https://docs.getmeasure.com/api-references/objects/create-object https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/objects Create an object for metrics calculation # Delete Object Source: https://docs.getmeasure.com/api-references/objects/delete-object https://api.getmeasure.com/api/v1/docs/api_spec.json delete /companies/{company_id}/objects/{id} Delete an object by ID # Find Objects Source: https://docs.getmeasure.com/api-references/objects/find-objects https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/objects/find Search for objects with matching parameters # Get Object Source: https://docs.getmeasure.com/api-references/objects/get-object https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/objects/{id} Retrieve an existing object by ID # Ingest Objects Source: https://docs.getmeasure.com/api-references/objects/ingest-objects https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/objects/ingest Send bulk billable objects for metrics calculation # Update Object Source: https://docs.getmeasure.com/api-references/objects/update-object https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/objects/{id} Update the properties of an existing object # Create One-Time Charges Source: https://docs.getmeasure.com/api-references/one-time/create-one-time-charges https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/one_times Create a one-time charges with given parameters # Create One-Time Charges V2 Source: https://docs.getmeasure.com/api-references/one-time/create-one-time-charges-v2 https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/one_times/create Create a one-time charges with given parameters # Find One-Time Charges Source: https://docs.getmeasure.com/api-references/one-time/find-one-time-charges https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/one_times/find Search one-time charges with given parameters # Find Payment Transactions Source: https://docs.getmeasure.com/api-references/payments/find-payment-transactions https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/payments/transactions/find Search payment transactions with given parameters. # Refund a Payment Transaction Source: https://docs.getmeasure.com/api-references/payments/refund-a-payment-transaction https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/payments/transactions/{id}/refund Refund a specific payment transaction. # Create Billable Item Source: https://docs.getmeasure.com/api-references/pricing/create-billable-item https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/billable_items Create a billable item # Create Billable Metric Source: https://docs.getmeasure.com/api-references/pricing/create-billable-metric https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/billable_metrics Create a billable metric # Create Product Source: https://docs.getmeasure.com/api-references/pricing/create-product https://api.getmeasure.com/api/v1/docs/api_spec.json POST /companies/{company_id}/products Create a new product # Create Product Pricing Source: https://docs.getmeasure.com/api-references/pricing/create-product-pricing https://api.getmeasure.com/api/v1/docs/api_spec.json POST /companies/{company_id}/pricing Create a new product pricing # Find Billable Items Source: https://docs.getmeasure.com/api-references/pricing/find-billable-items https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/billable_items/find Find billable items # Find Billable Metrics Source: https://docs.getmeasure.com/api-references/pricing/find-billable-metrics https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/billable_metrics/find Find billable metrics # Find Bundles Source: https://docs.getmeasure.com/api-references/pricing/find-bundles https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/bundles/find Search for bundles with given parameters # Find Product Pricing Source: https://docs.getmeasure.com/api-references/pricing/find-product-pricing https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/pricing/find Search for product pricing with given parameters # Find Products Source: https://docs.getmeasure.com/api-references/pricing/find-products https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/products/find Search for products with given parameters # Get Bundle Source: https://docs.getmeasure.com/api-references/pricing/get-bundle https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/bundles/{id} Retrieve a bundle by ID # Get Product Source: https://docs.getmeasure.com/api-references/pricing/get-product https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/products/{id} Retrieve a product by ID or external identifier # Get Product Pricing Source: https://docs.getmeasure.com/api-references/pricing/get-product-pricing https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/pricing/{id} Retrieve a product pricing by ID or external identifier # Update Billable Item Source: https://docs.getmeasure.com/api-references/pricing/update-billable-item https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/billable_items/{id} Update a billable item # Update Billable Metric Source: https://docs.getmeasure.com/api-references/pricing/update-billable-metric https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/billable_metrics/{id} Update a billable metric # Update Product Source: https://docs.getmeasure.com/api-references/pricing/update-product https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/products/{id} Update by product by ID or external identifier # Update Product Pricing Source: https://docs.getmeasure.com/api-references/pricing/update-product-pricing https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/pricing/{id} Update a product pricing by ID or external identifier # Cancel Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/cancel-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/cancel Cancel a subscription by ID with the provided cancellation options # Change Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/change-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/change Change a subscription by ID with the provided plan details # Create Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/create-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions Create a subscription with the provided plan details # Extend Trial End Date Source: https://docs.getmeasure.com/api-references/subscriptions/extend-trial-end-date https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/extend Update the end of the trial for the subscription. This can only be performed on an active trial subscription. # Find Subscriptions Source: https://docs.getmeasure.com/api-references/subscriptions/find-subscriptions https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/find Search subscriptions with given parameters # Generate Next Invoice Source: https://docs.getmeasure.com/api-references/subscriptions/generate-next-invoice https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/generate_next_invoice Generate the next invoice for the subscription right away. This is an asynchronous process so changes won't be reflected immediately. # Get Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/get-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json get /companies/{company_id}/subscriptions/{id} Retrieve a subscription by ID or external identifier # Get Subscription Usage Source: https://docs.getmeasure.com/api-references/subscriptions/get-subscription-usage https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/usage Retrieve the subscription usage by ID for a specific metric # Get Subscription Usage for Current Period Source: https://docs.getmeasure.com/api-references/subscriptions/get-subscription-usage-for-current-period https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/current_period_usage Retrieve the usage for the current period of the subscription for a specific billable item # Get Subscription Usage For Current Period Source: https://docs.getmeasure.com/api-references/subscriptions/get-subscription-usage-for-the-current-period https://api.getmeasure.com/api/v1/docs/api_spec.json POST /companies/{company_id}/subscriptions/{id}/current_period_usage Retrieve the usage for the current period of the subscription for a specific billable item # Pause Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/pause-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/pause Pause a subscription by ID with the provided pause configuration # Undo Cancel Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/undo-cancel-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json post /companies/{company_id}/subscriptions/{id}/undo_cancel Undo an upcoming cancellation on a subscription by ID. This does not revive an already cancelled subscription. # Update Subscription Source: https://docs.getmeasure.com/api-references/subscriptions/update-subscription https://api.getmeasure.com/api/v1/docs/api_spec.json patch /companies/{company_id}/subscriptions/{id} Update the properties of the subscription by ID with the provided details. Note: The subscription product pricing can not be changed with this endpoint. Please refer to /change to make plan changes. # Access Control Features Source: https://docs.getmeasure.com/pages/guides/access-controls ## RBAC (Role-based accessed controls) Measure offers Role-Based Access Controls (RBAC) as a security mechanism to govern access to resources based on predefined roles and associated permissions. RBAC ensures that users are granted appropriate access to perform their tasks while preventing unauthorized access. Measure provides the following roles out-of-the-box ### Full Admin This role provides complete read and write access to all features across the product. Full Admins can: * Manage all customers, subscriptions, invoices, and contracts * Configure products, pricing plans, and the price book * Set up and manage all integrations (payment providers, CRMs, accounting, email) * Access analytics, financial reports, and revenue recognition data * Configure company settings, branding, and notification settings * Manage users and assign roles * Configure approval workflows and notification rules * Manage tax settings and compliance configuration Full Admin is intended for operations leads, finance managers, or founders who need unrestricted access to configure and manage the entire platform. ### Sales Admin This role provides read and write access to customers, pricing, subscriptions, and contracts. Sales Admins can: * Manage the price book (create, update, and organize products and pricing plans) * View and manage all contracts across the sales team * Participate in contract approval workflows as an approver * Create and manage customers and subscriptions * Access all deals regardless of ownership This role does not include access to analytics, financial reporting, or system settings. Sales Admin is ideal for sales managers and operations leads who oversee the sales team's deals and maintain pricing consistency. ### Sales Rep This role provides access scoped to the individual sales representative's own deals and customers. Sales Reps can: * View and manage customers assigned to them * Create and track contracts for their deals * View their own sales commission reports * Access pricing and product catalog (read-only) Sales Reps cannot view deals, customers, or commissions belonging to other team members. This role is ideal for individual contributors on the sales team who need visibility into their own pipeline and earnings without access to organization-wide data. ### Customer Support This role provides read and write access to customers, subscriptions, invoices, payments, and contracts. This includes everything needed to manage renewals and resolve billing issues. Customer Support users can: * View and update customer information * Manage subscriptions (upgrades, downgrades, cancellations) * Process refunds and issue credit notes * View and resend invoices * Handle contract renewals and amendments * Access payment history and retry failed payments This role does not include access to: * Company settings and integrations * Analytics and financial reports * Product catalog and pricing configuration * User management The Customer Support role is ideal for support and customer success teams who need to resolve billing inquiries and manage the customer lifecycle without access to sensitive financial reporting or system configuration. ### Read-Only This role provides read-only access to all features in the app. Read-Only users can view: * Customers and customer details * Subscriptions and subscription history * Invoices, payments, and payment history * Contracts and contract status * Products and pricing catalog * Analytics and financial reports * Usage data and billable metrics Read-Only users cannot create, edit, or delete any records. This role is useful for stakeholders who need visibility into billing operations without the ability to make changes, such as executives, investors, or external auditors. ### Accountant This role provides read-only access to all features plus write permissions for accounting integrations. Accountants can: * View all customers, subscriptions, invoices, and payments * View analytics and financial reports * Configure and manage accounting integrations (QuickBooks, Xero) * Trigger manual syncs to accounting platforms * Map accounts and configure accounting export settings Accountants cannot modify billing data directly (customers, subscriptions, invoices, pricing). This role is ideal for finance team members who need to manage the flow of data to your accounting system while maintaining separation of duties. ### Custom Roles Measure also allows you to define custom roles with granular permissions tailored to your organization's needs. Custom roles are built using permission building blocks: * **Read**: View records and data * **Write**: Create new records * **Update**: Modify existing records * **Delete**: Remove records These permissions can be applied independently to each resource type (customers, subscriptions, invoices, contracts, products, integrations, reports). For example, you could create a role that can read all data, create and update subscriptions, but cannot delete anything or access integrations. Contact our support team to configure custom roles for your organization. ## Internal Logs All actions performed in Measure are internally logged and can be audited by the Full Admin role. This log contains the following details. ```json theme={null} { "company_id": "company_xyz", "created_at": "2023-06-01 00:55:10.09358+00", "action": "credit.created", "action_performed_by_user_id": "user_xyz", "reference_type": "credit", "reference_id": "credit_abc", "additional_data": "...", } ``` ## API Authentication All API calls to Measure need to be authenticated with an access token. Please review Authentication under our API reference for more details. # Overview Source: https://docs.getmeasure.com/pages/guides/accounting-integrations Measure integrates with standard accounting software such as Xero and Quickbooks to help you automate time-consuming data entry and reduce manual errors with invoices and customer data. Please chat with us at [support@getmeasure.com](mailto:support@getmeasure.com) to enable and configure this on your account. # Add Payment Method Source: https://docs.getmeasure.com/pages/guides/add-payment-method Measure enables you to generate a hosted link via the Add Payment Method API to enable customers to quickly add a payment method on file. \ This functionality is particularly useful for scenarios such as onboarding new customers, updating expired cards, or changing payment details. # AI Context Source: https://docs.getmeasure.com/pages/guides/ai-context This page is written for AI assistants and coding agents. If you are a human reader, the [core concepts guide](/pages/guides/core-concepts) is a friendlier starting point. ## Data model Measure separates **what you sell** from **how you price it** from **who buys it**. * **What you sell** is defined by Products and BillableItems. * **How you price it** is defined by BillableItemPricings, ProductPricings, and BundlePricings. * **Who buys it** is defined by Customers and Subscriptions. *** ## Billing lifecycle Every billable event in Measure flows through these stages: 1. **Customer created** — Customer record is set up; becomes the hub all other records reference. 2. **Proposal / quote** — Sales sends a CPQ proposal with TCV/ACV. Proposals can include one-time charges. The subscription link is populated once a proposal converts. 3. **Subscription activated** — Signed proposal converts to an active subscription linked to a bundle pricing. ARR/MRR values are stamped here and updated on changes. 4. **Product assignment** — The bundle defines which products and pricing tiers are included. The junction table maps the full product-pricing configuration. 5. **Usage metering** — Each billing period, usage is recorded for metered products. Billable metrics define how consumption is aggregated; pricing rules define how it is charged. 6. **Invoice generated** — At billing cycle end, Measure creates an invoice. Each product/charge becomes a line item. Discounts and credits are applied and reflected in line items and totals. 7. **Discounts and credits applied** — Active discounts (% or fixed) are applied at invoice time. Credits are drawn down from a balance. Both have ledger tables tracking exactly when and how much was applied per invoice. 8. **Payment captured** — Stripe (or other provider) processes payment. Each transaction records gross, net, and fee breakdown. Joins to invoices via UUID (not id). *** ## Schema domains The schema is organized into five domains. ### Domain 1: Core Entities | Table | Description | | --------------- | ------------------------------------------------------------------------------------------------ | | `customers` | Primary billing entity. Nearly every other table has a `customer_id → customers.id` foreign key. | | `subscriptions` | Recurring billing agreements. Tracks ARR/MRR, billing cycles, trial status, and renewal config. | | `proposals` | Sales quotes/CPQ proposals that convert into subscriptions. Tracks TCV/ACV and deal lifecycle. | ### Domain 2: Product Catalog | Table | Description | | ------------------------- | ----------------------------------------------------------------------------------------------- | | `products` | Top-level sellable products. Foundation of the product catalog. | | `product_pricings` | Multiple pricing plans per product — supports different tiers per currency, region, or package. | | `bundle_pricings` | Packaged groups of products. Referenced by `subscriptions.bundle_pricing_id`. | | `bundle_product_pricings` | Junction table: maps bundle → product → pricing tier (three-way mapping). | | `entitlements` | Feature flag definitions associated with products and pricing tiers. | ### Domain 3: Usage and Metering | Table | Description | | ------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | `billable_items` | Measurable units of consumption. Foundation of usage-based billing. | | `billable_item_pricings` | Pricing rules — supports volume, step, gradient, credit, and custom models. | | `billable_metrics` | Metric definitions that meter billable items. Defines how consumption is aggregated. | | `product_metric_pricings` | Central junction table (5 FKs) tying products, pricing tiers, billable items, item pricing, and metrics together. The most connected table in the schema. | | `subscription_metric_pricing_records` | Per-period metering records for each subscription. Highest-volume table in the schema. | ### Domain 4: Invoicing and Payments | Table | Description | | ---------------------- | ------------------------------------------------------------------------------------- | | `invoices` | Billing documents issued to customers. Has both `id` and `uuid` fields (see gotchas). | | `invoice_line_items` | Individual charges on an invoice, broken down by product/metric. | | `payment_transactions` | Payment records (charges, refunds) synced from Stripe or other providers. | | `one_time_billables` | One-off charges tied to proposals or customers. Non-recurring line items. | ### Domain 5: Credits and Discounts | Table | Description | | --------------- | ----------------------------------------------------------------------------- | | `credits` | Credit balances issued to customers or subscriptions. | | `credit_logs` | Ledger of credit applications and adjustments per invoice. | | `discounts` | Discount rules (% or fixed) applied to customers, subscriptions, or products. | | `discount_logs` | Ledger of discount applications per invoice. | *** ## Object reference ### Customers Primary billing entity. Nearly every other table has a `customer_id → customers.id` foreign key. Key fields: * `id` — Primary key. Referenced by nearly every table. * `identifier` — Your external ID. Accepted in most API calls as an alternative to the Measure-assigned `id`. * `name`, `org_name` — Display names. * `status` — `ACTIVE` or `ARCHIVED`. * `parent_customer_id` — Self-referencing FK for customer hierarchy (parent billing). * `exclude_from_metrics` — Filter flag for test or internal accounts; exclude from ARR/MRR calculations. * `billing_emails` — JSON array of billing contact emails. * `tags`, `metadata` — JSON fields for flexible categorization and custom attributes. * `mrr` / `arr` — Computed fields derived from active subscriptions. Do not set directly. * `computed_entitlements` — Aggregated feature access derived from all active subscriptions. This is a JSON object where each key is an entitlement key and the value is the resolved entitlement value across all active subscriptions. Use this field to check what a customer currently has access to without traversing the full subscription → bundle → product → entitlement chain. Do not set directly; it is recomputed whenever subscriptions change. ### Subscriptions Recurring billing agreements. Tracks ARR/MRR, billing cycles, trial status, and renewal config. Key fields: * `customer_id` — FK to `customers`. * `bundle_pricing_id` — FK to `bundle_pricings`. Defines what is being billed. * `status` — `ACTIVE`, `CANCELLED`, `UNPAID`, or `PENDING_PAYMENT`. * `start_date`, `end_date`, `renewal_date`, `cancel_date` — Lifecycle dates (stored as TEXT; see gotchas). * `next_invoice_date` — The upcoming invoice date. * `billing_anchor_date` — Anchor date that controls billing cycle alignment. * `arr_value_in_cents`, `mrr_value_in_cents` — Monetary values in cents (divide by 100 for dollars). * `minimum_spend_value_in_cents` — Contractual minimum spend. * `auto_renews` — Whether subscription renews automatically at term end. * `auto_charges` — Whether invoices are auto-charged to the default payment method. * `trial` — Whether this is a trial subscription. * `trial_conversion_date` — When trial converted to paid. * `config_items` — Per-subscription overrides. Most commonly used to set `num_licenses` (seat count) for LICENSE\_ITEM pricing. * `computed_entitlements` — Derived feature access based on active pricing. **Cancel timings**: `IMMEDIATE`, `PERIOD_END`, `RENEWAL`, `CUSTOM`. **Change timings** (plan upgrade/downgrade): `IMMEDIATE`, `PERIOD_END`, `RENEWAL`, `CUSTOM`, `RELATIVE`. **Proration types** (for mid-cycle changes): `NONE`, `NEXT` (credit on next invoice), `IMMEDIATE` (charge or credit now). ### Proposals Sales quotes/CPQ proposals that convert into subscriptions. Tracks TCV/ACV and deal lifecycle. Key fields: * `customer_id` — FK to `customers`. * `subscription_id` — FK to `subscriptions` (may be `NULL` if not yet converted). * `bundle_pricing_id` — FK to `bundle_pricings`. * `status` — Proposal lifecycle state. * `tcv_value_in_cents` — Total contract value. * `acv_value_in_cents` — Annual contract value. * `signed_date` — When the deal was signed. * `start_date`, `expiration_date`, `finalized_date`, `completed_date` — Deal timeline dates. * `auto_charges`, `auto_renew`, `trial` — Flags carried forward to the subscription on conversion. ### Products Top-level sellable products. Foundation of the product catalog. Key fields: * `id` — Primary key. * `name` / `external_name` — Internal and customer-facing names. * `state` — `ACTIVE` or `ARCHIVED`. * `entitlements` — Feature flags this product grants (JSON). * `tags`, `metadata` — Flexible categorization (JSON). ### Product Pricings Multiple pricing plans per product — supports different tiers per currency, region, or package. Key fields: * `product_id` — FK to `products`. * `name` / `external_name` — Internal and customer-facing names. * `currency` — Each ProductPricing is for a single currency. To sell in multiple currencies, create multiple ProductPricings. * `state` — `ACTIVE` or `ARCHIVED`. Archived pricings cannot be assigned to new subscriptions. * `num_subs` — Count of subscriptions currently on this pricing. * `entitlements` — Tier-specific feature grants (JSON). ### Bundle Pricings Packaged groups of products. Referenced by `subscriptions.bundle_pricing_id`. Key fields: * `name` / `key` — Identity fields. * `currency` — Pricing currency. * `default_term_count` / `default_term_frequency` — Default billing cycle. * `state` — `ACTIVE` or `ARCHIVED`. * `num_subs` — Count of active subscriptions using this bundle. Most companies create one bundle per tier (e.g., Starter, Growth, Enterprise). ### Bundle Product Pricings Junction table: maps bundle → product → pricing tier (three-way mapping). Key fields: * `bundle_pricing_id` — FK to `bundle_pricings`. * `product_id` — FK to `products`. * `product_pricing_id` — FK to `product_pricings`. ### Billable Items Measurable units of consumption. Foundation of usage-based billing. Key fields: * `name` / `external_name` — Internal and customer-facing names. * `state` — `ACTIVE` or `ARCHIVED`. * `standard` — Whether this is a standard vs. custom item. Item types: * `LICENSE_ITEM` — Seat or license based. Quantity set on the subscription via `config_items.num_licenses`. * `CUSTOM_USAGE` — Event-driven. Customers send events via the ingest API; Measure aggregates at billing time. * `CUSTOM_OBJ` — Object-based. Customers sync objects (e.g., active accounts); Measure counts or sums them. * `ONETIME_ITEM` — One-time charge not tied to a recurring billing period. ### Billable Metrics Metric definitions that meter billable items. Defines how consumption is aggregated. Key fields: * `item_id` — FK to `billable_items`. * `name` / `external_name` — Identity fields. * `metering_rule` — JSON: aggregation logic and filter rules. * `standard` — Whether this is a standard vs. custom metric. Aggregator types: `COUNT`, `SUM`, `MAX`, `AVG`, `UNIQUE`, `UNIQUE_DAILY`, `OBJ_COUNT`, `OBJ_SUM`, `OBJ_MAX`, `OBJ_UNIQUE`, `OBJ_PRORATED_COUNT`, `CUSTOMER_FIXED`, `CUSTOMER_LAST_EVER`, `CUSTOMER_LAST_PERIOD`, `LAST_EVER_SUM`. ### Billable Item Pricings Pricing rules — supports volume, step, gradient, credit, and custom models. Key fields: * `item_id` — FK to `billable_items`. * `charge_type` — `FIXED`, `STEP`, `GRADIENT`, `VOLUME`, `CUSTOM`, or `SCHEDULED`. * `frequency` — Billing frequency: `HOUR`, `DAY`, `WEEK`, `BI_MONTH`, `MONTH`, `QUARTER`, `BI_ANNUAL`, `YEAR`, or `ONETIME`. * `term_count` — How many frequency periods make one billing cycle. * `base_price_value_in_cents`, `volume_price`, `step_price`, `gradient_price`, `custom_price` — Pricing model data (JSON for tiered models). * `true_up_frequency` — How often usage is reconciled if it differs from billing frequency. * `carry_over` — Whether unused units roll over to the next period. * `base_units` — Included units before charges begin. * `proration_type` — How proration is calculated on mid-cycle changes. ### Product Metric Pricings Central junction table (5 FKs) tying products, pricing tiers, billable items, item pricing, and metrics together. The most connected table in the schema. Key fields: * `product_id` — FK to `products`. * `product_pricing_id` — FK to `product_pricings`. * `item_id` — FK to `billable_items`. * `item_pricing_id` — FK to `billable_item_pricings`. * `metric_id` — FK to `billable_metrics`. ### Subscription Metric Pricing Records Per-period metering records for each subscription. Highest-volume table in the schema. Key fields: * `subscription_id` — FK to `subscriptions`. * `customer_id` — FK to `customers` (denormalized for query performance). * `product_metric_pricing_id` — FK to `product_metric_pricings`. * `item_pricing_id` — The pricing rule used for this period. * `metric_id` — Which metric was measured. * `period_start_date`, `period_end_date` — Billing period boundaries (stored as TEXT). * `pre_charged_amount_value_in_cents` — Pre-computed charge amount. * `metric_meter` — JSON: meter reading for this period. * `state` — Record state. ### Invoices Billing documents issued to customers. Has both `id` and `uuid` fields (see gotchas). Key fields: * `id` — Primary key. * `uuid` — UUID field. **Payment transactions join on this field, not `id`.** * `customer_id` — FK to `customers`. * `billed_customer_id` — The customer actually billed (differs from `customer_id` in parent billing scenarios where a child's invoice rolls up to the parent). * `subscription_id` — FK to `subscriptions` (may be `NULL` for one-time invoices). * `proposal_id` — FK to `proposals` (optional). * `number` — Human-readable invoice number. * `status` — Lifecycle: `DRAFT` → `OPEN` → `PAID` / `VOID` / `UNCOLLECTIBLE`. * `invoice_date`, `due_date`, `paid_date` — Timeline dates (stored as TEXT). * `subtotal_value_in_cents` — Pre-tax subtotal. * `total_value_in_cents`, `paid_value_in_cents`, `due_value_in_cents` — Monetary totals. * `prorated_amount_value_in_cents` — Prorated portion of the invoice. * `pre_payment_credit_amount_value_in_cents`, `post_payment_credit_amount_value_in_cents` — Credits applied before and after payment. ### Invoice Line Items Individual charges on an invoice, broken down by product/metric. Key fields: * `invoice_id` — FK to `invoices`. * `subscription_id`, `product_id`, `product_metric_pricing_id` — Context FKs. * `description` — Line item description. * `quantity` — Units billed. * `amount_value_in_cents` — Total line charge. * `unit_price_value_in_cents` — Per-unit price. * `discount_applied_value_in_cents`, `tax_applied_value_in_cents` — Adjustments applied to this line. * `period_start_date`, `period_end_date` — Billing period for this line. * `proration` — Whether this is a prorated charge. * `taxable` — Whether this line is subject to tax. ### Payment Transactions Payment records (charges, refunds) synced from Stripe or other providers. Key fields: * `customer_id` — FK to `customers`. * `invoice_uuid` — **Joins to `invoices.uuid`, not `invoices.id`.** * `invoice_number` — Invoice number (denormalized). * `status` — Transaction state. * `transaction_type` — `CHARGE`, `REFUND`, etc. * `total_amount_value_in_cents` — Gross transaction amount. * `net_amount_value_in_cents` — Net after fees. * `total_fee_amount_value_in_cents` — Total fees. * `stripe_fee_amount_value_in_cents` — Stripe processing fee. * `tax_fee_amount_value_in_cents` — Tax fee component. * `provider_type` — Payment provider (Stripe, etc.). * `provider_transaction_id` — External transaction reference for reconciliation. * `captured_at` — When payment was captured (stored as TEXT). ### One Time Billables One-off charges tied to proposals or customers. Non-recurring line items. Key fields: * `customer_id` — FK to `customers`. * `proposal_id` — FK to `proposals`. * `product_pricing_id` — Associated pricing. * `name` — Charge description. * `state` — `ACTIVE` or `ARCHIVED`. * `aggregate` — Whether this charge is aggregated with other charges on the invoice. ### Credits Credit balances issued to customers or subscriptions. Key fields: * `customer_id` — FK to `customers`. * `subscription_id` — FK to `subscriptions` (may be `NULL` for customer-level credits). * `amount_value_in_cents` — Remaining monetary balance. * `issued_amount_value_in_cents` — Original issued amount. * `issued_units` / `units` — Unit-based credit issued and remaining. * `state` — `ACTIVE`, `EXPIRED`, or `CONSUMED`. * `expiration_date` — When the credit expires. * `coupon_id` — The originating coupon, if applicable. ### Credit Logs Ledger of credit applications and adjustments per invoice. Key fields: * `credit_id` — FK to `credits`. * `customer_id` — FK to `customers` (denormalized). * `invoice_id` — FK to `invoices` (which invoice consumed this credit). * `action_type` — What happened (applied, reversed, etc.). * `amount_applied_value_in_cents` — Monetary amount used. * `units_applied` — Units consumed (for unit-based credits). * `note` — Free-text note on the adjustment. ### Discounts Discount rules (% or fixed) applied to customers, subscriptions, or products. Key fields: * `customer_id` — FK to `customers`. * `subscription_id` — FK to `subscriptions` (may be `NULL`). * `product_id` — FK to `products` (for product-specific discounts). * `amount_value_in_cents` — Fixed discount amount. * `percent` — Percentage discount. * `cap_value_in_cents` — Maximum discount cap. * `state` — `ACTIVE` or `EXPIRED`. * `expiration_date` — When discount expires. * `coupon_id` — The originating coupon, if applicable. * `proposal_id` — The proposal this discount was created from, if applicable. ### Discount Logs Ledger of discount applications per invoice. Key fields: * `discount_id` — FK to `discounts`. * `customer_id` — FK to `customers` (denormalized). * `invoice_id` — FK to `invoices`. * `subscription_id` — FK to `subscriptions`. * `amount_applied_value_in_cents` — Fixed amount applied. * `cap_applied_value_in_cents` — Cap that was enforced. * `percent_applied` — Percentage applied. ### Entitlements Feature flag definitions associated with products and pricing tiers. Key fields: * `key` — Feature identifier. * `name` — Display name. * `possible_values` — JSON: allowed values. * `aggregator_type` — How values combine across products. Entitlements are inherited by customers via their active subscriptions. Values can be boolean, numeric, or string. *** ## Foreign key map All 39 relationships in the schema: | From | Field | To | | ------------------------------------- | --------------------------- | ---------------------------- | | `subscriptions` | `customer_id` | `customers.id` | | `proposals` | `customer_id` | `customers.id` | | `proposals` | `subscription_id` | `subscriptions.id` | | `invoices` | `customer_id` | `customers.id` | | `invoices` | `subscription_id` | `subscriptions.id` | | `invoices` | `proposal_id` | `proposals.id` | | `invoice_line_items` | `invoice_id` | `invoices.id` | | `invoice_line_items` | `subscription_id` | `subscriptions.id` | | `invoice_line_items` | `product_id` | `products.id` | | `invoice_line_items` | `product_metric_pricing_id` | `product_metric_pricings.id` | | `payment_transactions` | `customer_id` | `customers.id` | | `payment_transactions` | `invoice_uuid` | `invoices.uuid` ⚠️ | | `credits` | `customer_id` | `customers.id` | | `credits` | `subscription_id` | `subscriptions.id` | | `credit_logs` | `credit_id` | `credits.id` | | `credit_logs` | `customer_id` | `customers.id` | | `credit_logs` | `invoice_id` | `invoices.id` | | `discounts` | `customer_id` | `customers.id` | | `discounts` | `subscription_id` | `subscriptions.id` | | `discounts` | `product_id` | `products.id` | | `discount_logs` | `discount_id` | `discounts.id` | | `discount_logs` | `customer_id` | `customers.id` | | `discount_logs` | `invoice_id` | `invoices.id` | | `product_pricings` | `product_id` | `products.id` | | `bundle_product_pricings` | `bundle_pricing_id` | `bundle_pricings.id` | | `bundle_product_pricings` | `product_id` | `products.id` | | `bundle_product_pricings` | `product_pricing_id` | `product_pricings.id` | | `billable_item_pricings` | `item_id` | `billable_items.id` | | `billable_metrics` | `item_id` | `billable_items.id` | | `product_metric_pricings` | `product_id` | `products.id` | | `product_metric_pricings` | `product_pricing_id` | `product_pricings.id` | | `product_metric_pricings` | `item_id` | `billable_items.id` | | `product_metric_pricings` | `item_pricing_id` | `billable_item_pricings.id` | | `product_metric_pricings` | `metric_id` | `billable_metrics.id` | | `subscription_metric_pricing_records` | `subscription_id` | `subscriptions.id` | | `subscription_metric_pricing_records` | `customer_id` | `customers.id` | | `subscription_metric_pricing_records` | `product_metric_pricing_id` | `product_metric_pricings.id` | | `one_time_billables` | `customer_id` | `customers.id` | | `one_time_billables` | `proposal_id` | `proposals.id` | ⚠️ `payment_transactions.invoice_uuid` joins to `invoices.uuid`, not `invoices.id`. *** ## Common patterns **Look up a customer**: Use `identifier` (your external ID) or the Measure-assigned `id`. Both are accepted in GET `/customers` endpoints. **Find a customer's current plan**: Fetch the customer's active subscriptions, then follow `bundle_pricing_id` to the BundlePricing. Use `GET /bundle_pricings/{id}` to see the products inside. **Understand what a subscription costs**: Fetch the BundlePricing, then its BundleProductPricings, then each ProductPricing's ProductMetricPricings to see the items and BillableItemPricings. **Preview an upcoming invoice**: Use the `next_invoice` tool or endpoint. It supports simulating a plan change or cancellation. **Change a subscription's plan**: `PATCH /subscriptions/{id}` with a `change_config` specifying the new `bundle_pricing_id`, change `timing`, and `proration_type`. **Cancel a subscription**: `PATCH /subscriptions/{id}` with a `cancel_config` specifying `timing` and `refund_type`. **Apply a credit**: `POST /credits` with the customer ID, amount, and currency. Credits are applied automatically to the next invoice. **Get payment history for an invoice**: Join `payment_transactions.invoice_uuid = invoices.uuid` — not `invoices.id`. # Anrok Source: https://docs.getmeasure.com/pages/guides/anrok Anrok calculates taxes on Measure invoices in real-time based on your nexus registrations and customer location. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product type * **Product tax mapping**: Map Measure products to Anrok tax codes to ensure correct tax treatment, with the ability to update mappings as your catalog evolves * **Nexus threshold tracking**: Monitor transaction volume against economic nexus thresholds in each jurisdiction * **SaaS-specific tax rules**: Anrok specializes in software and SaaS tax compliance across jurisdictions * **Flexible control**: Enable or disable tax calculation at the integration level ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the transaction details to Anrok, which returns the applicable tax amounts based on your product mappings and the customer's location. The correct tax codes are applied to every transaction automatically. ## Configuration Connect Measure to Anrok using API key authentication. Once connected, map your Measure products to Anrok tax codes to ensure accurate tax treatment. You can update these mappings at any time as your product catalog changes. # Approval Workflows Source: https://docs.getmeasure.com/pages/guides/approval-workflows Measure's approval workflows allow you to define rules that trigger an approval process for contracts. This helps ensure deal compliance and automates parts of your sales process. ### Approval Rules Admins can configure rules that check finalized contracts and initiate an approval process if the criteria are met. Approval rules can be based on criteria such as: * **Discount amount**: Require approval for contracts that exceed a certain discount percentage. * **Contract value**: Trigger an approval workflow for high-value deals to ensure executive oversight. * **Contract content**: Flag deviations from standard templates for legal review. ### Notifications and Review When a contract meets the defined criteria, designated approvers are automatically notified via email and within the Measure platform. Approvers can then review the contract details, approve or reject the terms, and optionally provide comments. This creates an auditable trail for each contract's approval process. # Attio Source: https://docs.getmeasure.com/pages/guides/attio Attio integration connects your CRM to Measure, enabling contract creation from Attio contacts and syncing customer and contract data back to your CRM. ## Key Capabilities * **Contract creation from Attio contacts**: Search and select Attio contacts when creating contracts or subscriptions in Measure * **Template auto-population**: Auto-populate contract templates using customer data from Attio * **Pipeline-triggered proposals**: Generate personalized proposals when opportunities reach specific pipeline stages right from within Attio * **Approval workflows**: Trigger approval workflows for high-value deals, enabling finance and legal review before contract progression * **Deal stage automation**: Update Attio deal stages based on contract signature status in Measure ## Data Synchronization Control how data flows between Attio and Measure: * **Action mapping**: Define what happens in Attio when actions occur in Measure (and vice versa) * **Field mapping**: Map customer and contract fields between systems, including deal stages with contract status ## Use Cases * **Quote-to-cash automation**: Sales reps create contracts directly from Attio deals, with contract status automatically updating deal stages through signature and payment * **Pipeline accuracy**: Keep deal values and stages accurate by syncing contract amounts and signature status back to Attio # Authentication Source: https://docs.getmeasure.com/pages/guides/authentication The Measure API leverages API tokens for authentication. You can create and manage your API tokens from the Measure dashboard. The API token needs to be set in the `Authorization` header as a bearer token for each API request you make. If your token is valid, our API server will process your request and return the requested resource. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/customers \ --header 'accept: application/json' \ --header 'authorization: Bearer ' \ --header 'content-type: application/json' ``` Please note that you should also keep your API token secret and secure, as anyone with access to your token will be able to access our API resources on your behalf. With security in mind, we recommend that you expire and regenerate your API tokens on a regular basis. # Authorize.net Source: https://docs.getmeasure.com/pages/guides/authorize Authorize.net is a payment gateway service provider that allows merchants to accept credit card and electronic check payments. Measure's integration with Authorize.net enables you to connect your account to automate payment collection and refunds seamlessly. As one of the most widely used payment gateways, Authorize.net provides reliable and secure transaction processing. This integration is ideal for businesses that already have an established relationship with Authorize.net or require a robust payment solution that supports a wide range of merchant accounts. This feature is in beta. Please reach out to us to enable this on your account. # Avalara Source: https://docs.getmeasure.com/pages/guides/avalara Avalara AvaTax calculates taxes on Measure invoices in real-time based on your nexus registrations and customer location. Measure is a certified Avalara integration partner. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product type * **Product tax mapping**: Map Measure products to AvaTax tax codes to ensure correct tax treatment * **Nexus threshold tracking**: Monitor sales activity against economic nexus thresholds in each jurisdiction * **Global coverage**: Access tax rates from 12,000+ US jurisdictions and 200+ countries ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the transaction details to Avalara, which returns the applicable tax amounts based on your product mappings and the customer's location. ## Tax Filing Avalara aggregates your Measure transaction data for tax filing. Use Avalara's filing services to submit returns based on your calculated tax liabilities. # Bank Reconciliation Source: https://docs.getmeasure.com/pages/guides/bank-reconciliation Measure supports bank reconciliation to simplify matching incoming payments to outstanding invoices. By connecting your bank account, you can streamline the process of tracking which invoices have been paid, especially for payments received outside of integrated payment processors. ## Overview Bank reconciliation bridges the gap between Measure and your bank account. When customers pay via wire transfer, ACH, check, or other methods that bypass your payment processor, reconciliation ensures those payments are properly matched to invoices and reflected in your accounts receivable. ## Automated Matching Suggestions When payments arrive in your connected bank account, Measure identifies and suggests matches for them to the corresponding invoices based on: * **Payment amount**: Exact or partial matches against outstanding invoice balances * **Reference numbers**: Invoice numbers or payment references included in transaction descriptions * **Customer information**: Payer name or company name matching customer records ## Manual Matching Measure also provides tools to manually associate bank transactions with specific invoices: * **Review queue**: View all unmatched transactions in one place * **Invoice search**: Find outstanding invoices by customer, amount, or date * **Split payments**: Apply a single payment across multiple invoices * **Partial payments**: Record partial payments against invoices with remaining balances ## Reconciliation Dashboard The reconciliation dashboard provides a unified view of your payment matching status: * **Unmatched transactions**: Bank deposits awaiting invoice assignment * **Outstanding invoices**: Invoices pending payment that may match incoming transactions * **Recently matched**: Review matched payments for accuracy * **Discrepancies**: Identify and resolve mismatches between expected and received amounts ## Use Cases Bank reconciliation is particularly useful for: * **Wire transfers and ACH payments**: Match bank transfers that bypass your payment processor * **Check payments**: Reconcile checks deposited directly to your bank account * **International payments**: Track payments from customers who pay via local bank transfer * **Offline payments**: Record payments received outside of your standard billing workflow ## Connecting Your Bank To enable bank reconciliation, connect your bank account via Plaid. See [Plaid Integration](/pages/guides/plaid) for setup instructions. # Google BigQuery Source: https://docs.getmeasure.com/pages/guides/bigquery BigQuery integration enables you to export billing and subscription data to your BigQuery data warehouse for advanced analytics, reporting, and integration with your broader data infrastructure. ## Key Capabilities * **Automated daily sync**: Billing data automatically syncs to your BigQuery dataset on a daily basis * **Complete data export**: Export customers, subscriptions, invoices, payments, prices, credits, discounts and contracts * **Schema management**: Measure manages table schemas and handles schema evolution as new fields are added ## Available Data Export comprehensive billing data to BigQuery: | Table | Description | | ----------------------------------- | ---------------------------------------------------- | | **Customers** | Customer records with metadata and custom fields | | **Products and Prices** | Product catalog and pricing plans | | **Subscriptions** | Active and historical subscription data | | **Contracts** | Contract records with terms and status | | **Credits and Discounts** | Applied credits and discount configurations | | **Invoices and Invoice Line Items** | Invoice records with detailed line items and status | | **Payments** | Payment transactions, refunds, failures, and retries | Each dataset is modeled with stable primary keys and foreign-key relationships so you can confidently join across objects and time. ## Use Cases * **Revenue analytics**: Build custom dashboards combining billing data with product and marketing data * **Financial reporting**: Feed billing data into finance and FP\&A reporting tools * **Customer health scoring**: Combine billing metrics with product usage for customer health analysis * **Data warehousing**: Centralize billing data alongside other business data for unified analytics # Billable Events Source: https://docs.getmeasure.com/pages/guides/billable-events # Custom Schedules Source: https://docs.getmeasure.com/pages/guides/billing-schedules Custom pricing schedules in Measure provide the flexibility to structure contracts with non-regular billing intervals. This is particularly useful for complex, multi-year agreements where payment amounts and timelines vary, moving beyond the constraints of standard recurring billing. With custom schedules, you can define a series of billing periods and specify a unique amount for each one. This allows you to model sophisticated payment plans, such as upfront fees, milestone-based payments, or ramp-up pricing over the life of a contract. For example, you can configure a 24-month contract where a customer: * Pays \$1,000 upfront. * Pays \$500 at month six. * Pays \$800 at months nine, twelve, and fifteen. * Pays \$1,000 at months eighteen and twenty-four. This capability ensures that all billing is automated according to the specific terms of your customer agreements, reducing manual work and improving accuracy. Once a custom schedule is created as a pricing plan, it can be easily attached to any new contract or subscription. # Campfire Source: https://docs.getmeasure.com/pages/guides/campfire Campfire integration syncs invoices, payments, credit notes, and customer records from Measure into Campfire's accounting platform, keeping your accounting records automatically up to date. ## Key Capabilities * **Invoice sync**: Automatically push finalized invoices to Campfire with per-line product and tax details * **Payment sync**: Record payments against invoices in Campfire, including processing-fee journal entries and clearing-to-bank sweeps * **Credit note sync**: Push credit notes and refunds to Campfire as credit memos, linked to the originating invoice where possible * **Customer sync**: Create and update customer records in Campfire, with optional billing address * **Multi-entity support**: Select a specific Campfire entity to sync into during setup * **Test mode**: Connect in test mode to validate your configuration before going live; Campfire uses per-tenant data isolation rather than a separate sandbox host ## Data Synchronization The integration is a one-way sync from Measure to Campfire. Measure remains the source of truth for billing data, and Campfire reflects your invoicing and payment operations. Data syncs automatically at regular intervals. You can also trigger a manual sync from the Measure dashboard. ### What Gets Synced | Entity | Behavior | | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Customers** | Created or updated in Campfire as vendor records; matched by email or name on initial sync | | **Invoices** | Created in Campfire with per-line product mapping; voided invoices are voided in Campfire | | **Payments** | Recorded against the matching Campfire invoice; processing fees post as a separate journal entry; net amount sweeps to the deposit bank account if configured | | **Refunds** | Posted as standalone credit memos in Campfire, crediting the configured deposit bank account | | **Credit Notes** | Posted as credit memos linked to the originating invoice; memo stays unapplied if the invoice is already settled | ## Considerations * **Product mapping required**: Every line item on an invoice must be mapped to a Campfire product before invoices can sync; unmapped products block that invoice * **Clearing account required**: A clearing bank account must be configured per currency before payments can sync * **Customers without names**: Customers with no name in Measure are skipped and logged * **Invoice updates**: Campfire invoices are immutable after creation; updates to invoice data in Measure do not propagate to Campfire * **Rate limits**: The integration respects Campfire's rate limit of approximately 1 request per second # Contract Reminders Source: https://docs.getmeasure.com/pages/guides/contract-reminders Measure automates contract follow-ups with configurable email reminders. Reminders are sent for each contract stage (signing, payment collection) and support multiple signers, ensuring deals do not stall at any point in the process. Contract reminders require the Send Customer Emails setting to be enabled ## Reminder Schedules Choose from three preset patterns (Basic, Lenient, Persistent) or create custom schedules tailored to your sales process. **Continuous reminders**: After the final preset reminder, continuous reminders send recurring follow-ups at configurable intervals (e.g., every 3 days) until manually stopped. This ensures persistent engagement without deals falling through the cracks. ## Tracking Reminder status is visible in both the contract list (for quick status assessment) and individual contract views (for complete reminder history). The system automatically creates reminder schedules for each new contract once enabled. ## Control * **Global**: Enable or disable reminders organization-wide from Contract Settings. Disabling stops all existing reminders and prevents new ones from being created. * **Per-contract**: Stop reminders on individual contracts based on customer preferences or deal circumstances while keeping the global system active. # Contract Renewals and Plan Changes Source: https://docs.getmeasure.com/pages/guides/contract-renewals-and-plan-changes Measure supports contract renewals and mid-term plan changes, allowing you to transition customers to new terms while maintaining continuity. ## Renewals When you initiate a renewal from an existing subscription, Measure automatically carries over customer information and subscription terms as the baseline for the new contract. You can then adjust pricing, terms, or plans before sending for signature. **Renewal reminders**: Configure automated reminder emails to start the renewal process ahead of expiration. Set the timing (e.g., 90 days before expiration) and customize the messaging to align with your sales process. ## Change Contracts Change contracts formalize mid-term modifications such as upgrading tiers, adding seats, or adjusting commitment levels. * **Differential pricing**: Measure automatically calculates and displays the difference between the current plan and new plan, showing customers exactly what's changing * **Proration**: Mid-term changes are prorated based on the remaining contract period, ensuring accurate billing for partial periods * **Clear visibility**: Generated contracts highlight plan differences for both your team and the customer, speeding up the approval process ## Workflow Both renewal and change contracts follow the same approval and signature workflows as standard contracts. If approval workflows are configured, these contracts route through your approval process before being sent to the customer. # Contract Templates Source: https://docs.getmeasure.com/pages/guides/contract-templates Measure Contracts allow you to create different contract templates to meet all your sales needs. These templates can be customized to dynamically include all the variables and inputs added to the contract. **Template management capabilities**: Measure provides comprehensive template creation and customization tools, supporting both new template development and modification of existing templates for evolving business needs. ## Template Types Measure supports two distinct template types optimized for different business processes: **Sales Contract Templates**: Used for CPQ (Configure, Price, Quote) workflows and revenue-generating agreements. These templates include advanced pricing variables and are designed for transactions that create subscriptions and revenue. **Agreement Templates**: Used for non-transactional documents like NDAs, MSAs, and DPAs. These templates don't include pricing or payment terms and are designed for formal, administrative agreements. ## Creating Templates When creating a new template, you'll define the contract structure with static text and dynamic variables. The template editor allows you to write the full contract body and insert placeholders for dynamic content that will be populated when creating individual contracts. All templates require specific signature fields to ensure proper execution. Sales Contract templates require a pricing table and at least one signature field. Agreement templates require only a signature field, giving you maximum flexibility for various document types. ## Dynamic Content and Variable System **Flexible content integration**: Templates support comprehensive contract text with dynamic variable insertion, enabling personalized contract generation while maintaining consistent formatting and legal language. **Variable categories available**: * ​**Customer variables**: Automatically populate customer-specific information including organization name, contact details, and account information * ​**Signatory variables**: Manage external signatory details for contract execution and approval workflows * **Counter Signatory variables**: Handle internal signatory information for contracts requiring company approval **Multi-signature support**: Templates with multiple external signatures or counter signatures automatically display the appropriate input fields during contract creation based on the variables included in the template. * **Contract variables**: Dynamic insertion of contract terms including pricing information, start dates, net terms, and other deal-specific details **Sales Contract exclusives**: Advanced pricing variables such as "Pricing Information", "ACV", "TCV", "Minimum Spend", and "Currency" are specifically available for Sales Contract templates to support comprehensive CPQ workflows. * ​**Company variables**: Standardized company information including legal name, address, and contact details for consistent branding across all contracts ## Customer Input Fields Templates can include fields that customers complete when reviewing and signing the contract. This allows you to collect information directly from the customer during the signing process rather than requiring it upfront. **Available customer input types**: * **Billing email**: Collect the customer's billing email for invoice delivery. This is automatically saved back to the customer record. * **Billing address**: Capture the customer's billing address for invoicing and tax purposes. This is automatically saved back to the customer record. * **Custom text fields**: Add any additional text fields for information you need the customer to provide, such as PO numbers, department codes, or other business-specific data Customer input fields appear as fillable form fields in the contract document. The customer completes these fields before signing, and the entered information is captured and stored with the contract document. # Sales Contracts Source: https://docs.getmeasure.com/pages/guides/contracts Measure provides contract and quote management integrated with your subscriptions and invoicing. You can create contracts from templates, collect signatures, and automatically convert signed contracts into subscriptions with the agreed pricing. Contracts are signed using Dropbox Sign (integrated by default, or with your own authenticated account). Once signed, the contract pricing creates a subscription and syncs to connected systems for feature entitlement and revenue tracking. ## Contract Lifecycle Contracts in Measure follow a structured workflow from creation to execution: ### Draft In the Draft stage, you create a contract by: * Selecting a template and designating a customer and signatories * Configuring contract details: title, expiration date, start date, and subscription terms * Defining pricing based on your product catalog * Optionally requiring payment collection * Optionally enabling internal approval workflows ### Waiting for Approval (Optional) If approval workflows are enabled, contracts may require internal approval before being sent. For example, approval may be required if the discount exceeds a threshold. [More on approval workflows](/pages/guides/approval-workflows) ### Pending Signatures Once finalized, contracts can be delivered via: * **Email**: Direct delivery from Measure with integrated signature collection * **Shareable links**: Links can be embedded in emails or messages * **PDF download**: For offline distribution and record-keeping ### Pending Payment (Optional) If payment collection is enabled, the customer's payment card information is collected after the contract is signed. ### Awaiting Manual Confirmation (Optional) An additional approval stage can be required before the contract is considered executed. For example, this could be an implementation or onboarding stage. ### Executed At this stage, the contract is considered fully executed and the associated subscription will be created for the customer. ## Contract Templates Templates provide pre-formatted contract documents with standard clauses and sections. They can be order forms, MSAs (Master Sales Agreements), SOWs (Statements of Work), or other agreement types. **Two template types**: "Sales Contract" templates for CPQ workflows and "Agreement" templates for general agreements. **Requirements**: Sales Contract templates require a pricing table and signature field. All other fields and formatting are optional, allowing you to customize templates for different deal types. Templates support dynamic variables for customer information, signatory details, pricing data, and company branding. For detailed template configuration, see [Contract Templates](/pages/guides/contract-templates). ## Signature Workflows Measure supports flexible signature collection to match your business requirements: * **Single signature**: Standard contracts requiring one customer signature * **Multiple signatories**: Up to 3 external signatures for enterprise deals requiring multiple stakeholders (CFO, legal, department heads) * **Counter-signatures**: Internal approval signatures from your team before or after customer signing * **Offline signing**: Import contracts signed outside of Measure with optional PDF upload for record-keeping Learn more about [Multiple Signatories and Counter Signatories](/pages/guides/multiple-and-counter-signatures) and [Offline Contract Signing](/pages/guides/contracts-signed-offline). ## Renewals and Changes Measure provides end-to-end support for contract renewals and mid-term modifications: * **Renewal contracts**: Transition customers to new terms with automatic carry-over of customer information and baseline terms * **Change contracts**: Formalize plan upgrades, seat additions, or pricing adjustments with differential contract generation * **Renewal reminders**: Automated email reminders configurable for your sales cycle (e.g., 90 days before expiration) See [Contract Renewals and Plan Changes](/pages/guides/contract-renewals-and-plan-changes) for complete renewal workflow details. ## Automated Reminders Stay on top of pending contracts with automated follow-up emails: * **Pre-configured schedules**: Choose from Basic, Lenient, or Persistent reminder patterns * **Custom scheduling**: Define your own reminder cadence based on your sales process * **Continuous reminders**: Optional recurring follow-ups until the contract is signed * **Granular control**: Enable/disable reminders globally or for individual contracts Configure reminders in [Contract Reminders](/pages/guides/contract-reminders). ## General Agreements For non-commercial documents like NDAs, MSAs, DPAs, and partnership agreements, Measure supports a separate Agreement workflow. Agreements don't include pricing or payment terms and are designed for formal arrangements that establish foundational business terms. Learn more about [Agreements](/pages/guides/general-agreements). ## Custom Variables Add custom fields to contracts for your specific needs. Variables can be text fields for open-ended input or choice fields for standardized selections. Custom variables are populated during contract creation and rendered in the final document. ## CRM Integrations Contracts integrate with your CRM and sales workflows. Contract data syncs bidirectionally with your CRM, keeping deal information aligned across systems. See [Sales and CRM Providers](/pages/guides/sales-and-crm-integrations) for available integrations. # Offline Contract Signing Source: https://docs.getmeasure.com/pages/guides/contracts-signed-offline Measure Contracts can be signed offline for many reasons. Measure allows you to bring these contracts into the simplified contract workflow. **Offline signing flexibility**: When customers choose to sign contracts offline, Measure provides seamless integration capabilities to incorporate these executed documents back into your automated workflow. ## When to Use Offline Signing There are many scenarios where offline signing makes sense for your business: * **In-person meetings**: Contracts signed during face-to-face negotiations or on-site visits * **Alternative signing methods**: Using wet signatures, digital signing platforms outside of Measure, or industry-specific signing requirements * **Legacy processes**: Integrating with existing contract workflows that were signed before implementing Measure * **Special circumstances**: Cases where digital signing through Measure isn't available or practical ## Offline Contract Processing **Manual execution tracking**: The system supports marking contracts as signed offline, maintaining workflow continuity even when signatures occur outside the digital platform. **Document upload capability**: Optional PDF upload functionality allows you to attach the signed contract document for complete record-keeping, with flexibility to add documents immediately or at a later time. ## Workflow Integration **Simple workflow integration**: The offline signing process maintains full integration with Measure's contract management system. You can mark a contract as signed offline and optionally upload the executed PDF to maintain a complete audit trail of your agreement. Once marked as executed, the contract will progress through the payment collection stage (if enabled) and then to the [appropriate post-signature workflow](/pages/guides/contracts#contract-lifecycle). The contract will automatically create the associated subscription with the terms defined in the agreement, ensuring your records stay in sync even when signing happens outside the platform. # Core Concepts Source: https://docs.getmeasure.com/pages/guides/core-concepts This guide provides a comprehensive overview of the core concepts for revenue management in Measure. It details the fundamental entities and workflows applicable to both dashboard-based and API-driven billing operations. ## Operating Modes Measure can be leveraged in **no-code mode** through the dashboard. For deeper integration, the platform also provides a robust **API** so you can perform any dashboard action as a white-labeled experience in your own product, including usage-based and seat-based billing. **Test account**: Request a separate test account from [support@getmeasure.com](mailto:support@getmeasure.com) with distinct credentials so you can experiment before going live. ## Key Concepts ### Company When you sign up, Measure provisions a **company** for your business. All entities described below belong to that company. You can configure the company with an address, timezone, currency, and branding so it represents your product or business. ### Billable Items and Metrics Billable items and metrics are the core units for billing. **Billable items** are distinct billable entities in your product, for example Licenses, API Calls, or Users. Items can be **usage-based** and transient (e.g., API calls) or **object-based** and persistent (e.g., users). **Billable metrics** are rules and aggregators applied to billable items. They query events or objects and produce an aggregate value that is ultimately billed to the customer. ### Events and Objects Measure supports metering for: * **Usage-based items** (transient): e.g., API calls, bandwidth, compute minutes * **Object-based items** (persistent): e.g., seats, licenses, stored objects **Why both?** Events drive usage-based metrics; objects drive object-based metrics. Measure treats them separately because **revenue from persistent objects** (e.g., seats) counts as recurring revenue, while **revenue from transient events** does not, unless you have minimum pre-purchased events. ### Prices and Plans Pricing starts with **item prices** for each billable metric. You then combine them into **product pricing** (plans) with one or more billable components. Product prices represent different offerings (e.g., Basic, Pro, or Enterprise plans). ### Customers A **customer** is a business or user you bill through Measure. You can begin billing with just an email; for taxation and more advanced needs, add a customer address. Customers are central: they link to events, objects, contracts, subscriptions, invoices, and payments. ### Subscriptions A **subscription** represents recurring service for a customer. A subscription can include one or more product pricing, so a single invoice can cover multiple offerings. ### Contracts A **contract** is a proposal for a subscription or one-time charge. Contracts include a signature step before the subscription starts, which is common in enterprise sales. Measure Contracts simplify CPQ: create and share contracts, follow up to get them signed, and automatically create the associated subscriptions. ### Invoices and Payments An **invoice** can represent recurring or one-time charges. For active subscriptions, you can also preview upcoming invoices, which is useful for usage-based charges. Measure integrates with multiple payment providers to process payments for invoices. ## Explore Product Guides Configure your product catalog, plans, and packaging Set up rules and aggregators for usage-based and object-based billing Create and manage customers for billing Manage recurring subscriptions and plan changes Create, share, and sign proposals before subscriptions start Issue invoices, collect payments, and automate revenue collection # Create checkout session Source: https://docs.getmeasure.com/pages/guides/create_checkout_session # Create Checkout Session post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/checkout](https://api.getmeasure.com/api/v1/companies/\{company_id}/checkout) Create a customer-specific checkout session link to purchase a set of plans # Create contract Source: https://docs.getmeasure.com/pages/guides/create_contract # Create Contract post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/contracts](https://api.getmeasure.com/api/v1/companies/\{company_id}/contracts) Create a signature-enabled contract link to purchase a set of plans # Create credit Source: https://docs.getmeasure.com/pages/guides/create_credit # Create Credit post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/credits](https://api.getmeasure.com/api/v1/companies/\{company_id}/credits) Create a credit with given parameters # Create customer Source: https://docs.getmeasure.com/pages/guides/create_customer # Create Customer post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/customers](https://api.getmeasure.com/api/v1/companies/\{company_id}/customers) Create a customer with given parameters # Create entitlement Source: https://docs.getmeasure.com/pages/guides/create_entitlement # Create Entitlement post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/entitlements](https://api.getmeasure.com/api/v1/companies/\{company_id}/entitlements) Create an entitlement with given parameters # Create object Source: https://docs.getmeasure.com/pages/guides/create_object # Create Object post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/objects](https://api.getmeasure.com/api/v1/companies/\{company_id}/objects) Create an object for metrics calculation # Create one time charges Source: https://docs.getmeasure.com/pages/guides/create_one-time_charges # Create One-Time Charges post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/one\_times](https://api.getmeasure.com/api/v1/companies/\{company_id}/one_times) Create a one-time charges with given parameters # Create subscription Source: https://docs.getmeasure.com/pages/guides/create_subscription # Create Subscription post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/subscriptions](https://api.getmeasure.com/api/v1/companies/\{company_id}/subscriptions) Create a subscription with the provided plan details # Credit Notes Source: https://docs.getmeasure.com/pages/guides/credit-notes Credit notes, also known as credit memos, are documents issued by a seller to a buyer, reducing the amount the buyer owes to the seller under the terms of an earlier invoice. Credit Notes are generally used in, but not limited to, the following scenarios: * Returned Goods: The buyer has returned goods to the seller due to damage, defect, or other reasons. * Overbilling: There was an error in the original invoice, such as overbilling or incorrect pricing. * Discounts or Rebates: The seller wants to offer a discount or rebate after the initial invoice was issued. * Promotional Credits: Credits given for promotional purposes or customer satisfaction. Measure provides a comprehensive system for managing credit notes, ensuring accurate accounting and clear communication with customers. ### Flexible Credit Issuance You can issue a credit note for an entire invoice or for specific line items within an invoice. This granularity allows you to accurately reflect adjustments for particular products or services. When creating a credit note, you can specify the exact amount to be credited. ### Handling Paid Invoices Measure offers flexibility when issuing credit notes for invoices that have already been paid. You can choose to: * **Issue a Refund:** For payments processed through integrated payment providers like Stripe, you can initiate a refund directly. The credited amount is returned to the customer's original payment method. * **Apply as Account Credit:** The credited amount can be added to the customer's account balance. This credit will be automatically applied to their future invoices. * **Attach an Existing Refund:** If a refund has already been processed outside of the credit note workflow, you can link it to the credit note for accurate record-keeping. ### Communication and Record-Keeping To maintain clarity for both your team and your customers, Measure's credit notes include several communication features: * **Customer-Facing Memos:** Add a memo that will be visible to your customer on the credit note, explaining the reason for the credit. * **Internal Notes:** Keep internal-only notes for your team's reference. * **Automated Notifications:** When a credit note is issued, the customer automatically receives an email notification, ensuring they are aware of the adjustment to their account. ### Management and Audit Trail All credit notes are linked to their original invoices, providing a clear and auditable trail of adjustments. You can also update the internal and external notes on a credit note after it has been issued to add more context if needed. Only payments made through Stripe can be refunded # Credits-Based Billing Source: https://docs.getmeasure.com/pages/guides/credits-based-billing Measure enables purchasing, tracking and consumption of application credits for your customers. This is typically useful for resource-based applications such as AI or SaaS infrastructure products, where post-charging with simple usage-based billing can be a risk due to high costs of providing the service. With credits-based billing, credits can be added to the customer with pricing plans that ensure upfront revenue. Credits can be offered for specific billable items in your product or in the form of monetary credits. Enabling credits-based pricing in your product typically involves the following steps. ### Set up a billable item to issue credits in your app Billable items in Measure help track distinct entities for which you would like to track credits for in your application. ### Setting up credits-based pricing Measure supports the creation of pricing plans that add credits for different billable items for the customer. To get started with creating credits-based pricing, go to Products > Add New Product Pricing The purchase of any credits-based pricing plan is also flexibly supported even via [Payment, Checkout and Contract Links](/pages/guides/optimizing-checkout-with-payment-links). ### Managing credits for the customer Credits for a customer can be managed through the Measure dashboard or through the [Credits](/api-references/credits/create-credit) API. Credits related to different billable items can be added, expired or revoked on an individual grant basis. ### Consuming credits in your application Measure provides an API for credits consumption [Consume Credits](/api-references/credits/consume-credits). This enables you to deduct credits from a customer for a particular billable item based on actions they perform in your product. For example, if you have email credits in your product, you can deduct an email credit from the customer balance as soon as a successful send is complete. Measure ensures that consuming credits scales reliably, we keep track of accurate customer credit balances even when consumption is being deducted at a high rate. A detailed log for consumption of credits is also tracked and can be retrieved through the [Find Credit Logs](/api-references/credits/find-credit-logs) API. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/credits/consume \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "customer_id": "customer_id", "type": "UNITS", "item_id": "billable_item_id", "units": 5 } ' ``` ### Checking credits balance The credit balance for the customer can be viewed through the Measure dashboard or through the API. The [Check Balance](/api-references/credits/check-balance) API provides a detailed breakdown of credits for each billable item and the standing balance that can be exposed in your application. ### Credit Log An auditable log of all credits can be viewed through the Measure dashboard (Reports > Credit Log) or through the API ### Displaying credits to customers Credit balances and credit consumption logs for customers can be exposed to your customers via the [Customer Portal](/pages/guides/customer-portal) # Custom Email Domains Source: https://docs.getmeasure.com/pages/guides/custom-email-domains Measure allows you to configure a Custom Email Domain to send transactional or notification emails (e.g., invoices, alerts) using your own domain (e.g., @yourcompany.com). This ensures brand consistency and improves email deliverability. ### Configuring Your Custom Email Domain * Before you begin, ensure you have access to your domain's DNS settings as you will need to modify them to verify ownership * From the left menu, click on **Integrations** * Click Install on **Custom Email Domain** * Enable the Custom Domain and/or Email Provider setting * Configure your * "From" Address * Custom Domain * Sender Addresses Once set, your email will be delivered from the configured address and/or domains. # Customer Portal Source: https://docs.getmeasure.com/pages/guides/customer-portal The Customer Portal is a hosted self-service interface for customers to manage their billing. Customers can view and download invoices, update payment methods, track subscriptions, and manage account information—reducing support overhead for your team. ## Access Methods * **Dashboard links**: Direct links generated from the Measure dashboard * **API access**: Dynamically generated authenticated links via the [Customer Portal API](/api-references/customer-dashboards/get-customer-portal-link) for embedding in your application * **Magic links**: Company-level portal access that customers retrieve using their email on file ## Customization * **Branding**: Custom theming to match your brand * **Content**: Selectable billing sections (invoices, subscriptions, payments, credits) ## Self-Service Subscription Management * **Cancellation**: Customers can cancel subscriptions, effective at the end of the current billing term * **Seat/license upgrades**: Immediate effect with prorated charges for the remainder of the billing period * **Seat/license downgrades**: Takes effect at the start of the next billing cycle with no proration Seat and license management is available for license-based and seat-based subscriptions only. # Customers Source: https://docs.getmeasure.com/pages/guides/customers Customers can be managed both through the API as well as through the Measure dashboard. Customers have the following properties, but the most notable is the `identifier` which uniquely tracks a customer. This is typically set to your customer ID to map customers from Measure to your application. This `identifier` is also used for sending events or syncing objects for billing the customer. The customer also supports saving arbitrary metadata for additional mapping of fields or information to your application. ```bash theme={null} { "id": "cus_xyz", "company_id": "cmp_2MkGNwZqoewXZ38Sc2AzYZh4x50", "name": "Bob Jones", "email": "[email protected]", "identifier": "customer_123", "address": { "country": "US", "state": "CA", "zip": "94110", "city": "San Francisco", "address_line_1": "1 Something Street", "address_line_2": "Unit 5", }, "phone": "555-555-555", "locale": "en", "org_name": "Measure Systems", "metadata": { "key1": "value1", "key2": "value2", "key3": "value3" } ... } ``` ### Assigned Account Owners Customers can be assigned to specific owners, such as the Sales Rep. or Account Executive who owns that customer relationship. Once an account owner is set, you can configure invoice payment reminders and payment failure notifications to be sent to the owner as well. Go here to learn more about about [Payment Recovery and Reminders](/pages/guides/minimizing-payment-failures). ### Customer Tags Measure allows you to create custom tags for customers which can be used to trigger actions based on configured rules. ### Parent and Child Billing Measure also supports [Parent-Child billing relationships](/pages/guides/parent-billing) as a comprehensive solution designed to manage complex billing relationships within an organization. ### Customer Portal Measure supports a [Hosted Customer Portal](/pages/guides/customer-portal) to enables customer self-help workflows to relieve your support team of billing issues. The customer portal is fully configurable allowing to balance control and transparency. # Data Import and Migration Source: https://docs.getmeasure.com/pages/guides/data-import-and-migration Measure provides a robust set of features to import your data and migrate from other platforms seamlessly. Our tools are designed to ensure data integrity and a smooth transition, whether you're bringing in customer lists or migrating complex subscription histories. Your migration journey involves exporting data from your current system, mapping it to the data model in Measure, and then importing it using our flexible tools. We recommend exporting data in a structured format like CSV or JSON. ### Stripe Sync For users migrating from Stripe, Measure offers a dedicated, robust synchronization feature. We enable a one-way, continuously synced import of Stripe subscriptions into Measure. The concepts of Stripe subscriptions, pricing, and promotions are completely mapped into equivalent concepts in Measure. Any new subscriptions or changes to Stripe are automatically synced. The constant sync of Stripe subscriptions makes it easy to take your time and ensure a stable switch to Measure without any downtime for your application and customers. We also ensure that billing for each customer is cleanly managed by only one platform (Stripe or Measure). ### Bulk CSV Import For straightforward bulk data transfers, you can use our CSV import tools directly from the Measure dashboard. We provide templates and clear validation to guide you through the process of importing customers, events, and more. This method is ideal for one-time migrations of static data. ### API Import For more complex or ongoing data synchronization needs, our REST API provides endpoints to programmatically create and update records. This is ideal for: * Building custom migration scripts. * Synchronizing data from a proprietary system. * Ensuring data consistency with idempotent requests. * Automating data updates and ongoing data management. ### Contract Workflows Measure provides enhanced support for contract workflows so you can manage both business billing and self-serve billing in a single system. This means that your contract documents along with branding can be uploaded into Measure as templates. This ensures a seamless transition or starting of contract workflows with Measure. ### Sandbox Environment Test your entire import and migration process in a dedicated sandbox environment. This allows you to validate your data and workflows without affecting your live production data. ### Data Reconciliation After importing data into the sandbox, perform thorough data reconciliation. Compare key metrics and records between your old system and Measure to ensure everything matches. This includes: * Customer counts and details * Active subscription numbers and pricing * Total revenue figures for historical periods ### Data Validation During the import process, Measure automatically validates your data for correctness and consistency. If any issues are found, we provide clear error reports, making it easy to identify and fix problems in your source data before retrying the import. ### Go-Live Once your data is validated and you are confident in the migration, you can transition to using Measure as your primary platform. Our team has experience helping customers transition from platforms like Stripe, Chargebee, and Recurly, and we will support you during this final phase to ensure a seamless cutover. # Data Processing Agreement Source: https://docs.getmeasure.com/pages/guides/dpa A Data Processing Agreement (DPA) is a legally binding contract that outlines the roles, responsibilities, and obligations between a data controller and a data processor when handling personal data. It covers topics such as data security, data retention, breach notification, and the scope of processing activities. For a list of third-party services that may process data on our behalf, see [Subprocessors](/pages/guides/subprocessors). If you are interested in retrieving our DPA, please reach out to us at [support@getmeasure.com](mailto:support@getmeasure.com). # Dropbox Sign Source: https://docs.getmeasure.com/pages/guides/dropbox-sign Dropbox Sign provides e-signature capabilities for Measure contracts. Measure includes Dropbox Sign by default, but you can connect your own account for full control over document management. ## Key Capabilities * **Built-in e-signature**: Measure contracts use Dropbox Sign for legally compliant signatures out of the box * **Custom account connection**: Connect your own Dropbox Sign account for complete control over sent documents * **Document management**: Access all signed contracts through your Dropbox Sign dashboard Ensure your Dropbox Sign account is provisioned for API access if connecting your own account. # Embeddable Dashboards Source: https://docs.getmeasure.com/pages/guides/embeddable-dashboards These include out-of-the-box embeddable dashboards for your product without having to take the engineering lift on building completely white-labeled UX experiences. You can use the Measure API to retrieve an embeddable dashboard links which can be displayed through an iframe within your app. ## Usage Dashboard The usage dashboard allows your customers to see how they are using your product with usage-based metrics. This allows you to show your customers how they are using your product. Please refer to the [Get Customer Usage Dashboard Link](/api-references/customer-dashboards/get-customer-usage-dashboard-link) API to get the embeddable link that can be displayed via an iframe in your application. ## Invoice Dashboard (coming soon) The invoice dashboard allows your customers to view their current and historical invoices. ## Credits Dashboard (coming soon) The credits dashboard shows credits grants issued to the customer along with the credit log thus far. # Error Responses Source: https://docs.getmeasure.com/pages/guides/error-responses Error responses from the Measure API have the following fields * `error_message` The description for the error * `error_type` The type of error such as `auth_error`, `validation_error` etc. Please see a full list of error types below. * `error_code` The error code for the type of issue that can be referenced for nuanced error handling * `error_status` The same as the HTTP status code for the response The error response can have additional fields that have more details about the error. For example, the `validation_errors` field is populated for errors with type `validation_error` ```json theme={null} { "error_message": "Request body does not contain all required information", "error_type": "validation_error", "error_status": 400, "validation_errors": [ { "field": "config_items", "message": "config_items is required" } ] } ``` Here's more details on the different status codes and error types with the Measure API | Status Codes | Error Type | Description | | ------------ | ------------------------------------- | ------------------------------------------------------- | | 400 | `request_error` or `validation_error` | Bad request parameters or validation failure | | 401 | `auth_error` | Auth token failure or unauthorized access to a resource | | 403 | `auth_error` | Forbidden access to a resource | | 404 | `request_error` | Resource not found | | 409 | `idempotency_error` | Conflicting requests with the same idempotency key | | 429 | `request_error` | Rate limiting has occurred | | 500 | `request_error` | Internal server error within Measure | # Feature Entitlements Source: https://docs.getmeasure.com/pages/guides/feature-entitlements Measure allows you to manage different sets of features for different plans without any engineering involvement. You can make your code oblivious to which features are packaged into different plans. This allows for easy experimentation with different features in different packages and allows you to customize the feature set for larger customers without having to rely on your engineering team. Measure supports three kinds of feature entitlements * Boolean entitlements * Numerical or string-based entitlements * Enum or choice-based entitlements * Metered entitlements supported through billable metrics Entitlements can be set at different levels of the pricing stack such as the product level, the pricing level and the individual subscription level. The details of all entitlements, inherited or overridden are returned as computed entitlements with each of the APIs for pricing and subscriptions. ## Product, Pricing and Subscription Entitlements Product entitlements are inherited by default at the pricing or subscription level but can be explicitly overridden to accommodate for different pricing tiers or specific customer requirements or exceptions. ## Entitlement Aggregation The entitlements from each subscription can be aggregated (at a customer level) to provide overall entitlements for that customer. The following aggregation types are supported for the corresponding entitlement types. * Boolean entitlements - OR - True if any of the subscriptions has the entitlement enabled AND - True only if any of the subscriptions has the entitlement enabled * Numerical entitlements - Add - Add up all the numerical entitlement values Minimum - Pick the minimum numerical entitlement value Maximum - Pick the maximum numerical entitlement value * String/Text entitlements Coalesce - Combine all the entitlement values into an array * Enum/Choice entitlements Coalesce - Combine all the entitlement values into an array # Financial Reporting Source: https://docs.getmeasure.com/pages/guides/financial-reporting Measure serves as the source of truth for pricing, subscriptions, invoicing, and payment status. Financial reports provide finance teams with comprehensive visibility into revenue, receivables, and customer-level metrics. All reports support CSV export and custom date ranges. ## Invoiced Revenue Total amounts billed with breakdowns by customer, product, prices, product tags, price tags and time period. View revenue trends over time to identify growth patterns and seasonality. ## ARR/MRR/MRR Logs Recurring revenue by customer and time period. Track MRR movements including new, expansion, contraction, and churned revenue. Monitor customer-level ARR to identify your highest-value accounts and at-risk revenue. MRR logs provide a detailed audit trail of every change to recurring revenue. ## Aged Receivables Outstanding balances segmented by aging bucket (current, 30, 60, 90+ days) with customer-level detail. Identify overdue accounts to prioritize collection efforts and track receivables trends over time. ## Credit Logs Detailed history of credit issuance and consumption across customers. Track credit balances, expirations, and usage patterns. For deferred revenue, journal entries, and ASC 606/IFRS 15 compliance reporting, see [Revenue Recognition](/pages/guides/revenue-recognition). # Agreements Source: https://docs.getmeasure.com/pages/guides/general-agreements Agreements are non-commercial documents that formalize terms between you and your customers. Unlike sales contracts, agreements do not include line items, pricing, or payment terms. ## Common Agreement Types * **Non-Disclosure Agreements (NDAs)**: Protect confidential information shared between parties * **Master Service Agreements (MSAs)**: Establish general terms and conditions governing your relationship * **Data Processing Addendums (DPAs)**: Address data protection and privacy compliance requirements * **Partnership Agreements**: Formalize collaborative relationships with partners or resellers * **Service Level Agreements (SLAs)**: Define performance standards and commitments ## Key Differences from Sales Contracts | | Sales Contracts | Agreements | | ------------------------- | ------------------------------- | --------------------------- | | **Purpose** | Revenue-generating transactions | Non-commercial terms | | **Pricing** | Required pricing table | No pricing or payment terms | | **Template requirements** | Pricing table + signature | Signature only | | **Creates subscription** | Yes | No | ## Templates Agreement templates use the same template system as sales contracts but with minimal requirements—only a signature field is mandatory. See [Contract Templates](/guides/contract-templates) for details on creating and managing templates. ## Workflow Agreements follow the same creation and signing workflow as sales contracts: 1. Select an agreement template and associate with a customer 2. Complete any dynamic fields and save as draft or finalize 3. Share via direct link or email for signature 4. Agreement status automatically updates to "Executed" once signed # Helcim Source: https://docs.getmeasure.com/pages/guides/helcim This feature is in beta. Please reach out to us to enable this on your account. Helcim integration enables payment processing with Helcim's interchange-plus pricing model. ## Key Capabilities * **Automated payment collection**: Charge customer payment methods automatically when invoices are finalized * **Secure payment storage**: Payment methods are stored in Helcim's PCI-compliant vault * **Interchange-plus pricing**: Benefit from Helcim's transparent, cost-effective pricing model * **Test mode support**: Validate your payment workflows before going live # Overview Source: https://docs.getmeasure.com/pages/guides/hosted-components Measure offers a number of hosted components that enable core revenue workflows for your customers. These components can be enabled from the Measure dashboard or can be dynamically instantiated from the API. ## Component Overview Hosted components are pre-built, white-labeled interfaces that handle critical revenue operations. They can be embedded directly in your application or accessed via shareable links. ### Available Components **Payment & Checkout Links**: Allow customers to pay for subscriptions or one-time charges with complete checkout flows without building custom payment interfaces. These links can be shared one-off or embedded in your application. **Contract Links**: Distribute contracts to customers for review and signature collection. Customers can access contracts via secure links and complete the signature process without requiring a Measure account. **Payment Method Management**: Provide customers with a dedicated interface to add, update, or remove payment methods on file. This is useful for ensuring payment information stays current without involving your support team. **Customer Portal**: A comprehensive self-service hub where customers can view invoices, manage subscriptions, adjust seat counts, track billing activity, and handle cancellations. The portal serves as a single destination for all customer billing needs. # HubSpot Source: https://docs.getmeasure.com/pages/guides/hubspot HubSpot integration connects your CRM deals to Measure contracts, enabling sales teams to create and track contracts without leaving HubSpot. ## Key Capabilities * **Contract creation from deals**: Create Measure contracts directly from HubSpot deal records using the embedded Measure card * **Two-way sync**: Keep customer and deal data synchronized between HubSpot and Measure * **Contract status visibility**: View contract status, signature progress, and payment status from within HubSpot * **Price catalog sync**: Push your Measure product catalog to HubSpot for use in deal workflows ## Data Synchronization Configure how data flows between HubSpot and Measure: **Action mapping**: Define what happens in HubSpot when actions occur in Measure (and vice versa). Choose which system is the source of truth for customer and contract information. **Field mapping**: Map customer and contract fields between systems to ensure data consistency. Custom fields can be mapped to maintain your specific data requirements. ## Sales Workflow The HubSpot integration streamlines the quote-to-cash process: 1. Sales rep works a deal in HubSpot 2. When ready, creates a Measure contract directly from the deal record 3. Contract status updates sync back to HubSpot automatically 4. Deal closes when contract is signed and payment is collected ## Price Catalog Products and pricing plans created in Measure can be synced to HubSpot. This enables your sales team to access your full pricing model within the HubSpot deal interface while Measure remains the source of truth for pricing. ## Custom Objects Measure pushes custom objects to HubSpot for subscriptions and invoices, giving your team full visibility into billing data within the CRM. **Subscription objects**: View active subscriptions, plan details, billing frequency, and renewal dates directly on contact and company records. Track subscription changes over time without switching between systems. **Invoice objects**: Access invoice status, amounts, due dates, and payment history from within HubSpot. Identify overdue invoices and outstanding balances at a glance. ## Customer Success Workflows Use Measure data in HubSpot to power CS automation: * **Overdue account alerts**: Trigger tasks or workflows when invoices become overdue, enabling proactive outreach before accounts fall further behind * **Renewal workflows**: Automatically create deals or tasks based on upcoming subscription renewals * **Health scoring**: Incorporate payment history and invoice status into customer health scores * **Revenue reporting**: Build reports combining CRM pipeline data with actual invoiced and collected revenue from Measure for more accurate forecasting # Ingest usage events Source: https://docs.getmeasure.com/pages/guides/ingest_usage_events # Ingest Usage Events post [https://api.getmeasure.com/api/v1/companies/\{company\_id}/events/ingest](https://api.getmeasure.com/api/v1/companies/\{company_id}/events/ingest) Send bulk billable usage events for metrics calculation # Overview Source: https://docs.getmeasure.com/pages/guides/introduction # Welcome to Measure Measure is an end-to-end revenue management platform that enables workflows for engineering, product, sales and finance teams. Measure is designed to be highly available, accurate and flexible for any kind of billing capabilities that your application may need. At a high level, integrating with Measure involves the following steps * Setting up your product catalog and pricing plans * Setting up customers and subscriptions through the API, contracts, checkout links or directly through Measure * Ingesting events or syncing objects for usage-based or seat-based billing * Configuring invoicing and payments to enable Measure to automatically generate and charge your customers To get started with your integration, reach out to us at [hello@getmeasure.com](mailto:hello@getmeasure.com) for an account. Once you have an account, you can manage billing for your application either directly though the Measure dashboard or through the [Measure REST API](/pages/guides/create_customer). Please refer to the guides in the following sections to get started. # Invoicing Source: https://docs.getmeasure.com/pages/guides/invoicing Measure automates the invoice creation and payment tracking process for recurring subscription or one-time charges. Invoices typically include the product or service purchased, the price, any applicable taxes or fees, and payment terms. Invoices are used to track sales, ensure payment, and provide documentation for accounting purposes. Measure also tracks the payment status of each invoice, providing real-time visibility into payment history and outstanding balances. If a payment is missed, Measure can automatically send payment reminders to the customer, reducing the need for manual follow-up. Measure invoices can be accessed from the dashboard or the API. ### Lifecycle Measure invoices start out in `PENDING` status and then transition to `PAID` status on successful complete payment. When subscriptions are paused, invoices can be generated in `VOID` status or `DRAFT` status. ### Billing Cadence Measure provides the flexibility to bill for different line items on an invoice either in advance (pre-billing) or in arrears (post-billing). This allows you to combine fixed recurring fees and variable usage charges on a single invoice. * **Billing in Advance (Pre-billing):** Charges are invoiced at the *start* of a billing period for services that will be provided during that period. This is ideal for recurring platform fees, seat licenses, and other predictable costs. * **Billing in Arrears (Post-billing):** Charges are invoiced at the *end* of a billing period based on consumption during that period. This is essential for metered, usage-based items. For example, a customer on a monthly plan could receive a single invoice on May 1st that includes: * A recurring platform fee for the month of May (billed in advance). * Usage charges based on consumption during the month of April (billed in arrears). ### Minimum Commitments Measure allows you to set minimum spending commitments on subscriptions. This guarantees a minimum revenue amount per billing period, regardless of the customer's actual usage. If a customer's usage-based charges are less than the minimum commitment, they are billed the minimum amount. If their usage exceeds the minimum, they are billed for their actual usage. This is particularly useful for: * Ensuring predictable revenue from usage-based plans. * Covering the base costs of providing a service. For example, if you set a minimum commitment of \$100 per month: * If the customer's usage totals $60, they will be invoiced for $100. * If their usage totals $150, they will be invoiced for $150. ### Grace Period Measure enables customization of the time window in which invoices are finalized after the billing period. This is particularly for usage-based billing where there might be a lag in events being pushed to Measure. For example, if a billing period ends on April 30th, you can set a 3-day grace period. This ensures that any usage events that occurred in April but are received by Measure up to May 3rd are included in the April invoice before it is finalized. ### Taxes Standard taxes for invoices can be set at a company level or be overridden at the customer level. Automatic tax collection can also be enabled with third-party integrations. For example, you can set a default 5% GST for all Canadian customers at the company level, but override it for a specific tax-exempt customer by setting their tax rate to 0%. ### Metadata and Additional Fields Metadata on invoices for internal purposes or additional fields can be set on a per-invoice basis or can be set at the company level to display on every invoice. This is typically used for standard properties like tax registration numbers. For example, you can add a `vat_id: "2342342"` key-value pair to an invoice's metadata to track the VAT ID for the customer. ### Branding Measure allows you to customize invoices with your own branding to provide a consistent and professional experience for your customers. You can configure your company logo and messaging, which will automatically appear on all invoices sent from Measure, whether they are delivered via email or through a hosted payment link. ### Credit Notes A credit note can be used to decrease the amount due or provide a credit for an already issued invoice. This is typically done when there are duplicate or fraudulent charges on an invoice. Credit notes will also handle any tax associated with an invoice that included tax. Tax will be calculated when the credit note is issued. Once a credit note is issued, the adjusted amount due is available on the invoice. Click here to learn more about [using Credit Notes](/pages/guides/credit-notes) in Measure. # Usage-Based Billing Source: https://docs.getmeasure.com/pages/guides/kickstart-usage-based-billing Measure enables ingestion of events to dynamically calculate customer usage-based metrics in just a few steps. Usage-based events can be triggered based on user activity or usage of a resource provided by your application. Once you have covered the basics in [Basic API Guide](/pages/guides/quickstart-with-measure-api) and have an API token ready to go, you can kickstart usage-based billing in Measure. ### Setup a billable item Billable items in Measure help track distinct entities for which you would like to track usage in your application. For example, this could be "API Calls". ### Setup a billable metric The billable metric helps Measure determine what logic to apply when aggregating events on the billable item set up above. For example, a billable metric could be a "Count" of "API Calls" with some filtering on arbitrary properties you can send in such as `type`. ### Setup pricing for the billable items and overall plan You can set up a price for each metric type. For instance, in the following example, you can set up multiple prices based on the event type. Once you have set up each individual prices based on event type, you can group them into a plan that is exposed to your customers. The resulting API call plan will look as follows ### Setup a customer and subscription for usage tracking Send a POST request to the [Customers](/api-references/customers/create-customer) endpoint with the following parameters. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/my_company_id/customers \ --header 'accept: application/json' \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "email": "[email protected]", "name": "Hello Person", "org_name": "Hello Co.", "phone": "444-4444-4444", "identifier": "your_customer_db_id" } ' ``` Start a subscription for the customer based on the API Pricing Plan set up above ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/my_company_id/subscriptions \ --header 'accept: application/json' \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "auto_charges": true, "auto_renews": true, "product_pricing_ids": [ "product_pricing_id_from_previous_step" ], "customer_id": "customer_id_from_previous_step", "term": { "count": 1, "frequency": "YEAR" }, "config_items": [ { "num_licenses": 1 } ] } ' ``` ### Start tracking dynamic usage with the events ingest endpoint Once the customer and the subscription are set up, you can start tracking usage-events for different types of API calls as and when they happen in your application. Based on the metric we set up earlier, we would be counting API calls for each model type and charging them at a different rate. The billable event takes in a unique customer identifier that maps back to your application along with properties for any metadata that will eventually be used for creating billable metrics. For example, you can use Measure to count the number of API calls made by your customer. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/events/ingest \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "events": [ { "customer_id": "customer_id_from_previous_step", "customer_identifier": "your_customer_db_id", "transaction_id": "111-111-111", "timestamp": "2024-04-09T21:21:21+00:00", "item_id": "measure_api_calls_item_id", "properties": { "time_used": 10, "type": "model1" } } ] } ' ``` The `transaction_id` serves as an idempotency key for your events. Any events with the same `transaction_id` received within a 24 hour window for a customer will not be counted multiple times. The `item_id` is the unique identifier for the billable item in Measure that these events are logged against. In the above example, the `item_id` refers to a billable item for API calls. As events are sent to Measure, billable metrics are evaluated and leveraged towards billing the customer based on their subscription and pricing plan. ### Review the customer's usage on their next invoice in real-time You can track live usage metrics on the customer's next invoice from the customer's subscription page. ### Retrieving usage through the API Total usage aggregation for the customer can be retrieved with the [Get Subscription Usage](/api-references/subscriptions/get-subscription-usage) API. The results of the call can be used to display the usage for each period for the customer in your application. ### Viewing Billable Events on the Measure dashboard You can easily audit all your billable events and troubleshoot any issues with your usage-based billing plans by going **Developers** > **Events** to see all your billable events sent to Measure. Clicking on an event will show you all the relevant event details. You can **filter the events** for a given time period. You can also **export the filtered results** or export all events. # Credits, Discounts and Promotions Source: https://docs.getmeasure.com/pages/guides/managing-credits-discounts-and-promotions Measure enables management of credits, discounts and promotions with a high degree of flexibility. These levers can be used to increase customer satisfaction and boost sales. ## Credits Measure allows you to provide credits to your customers that they can use towards future purchases. These credits can be given as a reward for loyalty or as compensation for issues or mistakes. These can be easily managed and tracked though the Measure dashboard. Credits can be issued in terms of amounts that can be used by an expiration date or units of a particular item that is billed on an invoice. Credits can also be conferred through product pricing plans that a customer may purchase. Credits can be conferred at a customer level and also at a subscription level and they have different implications. ### **Customer-Level Credits** Unit credits or amount credits can be applied at a customer-level. Unit credits are always applied pre-tax and amount credits at the customer-level are applied post-tax. ### **Subscription-Level Credits** Unit credits or amount credits can be scoped at the subscription-level as well. This ensures that credits only apply to that subscription. These credits (both unit and amount) are applied pre-tax. If there are multiple credits on a customer-level or subscription-level, credits that have an expiration date always take preference in the application order. Otherwise the oldest created credit gets used up first. Also unit credits are always consumed first before amount credits in general. Refer to the [Credits-Based Billing](/pages/guides/credits-based-billing) for more details. ## Discounts Measure enables you to create customized discounts based on specific products, plans, or even item prices that are used to bill usage on an invoice. These discounts can be percentage-based or amount-based with or without an expiration date. These discounts can be auto created on contract or subscription creation as well. ## Coupons and Promo Codes Measure enables you to create coupons and run promotional campaigns that can help you attract and retain customers. Coupons and promo codes can be used flexibly create either credits or discounts for customers. These can be scoped to specific products, plans, billable items or item pricing. These can also be automatically enabled on payment links for smooth checkout experiences. # Products and Pricing Source: https://docs.getmeasure.com/pages/guides/managing-products-pricing-and-packaging Pricing can be easily set up through the Measure dashboard. This helps you think holistically about your pricing strategy. Once prices and components are set up, they can be referenced through the relevant IDs through the API to provision subscriptions. Measure provides several flexible pricing capabilities, designed to accommodate a wide range of pricing and packaging options that your application may need. For instance, Measure can easily support the following plan structures * Multi-phased plans with different discounts at every phase \_ Minimum pre-paid seats and overage calculations * Usage-based with minimum spend commitments * Periodic true-ups on seats and renewals at desired frequencies * Prorated billing * Multi currency support * Multiple billing frequencies within a single plan (ex. annual plan with monthly overages) * Pre-purchased credits To make these pricing structures work, Measure offers the following pricing concepts For the simplest way to get started with with Measure, you'll need to set up a "Product" and a "Product Pricing". ### Products Products represent a service a customer can buy. Products can have several corresponding product pricing plans. These plans can be recurring for a subscription or one-time prices such as an installation or setup fee. To create a product in the dashboard, navigate to Products > Overview and click the "Create Product" button. Also add relevant tax code information if you have enabled Measure to collect taxes on invoices. ### Product Pricing This represents a plan for a product. A product may have several options for pricing based on different currencies or billable metrics. Product prices can be recurring (for subscriptions) or one-time charges such as a setup/implementation fee or credit units for any billable item in your application. To add a product pricing, click on "Add New Pricing" under the specific product and follow the steps to add prices for components of the plan. #### Billable Items and Item Pricing **Billable Items** are the items you charge for and the **Item Price** represents the price of the item used for billable metrics. For example, **"API calls" for an API product** or **"Minutes" on a cell phone plan** are Billable Items. Item Pricing captures the "per unit price" of an item that can be tracked in the following ways * Fixed pricing to charge the same price for each unit consumed * Step pricing to charge a fixed price to a range of units * Gradient pricing or volume pricing to charge based on a tier of prices * Custom pricing to charge based on customer input Billable items in the system can have various item pricing attached to them and can be used within any product pricing plan. #### Multi-Item Plans You can also create multi-item plans using other billable items in your application. The product pricing can also be composed of multiple billable items and metrics tagged with an item price. The addition of new prices is typically useful for creating custom plans for specific customers. ### Product Metric Pricing The plan for a product can be composed of several billable metrics. For example, a product pricing can include monthly charges for "API calls" at 10c a call along with a yearly licensing fee. The product metric pricing ties the item pricing to the overall product pricing. ### Bundles Customers can subscribe to multiple product pricing plans under a single subscription. You can also create pre-set groupings of product plans together. For instance, you could combine a phone plan along with a TV-plan and internet-plan under the same subscriber. # MCP Server Source: https://docs.getmeasure.com/pages/guides/mcp MCP (Model Context Protocol) servers enable AI assistants like Claude to interact directly with the Measure API. With an MCP server, you can manage customers, subscriptions, invoices, and billing operations through natural language conversations with your AI assistant. ## Official MCP Server The Measure MCP server lets you interact with the Measure API through any MCP-compatible AI client (Claude Code, Cursor, etc.) using natural language. Under the hood it proxies your requests to the same Measure REST API, so all existing permissions and rate limits apply. ### Prerequisites * An active Measure account * An MCP-compatible client (see [Supported Clients](#supported-clients)) If connecting via **API key** (Claude Code, Cursor, or other clients): * A Measure API key — generate one from **Developers > API Tokens** in the Measure dashboard. **Note**: Anyone with access to the API token will be able to perform all actions via the Public APIs or MCP tools. * Your company ID — found in **Developers > API Tokens** in the Measure dashboard ### Connection Details | Property | Value | | --------------------------- | -------------------------------- | | Server URL | `https://mcp.getmeasure.com/mcp` | | Transport | Streamable HTTP | | `MEASURE_API_TOKEN` header | Your Measure API key | | `MEASURE_COMPANY_ID` header | Your Measure company ID | ### Supported Clients #### Claude.ai Measure is available in the Claude Connectors marketplace. If you're on a Claude Team or Enterprise account and Measure doesn't appear, your Claude admin may need to enable connector access first. **Step 1 — Find Measure** In Claude Desktop or Claude.ai, navigate to **Connectors** in the left sidebar and use the search bar to find **Measure**. Connectors list **Step 2 — Connect** Click **Measure** to open its detail panel, then click **Connect**. This launches the Measure authorization flow in your browser. **Step 3 — Authorize access** Select the Measure organization you want to connect, then click **Allow** to grant Claude read access to your account data. You'll be redirected back to Claude.ai when done. Authorization prompt **Step 4 — Configure tool permissions (optional)** Once connected you'll see a **"Connected to Measure"** confirmation and a list of available tools for Claude to use. You can control how Claude uses each tool with the permission toggle: | Setting | Behavior | | ------------------ | ----------------------------------- | | **Always allow** | Claude uses the tool automatically | | **Ask every time** | Claude asks before running the tool | | **Never** | The tool is disabled | **Can't find the Measure connector?** If Measure doesn't appear in your list, use the **+** button to add it manually: 1. Enter a **Name** (e.g. `Measure`) and **Remote MCP server URL**: `https://mcp.getmeasure.com/mcp` 2. Expand **Advanced settings** and enter **OAuth Client ID**: `claude-measure-mcp` 3. Click **Add** Add custom connector modal *** #### Claude Code Run the following command in your terminal: ```bash theme={null} claude mcp add --transport http measure https://mcp.getmeasure.com/mcp \ --header "MEASURE_API_TOKEN:" \ --header "MEASURE_COMPANY_ID:" ``` The server will be available in all Claude Code sessions immediately. *** #### Cursor 1. Open **Cursor Settings → MCP**. 2. Click **Add new global MCP server** and paste: ```json theme={null} { "measure": { "type": "http", "url": "https://mcp.getmeasure.com/mcp", "headers": { "MEASURE_API_TOKEN": "", "MEASURE_COMPANY_ID": "" } } } ``` 3. Save and reload the window. *** #### Other MCP Clients Any client that supports the [MCP Streamable HTTP transport](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) can connect using: * **Endpoint:** `https://mcp.getmeasure.com/mcp` * **`MEASURE_API_TOKEN` header:** your Measure API key * **`MEASURE_COMPANY_ID` header:** your Measure company ID *** ### Example prompts Once connected, you can ask Claude things like: * "Show me all overdue invoices from this month" * "Find all active subscriptions for Acme Corp" * "Which customers have the highest MRR?" * "List contracts expiring in the next 90 days" ### Troubleshooting **Measure doesn't appear in my connector list** On Claude Team or Enterprise accounts, your Claude admin may need to enable third-party connectors. Ask them to enable the Measure connector for your organization. Alternatively, use the **+** button to add it manually as described above. **Authorization failed or redirected incorrectly** Make sure you're logged into the correct Measure account in your browser before clicking Connect, and that you have permission to authorize third-party integrations in that Measure organization. *** ### Giving your AI assistant context For best results, load the [Measure data model reference](https://docs.getmeasure.com/pages/guides/ai-context) into your AI assistant's context before starting a session. It explains how BillableItems, ProductPricings, BundlePricings, Subscriptions, and Customers relate to each other - which helps the assistant form correct queries and avoid common mistakes. In Claude Code, you can do this with: ``` fetch https://docs.getmeasure.com/pages/guides/ai-context ``` Or add it to your project's `CLAUDE.md`: ```markdown theme={null} For Measure API context, see: https://docs.getmeasure.com/pages/guides/ai-context ``` ## Available Tools ### Read-Only Tools | Tool | Description | | ------------------------------------------- | ------------------------------------------------------------------------------------------ | | `find_billable_items` | Search billable items by name, external name, or state | | `find_billable_metrics` | Search billable metrics by name, item, or state | | `find_bundles` | Search bundles by name or state | | `find_contracts` | Search contracts by customer, status, type, etc. | | `find_credit_logs` | Search credit logs by customer, invoice, action type, etc. | | `find_credits` | Search credits by customer, status, type, currency, etc. | | `find_customers` | Search customers by name, email, MRR, ARR, tags, etc. | | `find_entitlements` | Search entitlements by name, key, or type | | `find_invoices` | Search invoices by customer, status, date range, amount, etc. | | `find_objects` | Search billable objects by customer or item | | `find_one-time_charges` | Search one-time charges by customer, state, or type | | `find_payment_transactions` | Search payment transactions by customer, invoice, status, etc. | | `find_product_pricing` | Search product pricing by name, currency, type, tags, etc. | | `find_products` | Search products by name, state, or tags | | `find_subscriptions` | Search subscriptions by customer, status, MRR, dates, etc. | | `get_bundle` | Retrieve a bundle by ID | | `get_contract` | Retrieve a contract by ID | | `get_credit` | Retrieve a credit by ID | | `get_customer` | Retrieve a customer by ID or external identifier | | `get_entitlement` | Retrieve an entitlement by ID | | `get_invoice` | Retrieve an invoice by UUID | | `get_invoice_link` | Generate an authenticated link to an invoice | | `get_payment_methods` | Get all payment methods for a customer | | `get_product` | Retrieve a product by ID or external identifier | | `get_product_pricing` | Retrieve product pricing by ID or external identifier | | `get_subscription` | Retrieve a subscription by ID or external identifier | | `get_subscription_usage` | Retrieve the subscription usage by ID for a specific metric | | `get_subscription_usage_for_current_period` | Retrieve the usage for the current period of the subscription for a specific billable item | | `next_invoice` | Preview the upcoming invoice for a subscription (supports change/cancel simulation) | ### Write Tools Write tools make real changes to your data. Always review what Claude intends to do before confirming, and be especially careful with bulk operations. | Tool | Description | | -------------------------- | --------------------------------------------------------------------------------------------------- | | `cancel_subscription` | Cancel a subscription by ID with the provided cancellation options | | `change_subscription` | Change a subscription by ID with the provided plan details | | `create_credit` | Create a credit with given parameters | | `create_one-time_charges` | Create one-time charges with given parameters | | `extend_trial_end_date` | Update the end of the trial for the subscription | | `finalize_draft_invoice` | Finalize a draft invoice by UUID | | `generate_invoice_pdf` | Generate the invoice as a PDF file | | `generate_next_invoice` | Generate the next invoice for the subscription immediately (asynchronous) | | `mark_invoice_as_paid` | Mark an invoice as paid by UUID | | `revoke_credit` | Revoke a credit by ID | | `start_managing_customer` | Start managing a customer in Measure that was previously managed externally | | `undo_cancel_subscription` | Undo an upcoming cancellation on a subscription (does not revive an already cancelled subscription) | | `update_customer` | Update a customer by ID or external identifier | | `void_invoice` | Void an invoice by UUID | ## Building your own MCP server In the meantime, you can build a custom MCP server using our [OpenAPI specification](https://api.getmeasure.com/api/v1/docs/api_spec.json). The OpenAPI spec provides a complete definition of all Measure API endpoints, making it straightforward to generate an MCP server that works with any AI assistant that supports the Model Context Protocol. ### Options for building There are several approaches you can take to build an MCP server for Measure: **1. Generate with AI assistants** You can use Claude or other AI assistants to automatically generate an MCP server from the Measure OpenAPI specification. Simply provide the specification and ask the AI assistant to create an MCP server implementation in your preferred language. **2. Use MCP SDKs** The [Anthropic MCP SDK](https://github.com/anthropics/mcp) provides tools and libraries for building MCP servers in TypeScript and Python. You can use these SDKs to create a custom server that wraps the Measure API. **3. Use OpenAPI-to-MCP conversion tools** Several community tools can automatically convert OpenAPI specifications into MCP servers, allowing you to generate a working server with minimal effort. ### Setting up your MCP server To build and configure your own MCP server: 1. Download the [Measure OpenAPI specification](https://api.getmeasure.com/api/v1/docs/api_spec.json) 2. Create an [API token](/pages/guides/quickstart-with-api) from the Measure dashboard under **Developers > API Token** 3. Use your preferred method to generate the MCP server from the OpenAPI specification 4. Configure the server with your API token for authentication Your API token should be kept secret and secure. Anyone with access to your token will be able to access Measure resources on your behalf. Once your MCP server is configured and running, you can connect it to AI assistants like Claude to interact with Measure through natural language. You'll be able to perform operations like creating customers, managing subscriptions, generating invoices, processing payments, and more. ### Important considerations for bulk operations **Exercise caution with bulk write operations.** When using an MCP server with AI assistants, it's easy to execute bulk operations through natural language commands. However, certain actions (such as canceling multiple subscriptions, deleting customers, or applying changes to large sets of records) can be irreversible and may have significant business impact. We recommend: * Always review bulk operations before confirming execution * Test bulk operations with a small subset of data first * Be explicit about which customers or subscriptions should be affected * Consider the downstream effects of bulk changes (e.g., invoice generation, payment processing) * Maintain backups or records of data before performing bulk modifications Some operations that require extra care include: * **Bulk subscription cancellations**: Canceling multiple subscriptions at once will immediately stop billing for those customers * **Bulk pricing changes**: Changing pricing for multiple subscriptions simultaneously will affect future invoices * **Bulk refunds**: Processing refunds in bulk will immediately credit customer accounts and impact your revenue * **Bulk status changes**: Changing subscription or customer status in bulk can affect access to your services Always confirm the scope and impact of bulk operations before proceeding. When in doubt, perform operations one at a time or on a small test set first. ### What you can do with an MCP server With a Measure MCP server connected to your AI assistant, you can perform operations such as: * Create and manage customers * Set up and modify subscriptions * Generate and send one-off invoices * Process payments and refunds * Manage products, pricing, and plans * Handle credits, discounts, and promotions The MCP server provides a conversational interface to the full Measure API, allowing you to manage your billing operations through natural language interactions. # Minimizing payment failures Source: https://docs.getmeasure.com/pages/guides/minimizing-payment-failures # Multiple Signatories and Counter Signatories Source: https://docs.getmeasure.com/pages/guides/multiple-and-counter-signatures Measure Contracts offer flexible signature options providing full control over the approval process. Whether you need buy-in from multiple decision makers on the customer side or require internal approval before sending to customers, Measure supports complex signature workflows. **Signature Options**: * Up to 3 external signatures from the customer organization * Optional counter-signatures from internal signatories * Any combination of multiple signatories and counter-signatories The same template can contain both "multiple" and "counter" signatory variables, allowing for complex approval chains. ## Use Cases for Multi-Signature **Enterprise sales**: Large deals often require sign-off from multiple stakeholders (CFO, legal, department heads) before commitment. **Internal approval**: Require internal company review and sign-off from your team (manager, legal, finance) before the contract is sent to customers. **Joint agreements**: Partnerships or affiliate agreements that require signatures from multiple organizations. ### Multiple Signatories **Dynamic signatory management**: Multi-signatory contracts automatically adapt based on the selected template, displaying the appropriate number of signatory fields to match template requirements. **Comprehensive signatory information**: Each signatory can be configured with complete details including name, title, and email information for proper contract execution and communication. **Template-driven workflow**: The signatory section dynamically adjusts to show the exact number of signature fields defined in the selected template, ensuring consistency across contract types. ### Counter Signatories **Internal approval integration**: Counter-signatory functionality enables internal company approval workflows by allowing selection of any Measure user as an internal signatory. **User-friendly selection**: Counter-signatory templates provide dropdown selection from your company's Measure users, streamlining the internal approval assignment process. **Flexible approval workflows**: Templates can be configured to require counter-signatures for contracts that need internal sign-off before customer execution. ### Notes * Signatures can be collected in any order but all must be collected for the contract to be considered fully executed * **Any of the external signatories can provide payment information** if collection of payment information is required * **If none of the signatories are the payer**, the signatories can share the payment link with the payer after signing the contract # NetSuite Source: https://docs.getmeasure.com/pages/guides/netsuite Measure can export invoices and payments in a CSV format that is ready to import directly into NetSuite. This is useful if you manage your accounting in NetSuite but do not have a live API integration. You can export from Measure on a schedule and import the file into NetSuite using its standard CSV import tool. ## Invoice Line Items Export The invoice line items export produces one row per line item, with invoice-level fields repeated on each row. This maps directly to NetSuite's **Invoice** import record type. | Column | Description | | ---------------------------------------- | -------------------------------------------------------------------------- | | **External ID** | The Measure invoice ID, used as the NetSuite external ID for deduplication | | **Invoice Number** | The invoice number from Measure | | **Invoice Date** | Invoice date formatted as `YYYY-MM-DD` | | **Due Date** | Payment due date formatted as `YYYY-MM-DD` | | **Status** | NetSuite-compatible status (see mapping below) | | **Currency** | Full currency name (e.g. `US Dollar`, `CA Dollar`) | | **Customer** | Customer display name | | **Customer Email** | Primary email address on the customer record | | **Billing Address 1–2** | Street address lines | | **Billing City / State / Zip / Country** | Billing address fields | | **Item** | Product name | | **Item Description** | Line item description | | **Quantity** | Line item quantity | | **Unit Price** | Price per unit | | **Amount** | Total line amount | | **Tax Rate** | Applicable tax rate | | **Tax Amount** | Total tax charged on the line | | **Memo** | Invoice notes | | **Service Start Date** | Service period start formatted as `YYYY-MM-DD` | | **Service End Date** | Service period end formatted as `YYYY-MM-DD` | ### Invoice Status Mapping Measure invoice statuses are mapped to the closest equivalent NetSuite status: | Measure Status | NetSuite Status | | ------------------ | ---------------- | | Draft | Pending Approval | | Void | Pending Approval | | Pending | Open | | Overdue | Open | | Uncollectible | Open | | Payment Processing | Open | | Paid | Paid In Full | ## Payments Export The payments export produces one row per payment transaction. This maps to NetSuite's **Customer Payment** import record type. | Column | Description | | ------------------------- | ------------------------------------------------------------ | | **Invoice Number** | The invoice number the payment applies to | | **Customer ID** | The Measure customer identifier | | **Invoice Payment** | Payment amount | | **Payment Date** | Date the payment was initiated, formatted as `YYYY-MM-DD` | | **Payment Captured Date** | Date the payment was captured, formatted as `YYYY-MM-DD` | | **Payment Currency** | Full currency name (e.g. `US Dollar`, `CA Dollar`) | | **Payment Amount** | Payment amount (same as Invoice Payment) | | **Payment Method** | Payment provider or method (e.g. `STRIPE`, `WIRE`, `CHEQUE`) | | **Payment ID** | The Measure payment transaction ID | # Numeral Source: https://docs.getmeasure.com/pages/guides/numeral Numeral calculates taxes on Measure invoices in real-time and handles the full sales tax compliance lifecycle — from nexus monitoring and registration through filing and remittance. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product tax category * **Product tax mapping**: Map Measure products to Numeral tax categories to ensure correct tax treatment across jurisdictions * **Filing & remittance**: Numeral prepares and submits state returns on your behalf with an on-time filing guarantee * **Nexus monitoring**: Tracks your transaction volume against economic nexus thresholds and alerts when registration is required * **Automatic registration**: Handles state registrations when you cross a nexus threshold * **Exemption certificate management**: Manages customer exemption certificates and applies them automatically * **Global coverage**: Supports US sales tax across all states and VAT in 80+ countries * **Government correspondence**: Handles state and local tax notices via virtual mailboxes on your behalf ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the line items and customer address to Numeral, which returns the applicable tax amounts based on your product mappings and the customer's location. The calculated tax is committed as a recorded sale in Numeral once the invoice is finalized, and reversed automatically when a refund or credit note is issued. A complete customer billing address is required for tax calculation. Invoices without a valid address will not have tax applied. ## Configuration Connect Measure to Numeral using your Numeral API key. Once connected, map each Measure product to a Numeral tax category to ensure accurate treatment. ## Product Tax Categories | Category | Numeral Code | When to use | | ------------------------- | ----------------------------- | ---------------------------------------------------- | | SaaS General | `SAAS_GENERAL` | General-purpose SaaS products sold to all customers | | SaaS General B2B | `SAAS_GENERAL_B2B` | SaaS products sold exclusively to businesses | | Software B2B | `SOFTWARE_B2B` | Downloadable or licensed software sold to businesses | | Software B2B License | `SOFTWARE_B2B_LICENSE` | Perpetual software licenses sold to businesses | | SaaS With Download (Used) | `SAAS_WITH_DOWNLOAD_USED` | SaaS that includes a downloadable component | | Data Processing | `DATA_PROCESSING` | Data processing or analytics services | | Consulting Services | `CONSULTING_SERVICES_GENERAL` | Professional or consulting services | | Non-Taxable | `NON_TAXABLE` | Products that are not subject to sales tax | | Exempt | `EXEMPT` | Products sold to tax-exempt customers | Every product must have a mapping before invoices can be taxed. Unmapped products will cause tax calculation to be skipped for that line item. # Payment, Checkout and Contract Links Source: https://docs.getmeasure.com/pages/guides/optimizing-checkout-with-payment-links Measure enables you quickly sign up customers on a plan with standard payment links, customer specific checkout sessions or contract signature workflows. ## Payment Links Payment links are a hosted links that provide a convenient and simple way for your customers to sign up for any product plan or one-time payment fee via your linked payment provider. These reusable links can be shared with your customers via email, messaging apps, or social media. Measure enables the setup of payment links for product pricing through the dashboard and the API. There are several options provided by payment links * Email verification - to ensure that customers provide a verified email as they sign up for your product * Promotion codes – to enable coupons for the payment flow through promo codes * Required customer fields - to ensure customer phone or address fields are populated * Save card on checkout - to ensure future customer charges are seamless * Confirmation page - to customize the messaging upon completion of the flow * Redirect URL - to redirect the flow to your application after the checkout flow is completed. The redirect URL includes query parameters for the customer ID created on Measure. When a customer clicks on the payment link, they will be redirected to a payment page where they can enter their payment information. Once the payment is processed, the customer will be redirected to Measure and a subscription with the product pricing is created. To create a payment link, go to Products > Payment Links and hit Create Payment Link You can configure your payment link settings based on the product pricing and then expose this within your application. ## Checkout Sessions While the standard payment links serve as a template for a standard plan purchases (say from your website), the Measure API also supports creation of a customer-specific checkout session links that enable you to dynamically build cart-like checkout for any arbitrary list of product plans. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/checkout \ --header 'accept: application/json' \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "customer_id": "cus_2YdAsQWuTtz2LQh3pjDpj6uwYTI", "type":"CHECKOUT_SESSION", "term": { "frequency": "MONTH", "count": 1 }, "currency": "USD", "product_pricing_ids": ["plan_2QAjNCQN2iEJHWV12IfUIhHjHfd"], "config_items": [ { "num_licenses": 1 } ] } ' ``` While this endpoint is primarily designed for initiating new subscriptions, it can also be utilized to modify existing subscriptions by configuring specific parameters. To update an existing subscription using the checkout session, you can set parameters such as proration mechanism, resetting the billing anchor or timing for the change. By configuring these parameters appropriately, you can effectively use the checkout session to upgrade or downgrade a customer's existing subscription, adjust billing cycles, and manage proration behavior. This approach provides flexibility in handling subscription modifications directly through the checkout process. For more detailed information and examples, please refer the [Checkout API](/api-references/checkout/create-checkout-session). ## Contract Links Measure also enables the creation of checkout flows with contract signatures enabled. The customer checking out is considered to be the signatory on the contract and can sign the document with an in-built flow with Dropbox Sign by default. For more details for creating contract links, refer to our [Contracts API](/api-references/contracts/create-contract). # Pagination Source: https://docs.getmeasure.com/pages/guides/pagination The Measure API offers several list and search APIs that have a common structure that contains the requested list in a `results` response object along with metadata that is useful for pagination in the `pagination` response object that also contains the `from_key` as the cursor that is customized based on the resource being requested. All paginated calls require a `limit` field with a maximum upper bound of 100 items per request. They also require a `sort_key` to determine the desired sort order for objects returned. For example, a typical expectation is that `results` are returned in reverse chronological order by using the `createdAtDesc` option. ```json theme={null} { "results": [ { "id": "vE1zSWtFGL", "created_at": "2023-03-15T10:49:03.461-04:00", ... } ... ], "pagination": { "from_key": "2023-03-15T12:54:17.533Z", "limit": 100 } } ``` # Parent-Child Billing Source: https://docs.getmeasure.com/pages/guides/parent-billing Measure supports hierarchical accounts to enable parent-child billing relationships, a comprehensive solution designed to manage complex billing structures within large organizations or reseller models. This feature allows you to link customer accounts together, designating one as the parent and others as children, which is ideal for scenarios like corporate hierarchies, franchises, or partners who manage billing for their end-customers. ## Flexible Billing Models Measure's parent-child billing is designed for flexibility, supporting various billing arrangements to suit your business needs. ### Centralized Billing to the Parent In this model, all invoices for child accounts are automatically deferred to the parent account for payment. This centralizes billing and simplifies payment management for the end customer. For instance, a university's IT department might pay for software used by various academic departments, even if each department manages its own subscription. ### Direct Billing to the Child Alternatively, you can have each child account manage its own billing and payment methods. The parent account retains visibility into the child's subscriptions and invoices, providing a complete overview without handling the payments directly. For instance, a franchise headquarters may want to monitor the spending and subscriptions of individual franchisee locations, while each location pays its own bills. ### Mixed-Mode Billing For the ultimate flexibility, Measure supports a mixed-mode setup. In this arrangement, a parent account can have some children defer their billing to the parent, while other children manage and pay their own invoices directly. ## Centralized Management and Invoicing Parent-child billing enhances administrative efficiency by providing a unified view of all related accounts. The parent account dashboard lists all associated children, along with their active subscriptions and invoices. For even greater simplicity, Measure can consolidate all child invoices into a single **rollup invoice** for the parent. These rollup invoices can be generated at any desired frequency (e.g., monthly, quarterly) and can include parent-specific charges, credits, and discounts. Our system accurately handles complex tax calculations based on both parent and child jurisdictions and generates separate invoices for each currency if multiple are involved. The entire hierarchical account structure, including assigning parents and configuring billing behavior, can be managed through both the Measure dashboard and our comprehensive API. # Payment Recovery Source: https://docs.getmeasure.com/pages/guides/payment-recovery Measure helps you fight involuntary churn by intelligently handling failed payments and delinquencies. Our automated dunning and payment recovery tools maximize revenue recovery by automating payment retries and proactively notifying customers about expiring payment methods. ### Failed Payment Retries Payment failures are not uncommon and can occur for a variety of reasons. If a payment for an auto-charge invoice fails, Measure's smart retry system automatically attempts to collect the payment again based on a configurable schedule. You can design a multi-step recovery workflow that escalates over time. For example, you can configure Measure to: * Retry the payment and email the customer 1 day after a failure. * Retry again and send another email 7 days later. * Notify the internal account owner after 14 days of non-payment. * Automatically cancel the subscription after 28 days of failed attempts. ### Unpaid Invoice Reminders For invoices that are past due, Measure can send automated dunning messages at regular intervals. You can use one of our pre-configured schedules (Basic, Lenient, or Persistent) or create a custom schedule to match your business's communication style. You can also enable continuous reminders that are sent on a recurring cadence until the invoice is paid. ### Credit Card Expiry Notifications To prevent future payment failures, Measure can automatically send notifications to customers before their credit card on file expires. This proactive communication prompts them to update their payment information, ensuring a seamless continuation of service and preventing churn due to outdated card details. # Payment Security Source: https://docs.getmeasure.com/pages/guides/payment-security-for-customers Measure processes payments through secure, PCI-compliant payment providers. Payment information is protected by industry-standard security controls and encryption. This page covers how payment data is stored, what information is accessible, and the security standards Measure follows. Payment data is processed by payment providers like [Stripe](https://stripe.com), which is used by Amazon, Google, Shopify, and millions of businesses globally. Measure does not store card numbers, CVV codes, or bank account numbers. ## Payment Data Storage Payment data is transmitted directly to the payment processor's servers. Card numbers, CVV codes, and bank account numbers are stored by the payment processor in PCI-compliant vaults. Measure stores secure tokens that reference the payment methods without containing sensitive data. Payment processors maintain PCI-DSS Level 1 certification. Only the last 4 digits, expiration date, and payment method type are visible to Measure and the business. [Learn more about Stripe's security](https://docs.stripe.com/security). ## Payment Link Security Payment and invoice links are protected with authentication tokens that expire after a period of time. Email verification may be required to access invoice links, ensuring only authorized recipients can view and pay invoices. ## Bank Account Connections Bank account connections for reconciliation are processed through [Plaid](https://plaid.com/). Bank login credentials are not stored or accessible to Measure or the business. Account information is stored by the payment processor. Only the last 4 digits of the account number are visible to the business. ## Data Visibility Businesses using Measure can access customer name and email, payment amounts and dates, last 4 digits of payment methods, and payment status. Businesses cannot access full bank account or card numbers, bank login credentials, or card CVV codes. ## Security Standards * **PCI-DSS Level 1**: Payment methods stored in the payment processor's PCI-compliant vault * **SOC 2 Type 2**: Measure is independently audited for security controls. [View Trust Page](https://app.sprinto.com/trust-center/view/7fb3cc8f-f37b-4ad6-8335-223c07e28bba) ## Support For any security concerns, email [support@getmeasure.com](mailto:support@getmeasure.com). ## Additional Resources * [Stripe Security & Compliance](https://docs.stripe.com/security) * [Measure Trust Center](https://app.sprinto.com/trust-center/view/7fb3cc8f-f37b-4ad6-8335-223c07e28bba) * [Plaid Security](https://plaid.com/safety/) * [Privacy Policy](/pages/guides/privacy-policy) # Payments and Refunds Source: https://docs.getmeasure.com/pages/guides/payments-and-refunds Measure provides a comprehensive payment processing system that automates collecting payments, tracking transactions, and handling refunds. This gives you a centralized view of your cash flow and simplifies financial operations. From the Measure dashboard, you can access a detailed overview of all payments, including high-level aggregations and powerful filtering options. This allows you to easily track payments by status, currency, payment provider, and transaction type. You can also choose to show or hide Stripe Connect transactions. ### Automated and Manual Payments Measure integrates with a variety of third-party payment providers to automate payment collection and refunds. When a payment is processed through an integrated provider, the transaction is automatically logged in Measure and associated with the correct invoice, triggering the appropriate status changes. For a complete list of supported payment providers, please see our [Integrations section](/guides/setting-up-integrations). For payments collected outside of our automated system (such as wire transfers, ACH, or checks), Measure allows you to manually record the payment and mark the corresponding invoice as paid. This ensures that your financial records in Measure remain accurate and up-to-date, regardless of how the payment was received. ## Refunds Measure simplifies the process of issuing refunds for payments. You can issue full or partial refunds directly from the payment transaction details in the Measure dashboard. When a refund is processed through an integrated payment provider, Measure automatically handles the transaction and updates the associated invoice and credit note records. For manual payments, you can log the refund to maintain accurate accounting. You can also issue credits to a customer's account, which can be automatically applied to future invoices. To learn more, see our guide on [Credit Notes](/guides/credit-notes). # Pipedrive Source: https://docs.getmeasure.com/pages/guides/pipedrive Pipedrive integration connects your CRM to Measure, enabling contract creation from Pipedrive deals and syncing customer and contract data between systems. ## Key Capabilities * **Contract creation from deals**: Create contracts directly from the Pipedrive deals interface * **Contract status visibility**: View contract statuses within Pipedrive deals * **Customer data sync**: Keep customer information synchronized between Pipedrive and Measure ## Data Synchronization Control how data flows between Pipedrive and Measure: * **Action mapping**: Define what happens in Pipedrive when actions occur in Measure (and vice versa), with configurable source of truth * **Field mapping**: Map customer and contract fields between systems # Plaid Source: https://docs.getmeasure.com/pages/guides/plaid Plaid connects your bank account to Measure, enabling [Bank Reconciliation](/guides/bank-reconciliation) to match incoming wire transfers, ACH payments, and checks to outstanding invoices. ## Key Capabilities * **Automatic transaction sync**: Bank transactions are pulled daily, keeping your payment data current * **Multi-account support**: Connect multiple bank accounts and manage reconciliation across all of them * **Matching suggestions**: Measure suggests invoice matches based on amount, reference numbers, and customer name See [Bank Reconciliation](/pages/guides/bank-reconciliation) for details on matching payments to invoices. ## Bank Coverage Plaid supports thousands of financial institutions across the US and Canada: * Major national banks * Regional and community banks * Credit unions * Online banks and neobanks ## Security * **Read-only access**: Measure cannot initiate transactions or modify your accounts * **No credential storage**: Authentication happens directly with your bank via Plaid * **SOC 2 Type II certified**: Bank-level encryption for all data # Postmark Source: https://docs.getmeasure.com/pages/guides/postmark Postmark integration enables you to send customer emails from your own domain, giving you control over deliverability and brand consistency. Route invoices, payment receipts, and contract notifications through your Postmark account. ## Key Capabilities * **Custom domain sending**: Send emails from your verified domain instead of Measure's default * **Improved deliverability**: Leverage your domain's reputation and Postmark's delivery infrastructure * **Email tracking**: Track deliveries, opens, clicks, and bounces for all customer communications * **Consistent branding**: Maintain your brand identity across all customer touchpoints ## Email Types All customer-facing emails from Measure can be routed through Postmark: * **Invoice emails**: Invoice delivery and payment reminders * **Payment receipts**: Confirmation emails for successful payments * **Contract notifications**: Signature requests and contract status updates ## Tracking and Analytics With webhook integration, Measure tracks email engagement: | Event | Description | | ------------------ | ----------------------------------------- | | **Delivered** | Email successfully delivered to recipient | | **Opened** | Recipient opened the email | | **Clicked** | Recipient clicked a link in the email | | **Bounced** | Email could not be delivered | | **Spam Complaint** | Recipient marked email as spam | Email status is visible on invoice and contract records, helping you understand customer engagement and troubleshoot delivery issues. ## Requirements * Verified domain or sender signature in Postmark * Postmark Server API token # Phased Billing Source: https://docs.getmeasure.com/pages/guides/pricing-phases Pricing phases in Measure allow you to create dynamic subscription pricing that evolves over the lifecycle of a customer. This powerful feature enables you to implement various pricing strategies, such as introductory offers, promotional discounts that expire, or planned price increases, without manual intervention. ### What are Pricing Phases? A pricing phase is a defined period within a subscription's term that has a specific pricing structure. You can chain multiple phases together to create a subscription that automatically transitions from one price point to another. This is particularly useful for multi-year enterprise contracts with planned price adjustments. For example, consider a three-year contract where the price per license and the discount change each year: * **Phase 1 (Year 1):** \$20 per license per month, with a 20% discount. * **Phase 2 (Year 2):** \$40 per license per month, with a 15% discount. * **Phase 3 (Year 3):** \$60 per license per month, with a 10% discount. This entire sequence is configured once when creating a contract. Measure handles the transitions automatically at the end of each billing period, ensuring a seamless and predictable billing cycle. ### Common Use Cases * **Ramped Deals:** For enterprise customers, you can structure deals that ramp up over time (e.g., Year 1 at price X, Year 2 at price Y) and automate the price adjustments. * **Introductory Pricing:** Attract new customers by offering a lower price for an initial period before automatically moving them to your standard plan. * **Promotional Campaigns:** Run a marketing campaign with a special discount that automatically expires after a set duration. * **Ending a Trial:** Seamlessly convert a customer from a free trial to a paid plan by scheduling a change at the end of the trial period. By using pricing phases, you can build more flexible and automated billing models that cater to your business needs and go-to-market strategies. # Privacy Policy Source: https://docs.getmeasure.com/pages/guides/privacy-policy # QuickBooks Source: https://docs.getmeasure.com/pages/guides/quickbooks QuickBooks Online integration syncs invoices, credit notes, and payments from Measure to keep your accounting records up to date. ## Key Capabilities * **Invoice sync**: Automatically sync invoices, credit notes, and payments from Measure to QuickBooks * **Customer mapping**: Map customer records between Measure and QuickBooks * **Product mapping**: Map Measure products and pricing plans to QuickBooks items for accurate revenue reporting * **Tax rate mapping**: Map Measure tax rates to QuickBooks for accurate tax calculations ## Data Synchronization The integration is a one-way sync from Measure to QuickBooks Online. Measure remains the source of truth for billing data, and QuickBooks reflects your invoicing operations. Data syncs automatically at regular intervals. You can also trigger a manual sync from the Measure dashboard. # No-Code Quickstart Source: https://docs.getmeasure.com/pages/guides/quickstart Get to your first subscription or one-time invoice in minutes using the Measure dashboard, with no code required. Get to your first subscription or one-time invoice in minutes. This guide uses only the Measure dashboard, with no code required. **New to Measure?** Read [Core Concepts](/pages/guides/core-concepts) first for an overview of key terms and entities. For a deeper billing integration via the API, see the [API Quickstart](/pages/guides/quickstart-with-measure-api). **Measure dashboard**: [app.getmeasure.com](https://app.getmeasure.com) Build your product and pricing catalog in Measure. Go to the Measure dashboard → **Products** → **Overview** → **Add New Product**. Products overview with Add New Product button Under the new product, click **Add New Product Pricing** to create a plan. Add New Product Pricing dialog You can add multiple recurring pricing components under a single plan at different billing frequencies with multi-item pricing. For advanced pricing, see [Setting up billable metrics](/pages/guides/setting-up-billable-metrics). Connect a payment provider so Measure can charge invoices. Go to **Integrations** and click **Connect** on Stripe (or another supported provider). Complete the connection flow to link your account. Integrations page with Stripe Connect option Create a customer, then attach a subscription to start billing. Go to **Customers** → **Create Customer**, add the customer details, and click **Add Customer**. If you use a CRM integrated with Measure (see [Sales and CRM integrations](/pages/guides/sales-and-crm-integrations)), you can go to **Subscriptions** → **Create New Subscription** and select the customer from your CRM. Go to **Subscriptions** → **Create New Subscription**, choose the customer, and click **Create Subscription**. Create New Subscription form Select your plan (e.g., **Basic Plan**). Use **Advanced Options** for an end date, manual billing, or net terms. Plan selection and Advanced Options The new subscription appears under the customer. Customer subscription view When the subscription is created, the first invoice is generated and you get a preview of the next invoice. First invoice and next invoice preview If the customer has a payment method on file and the subscription is set to auto-charge, the invoice is charged and marked as paid automatically. In **manual invoicing** mode, the invoice stays open for you to share with the customer for payment. Manual invoice in the dashboard You now have a live subscription, an issued invoice, and (with auto-charge) a completed payment. For more, see [Invoicing](/pages/guides/invoicing). ## Next Steps Create customers, subscriptions, and invoices via the Measure API Create, edit, and issue invoices and credit notes Set up usage-based and object-based billing Review key entities and workflows in Measure # API Quickstart Source: https://docs.getmeasure.com/pages/guides/quickstart-with-api For detailed documentation on the Measure API, please review our [API Reference](/pages/guides/authentication) Create an API token from the Measure dasboard under **Developers > API Token**. The generated token will only be visible to you once. Once created, you cannot retrieve or update the same API token again. Make sure to be save the token in a secure manner Below is an example to create a customer using the [Create Customer API](/api-references/customers/create-customer) ```bash theme={null} curl --request request \ --url https://api.getmeasure.com/api/v1/companies//customers \ --header 'accept: application/json' \ --header 'authorization: Bearer ' \ --header 'content-type: application/json' \ --data ' { "email": "[email protected]", "name": "Hello Person", "org_name": "Hello Co.", "phone": "444-4444-4444", "title": "Director of Operations", "identifier": "external_customer_id" }' ``` Copy the customer `id` from the response. You can verify that the customer was created using the dashboard or calling the [Get Customer](/api-references/customers/get-customer) or [Find Customer](/api-references/customers/find-customers) API. Go to the Measure dashboard and navigate to **Products > Overview** and click on the **'Add New Product'** button. You can achieve this through the API as well, if needed. Under the new product, click on 'Add New Product Pricing' to create a plan. You can achieve this with the API as well, if needed. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies//subscriptions \ --header 'accept: application/json' \ --header 'authorization: Bearer ' \ --header 'content-type: application/json' \ --data ' { "auto_charges": true, "auto_renews": true, "currency": "USD", "product_pricing_ids": [ "plan_2ZC39unZNwxsOzvE8K8YRZ6FMBF" ], "customer_id": "cus_2ZC4MvcO47Iog1PYRZRGHDL90Vu", "term": { "count": 3, "frequency": "MONTH" }, "config_items": [ { "num_licenses": 1 } ] } ' ``` You can verify that the first invoice was generated in the UI or using the [Invoice Find](/api-references/invoices/find-invoices) API. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/invoices/find \ --header 'accept: application/json' \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "pagination": { "limit": 10 }, "query": { "customer_id": "cus_2ZC4MvcO47Iog1PYRZRGHDL90Vu" }, "sort_key": "createdAtDesc" } ' ``` # Rate Limits Source: https://docs.getmeasure.com/pages/guides/rate-limits Our API uses rate limiting to ensure stability and prevent abuse of the platform. The rate limit across our endpoints depends on your plan with Measure, with higher rates supported for usage events ingestion and credits consumption at scale. Please chat with our team at [support@getmeasure.com](mailto:support@getmeasure.com) for specific rate limits on these endpoints for your account. We may occasionally reduce the rate limit as part of incident response to protect our other systems. This means that you should be prepared to receive `429` responses specific to rate limiting and handle it appropriately in your application, even if you do not intend to hit the limits. # Razorpay Source: https://docs.getmeasure.com/pages/guides/razorpay We are constantly adding more support for payment providers for specific locales. Razorpay is a payment solution that works well in Asian countries like India. This feature is in beta. Please reach out to us to enable this on your account. ## Setup Under Integrations > Available Apps, select Razorpay Once you click install, enter your API key # Amazon Redshift Source: https://docs.getmeasure.com/pages/guides/redshift Amazon Redshift integration enables you to export billing and subscription data to your Redshift data warehouse for advanced analytics, reporting, and integration with your broader data infrastructure. ## Key Capabilities * **Automated sync**: Billing data automatically syncs to your Redshift cluster on a regular basis * **Complete data export**: Export customers, subscriptions, invoices, payments, prices, credits, discounts and contracts * **Schema management**: Measure manages table schemas and handles schema evolution as new fields are added * **S3 staging support**: Optionally use an S3 bucket as a staging area for bulk loads to improve performance * **SSH tunnel support**: Connect to Redshift clusters in private VPCs via an SSH tunnel ## Available Data Export comprehensive billing data to Redshift: | Table | Description | | ----------------------------------- | ---------------------------------------------------- | | **Customers** | Customer records with metadata and custom fields | | **Products and Prices** | Product catalog and pricing plans | | **Subscriptions** | Active and historical subscription data | | **Contracts** | Contract records with terms and status | | **Credits and Discounts** | Applied credits and discount configurations | | **Invoices and Invoice Line Items** | Invoice records with detailed line items and status | | **Payments** | Payment transactions, refunds, failures, and retries | Each dataset is modeled with stable primary keys and foreign-key relationships so you can confidently join across objects and time. ## Setup To connect Redshift, you will need: * **Host**: Your Redshift cluster endpoint * **Port**: The port your cluster is listening on (default: 5439) * **Database**: The target database name * **Schema**: The schema where Measure will create tables * **Username / Password**: Credentials with permission to create and write tables ### Optional: S3 Staging For improved load performance, you can provide an S3 bucket for staging data before it is bulk-loaded into Redshift: * **S3 Bucket Name** and **Region** * **AWS Access Key ID** and **Secret Access Key** * Optionally, an **S3 Bucket Path** prefix ### Optional: SSH Tunnel If your Redshift cluster is in a private VPC, Measure can connect through an SSH bastion host: * **SSH Host**, **Port**, and **Username** * **SSH Private Key** (PEM format) ## Use Cases * **Revenue analytics**: Build custom dashboards combining billing data with product and marketing data * **Financial reporting**: Feed billing data into finance and FP\&A reporting tools * **Customer health scoring**: Combine billing metrics with product usage for customer health analysis * **Data warehousing**: Centralize billing data alongside other business data for unified analytics # Idempotency Source: https://docs.getmeasure.com/pages/guides/request-idempotency The Measure API supports idempotency for safe retries of the same requests without causing unintended consequences. This feature is particularly useful in cases where network issues or system failures can cause duplicate API requests to be sent to the server. This helps provide improved reliability, better user experiences and simplified error handling in your application. ## Requests To use the API idempotency feature, you must first generate a unique identifier to be used as the idempotency key. The keys themselves can be arbitrary strings with a max length of 64 characters. We recommend the use of UUIDs In order to generate a fully unique keys. This identifier must be included in your request as the `Idempotency-Key` header. Although the idempotency key is not required, it is strongly recommended for all `POST` or `PATCH` requests. Sending idempotency keys in `GET` or `DELETE` requests has no effect as these requests are idempotent by definition. The server will then use this identifier to ensure that the same request is not executed multiple times. Measure's idempotency works by saving the resulting status code and body of the first request made for any given idempotency key, regardless of whether it succeedes or fails. Subsequent requests with the same key return the same result, including 400 and 500 errors. Once the API request is received by the server, the server will check if the identifier is valid and has not been used before. If the identifier is valid and has not been used before, the server will process the request and mark the identifier as used. If the identifier is not valid or has been used before, the server will ignore the request and return the response from the previous request. You can safely retry requests that include an idempotency key within 24 hours. Once the key expires, Measure will execute those requests again. For example, you can use an idempotency header to prevent duplication while creating customers in Measure. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/customers \ --header 'accept: application/json' \ --header 'content-type: application/json' --header 'Idempotency-Key: a5a9d072-16a2-4204-a14b-aa2fda1928bd' \ ``` ## Responses Any request that is performed with an idempotency key will include an `Idempotency-Key` header in the response to ensure that there is clarity on the key being used. Measure will also include `Idempotency-Used: true` in the response to show that a previous response is being replayed. # Resend Source: https://docs.getmeasure.com/pages/guides/resend Resend integration enables you to send customer emails from your own domain, giving you control over deliverability and brand consistency. Route invoices, payment receipts, and contract notifications through your Resend account. ## Key Capabilities * **Custom domain sending**: Send emails from your verified domain instead of Measure's default * **Improved deliverability**: Leverage your domain's reputation and Resend's delivery infrastructure * **Email tracking**: Track deliveries, opens, clicks, and bounces for all customer communications * **Consistent branding**: Maintain your brand identity across all customer touchpoints ## Email Types All customer-facing emails from Measure can be routed through Resend: * **Invoice emails**: Invoice delivery and payment reminders * **Payment receipts**: Confirmation emails for successful payments * **Contract notifications**: Signature requests and contract status updates ## Tracking and Analytics With webhook integration, Measure tracks email engagement: | Event | Description | | -------------- | ----------------------------------------- | | **Delivered** | Email successfully delivered to recipient | | **Opened** | Recipient opened the email | | **Clicked** | Recipient clicked a link in the email | | **Bounced** | Email could not be delivered | | **Complained** | Recipient marked email as spam | Email status is visible on invoice and contract records, helping you understand customer engagement and troubleshoot delivery issues. ## Requirements * Verified domain in Resend * Resend API key # Revenue Recognition Source: https://docs.getmeasure.com/pages/guides/revenue-recognition Measure automatically generates revenue recognition schedules from your subscriptions and invoices, ensuring your financial reporting stays compliant with ASC 606 and IFRS 15 standards without manual spreadsheet work. ## Automated Recognition Schedules Recognition schedules are created automatically when subscriptions are activated or invoices are finalized. Each line item generates its own schedule based on service period and billing terms. Annual contracts paid upfront spread revenue across 12 months, while monthly subscriptions recognize in the period billed. When subscriptions change (upgrades, downgrades, cancellations, or amendments), schedules adjust automatically. Remaining deferred revenue is recalculated and future periods updated to reflect new terms. ## Billing and Recognition Integration Every subscription links directly to its recognition schedule, providing complete traceability. Signed contracts flow into subscriptions, which create recognition schedules. The entire revenue lifecycle is connected without manual data entry. ## Revenue Recognition Reports Measure provides purpose-built reports for revenue recognition, designed for both operational visibility and accounting system integration. ### Journal Reports Generate month-end journal entries ready for your general ledger. Journal reports aggregate recognition activity by customer, product, and invoice with debit and credit entries formatted for direct GL import. * **Configurable grouping**: View journals grouped by customer, product or revenue account * **Period flexibility**: Generate reports for any date range with daily, weekly, or monthly granularity ### Deferred Revenue Reports Monitor your deferred revenue balance with real-time visibility into future recognition. The deferred revenue waterfall shows how today's liability will convert to recognized revenue over upcoming periods. * **Waterfall projections**: See expected recognition amounts for each future month * **Customer-level detail**: Break down deferred revenue by customer to understand concentration * **Product analysis**: Identify which products contribute most to deferred revenue balances ### Accounting System Integration Export recognition data directly to your accounting platform. Measure formats exports to match the import requirements of major accounting systems. * **QuickBooks and Xero**: Pre-formatted exports with account mapping * **Automated sync (coming soon)**: Schedule recurring exports to keep your GL up to date ## Revenue Adjustments Handle complex scenarios that require manual intervention while maintaining audit trails. **Contract modifications**: When contracts are amended mid-term, Measure recalculates recognition schedules and generates adjustment entries to true-up previously recognized amounts. **Credit notes and refunds**: Credits issued against invoices automatically generate reversal entries in the recognition schedule, reducing both recognized and deferred revenue appropriately. **Discount allocation**: Product-level discounts net against line items directly. Invoice-level discounts are allocated proportionally across line items based on standalone selling prices, maintaining compliance for bundled pricing. # Rillet Source: https://docs.getmeasure.com/pages/guides/rillet Rillet integration syncs invoices, payments, credit notes, and customer records from Measure into Rillet's AI-native ERP, keeping your accounting records automatically up to date. ## Key Capabilities * **Invoice sync**: Automatically push finalized invoices to Rillet using revenue-recognition mode * **Payment sync**: Record payments against invoices in Rillet, including processing-fee journal entries and clearing-to-bank sweeps * **Credit note sync**: Push credit notes and refunds to Rillet as credit memos, linked to the originating invoice where possible * **Customer sync**: Create and update customer records in Rillet, with optional billing address * **Multi-entity support**: Select a specific Rillet subsidiary to sync into during setup * **Sandbox mode**: Test your configuration against Rillet's sandbox environment before going live ## Data Synchronization The integration is a one-way sync from Measure to Rillet. Measure remains the source of truth for billing data, and Rillet reflects your invoicing and payment operations. Data syncs automatically at regular intervals. You can also trigger a manual sync from the Measure dashboard. ### What Gets Synced | Entity | Behavior | | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Customers** | Created or updated in Rillet; matched by email or name on initial sync | | **Invoices** | Created in Rillet using revenue-recognition mode; voided invoices are offset with a full-amount credit memo | | **Payments** | Recorded against the matching Rillet invoice; processing fees post as a separate journal entry; net amount sweeps to the deposit bank account if configured | | **Refunds** | Posted as standalone credit memos in Rillet | | **Credit Notes** | Posted as credit memos linked to the originating invoice; falls back to standalone if the invoice is already closed | ## Considerations * **Currency**: Rillet syncs invoices in the subsidiary's home currency only; invoices in other currencies are skipped with an explanatory sync log * **Customers without names**: Customers with no name in Measure are skipped and logged * **Invoice updates**: Rillet invoices are immutable after creation; updates to invoice data in Measure do not propagate to Rillet * **Rate limits**: The integration respects Rillet's rate limit of 60 requests per minute # Sales Commissions Source: https://docs.getmeasure.com/pages/guides/sales-commissions This feature is currently in beta. Please reach out to us to enable this on your account. Measure automates sales compensation calculations using your existing contract and payment data. Commissions calculate and post automatically when deals close, with support for tiered rates, accelerators, and bonuses across new business, renewals, and expansion deals. Key capabilities include flexible timing (calculate at signature or payment), automatic clawback management for churn and failed payments, and real-time visibility for sales reps as deals progress. # Salesforce Source: https://docs.getmeasure.com/pages/guides/salesforce Salesforce integration connects your CRM opportunities to Measure contracts, enabling sales teams to create and track contracts directly from Salesforce. ## Key Capabilities * **Contract creation from opportunities**: Launch Measure contract creation directly from Salesforce opportunity pages via custom buttons * **Two-way sync**: Keep customer and opportunity data synchronized between Salesforce and Measure * **Contract status visibility**: Track contract progress, signature status, and payment collection from within Salesforce * **Price catalog sync**: Push your Measure product catalog to Salesforce for use in opportunity workflows ## Data Synchronization Configure how data flows between Salesforce and Measure: **Action mapping**: Define what happens in Salesforce when actions occur in Measure. Automate status updates, field changes, and notifications based on contract events. **Field mapping**: Map customer and contract fields between systems to ensure data consistency. Support for standard and custom fields. ## Sales Workflow The Salesforce integration streamlines the quote-to-cash process: 1. Sales rep works an opportunity in Salesforce 2. When ready, launches Measure contract creation from the opportunity page 3. Contract status updates sync back to Salesforce automatically 4. Opportunity closes when contract is signed and payment is collected ## Price Catalog Products and pricing plans created in Measure sync to Salesforce. Your sales team can access the full pricing model within Salesforce while Measure remains the source of truth. For complex pricing models (e.g., gradient pricing), pricing details are added to the description field in Salesforce. ## Custom Objects Measure pushes custom objects to Salesforce for subscriptions and invoices, giving your team full visibility into billing data within the CRM. **Subscription objects**: View active subscriptions, plan details, billing frequency, and renewal dates directly on account and opportunity records. Track subscription changes over time without switching between systems. **Invoice objects**: Access invoice status, amounts, due dates, and payment history from within Salesforce. Identify overdue invoices and outstanding balances at a glance. ## Customer Success Workflows Use Measure data in Salesforce to power CS automation: * **Overdue account alerts**: Trigger tasks or notifications when invoices become overdue, enabling proactive outreach before accounts fall further behind * **Renewal workflows**: Automatically create renewal opportunities based on subscription end dates * **Health scoring**: Incorporate payment history and invoice status into customer health scores * **Revenue reporting**: Build reports combining CRM pipeline data with actual invoiced and collected revenue from Measure for more accurate forecasting # SDKs Source: https://docs.getmeasure.com/pages/guides/sdks Our language specific SDKs are under way, but in the meantime our [REST API](https://api.getmeasure.com/api/v1/docs/api_spec.json) adheres to [OpenAPI specifications](https://swagger.io/specification/). The OpenAPI spec can be used to generate an SDK in your language of choice. For example, [https://openapi-generator.tech/](https://openapi-generator.tech/), [https://openapi-ts.dev/introduction](https://openapi-ts.dev/introduction) (for Typescript). # Overview Source: https://docs.getmeasure.com/pages/guides/security Measure has industry-standard security controls and constantly monitor our security policies to ensure we are compliant. We follow and promote the following security best-practices in our product by deeply adhering to standardized compliance governance standards such as SOC 2 Type 2 and building feature capabilities that enable users to require the minimum necessary permissions to fulfill their tasks. # SendGrid Source: https://docs.getmeasure.com/pages/guides/sendgrid SendGrid integration enables you to send customer emails from your own domain, giving you control over deliverability and brand consistency. Route invoices, payment receipts, and contract notifications through your SendGrid account. ## Key Capabilities * **Custom domain sending**: Send emails from your verified domain instead of Measure's default * **Improved deliverability**: Leverage your domain's reputation and SendGrid's delivery infrastructure * **Email tracking**: Track opens, clicks, bounces, and spam reports for all customer communications * **Consistent branding**: Maintain your brand identity across all customer touchpoints ## Email Types All customer-facing emails from Measure can be routed through SendGrid: * **Invoice emails**: Invoice delivery and payment reminders * **Payment receipts**: Confirmation emails for successful payments * **Contract notifications**: Signature requests and contract status updates ## Tracking and Analytics With webhook integration, Measure tracks email engagement: | Event | Description | | --------------- | ----------------------------------------- | | **Delivered** | Email successfully delivered to recipient | | **Opened** | Recipient opened the email | | **Clicked** | Recipient clicked a link in the email | | **Bounced** | Email could not be delivered | | **Spam Report** | Recipient marked email as spam | Email status is visible on invoice and contract records, helping you understand customer engagement and troubleshoot delivery issues. ## Requirements * Verified domain or sender signature in SendGrid * SendGrid API key with Mail Send and Tracking permissions # Billable Items and Metrics Source: https://docs.getmeasure.com/pages/guides/setting-up-billable-metrics Billable items are the core unit for charging a customer through Measure. This typically is a standard license, a usage based item such as API calls or an object such as user seats. Billable items can be set up through the Measure dashboard. Measure provisions "License" items by default. For usage-based and object-based items, a billable metric needs to be defined before setting up pricing. ## Setting up a Billable Item Measure supports metering of more transient usage-based items or more persistent object-based items in your product. Measure manages these two concepts distinctly because they made a difference when tracking MRR for your business. Revenue generated through object-based items (such as seats deployed) count towards recurring revenue while revenue generated through usage-based items (such as API calls) do not unless there are a minimum set of pre-purchased items. With both events and objects synced into Measure, you can set up billable metrics that can be aggregated over metadata captured in the `properties` field. ## Metrics Billable metrics are composed of filters and aggregation clauses. Think of these as `WHERE` and `GROUP BY` SQL clauses respectively. For example, you can create a billable metric for the `COUNT()` of API calls based on the following usage based event ```json theme={null} { "company_id": "...", "identifier": "...", "transaction_id": "...", "timestamp": "...", "item_id": "api_call_item_id", "properties": { "route": "/plans" } } ``` Other aggregators leverage a property to aggregate over. Measure supports the following aggregators for usage-based events * `COUNT()` to count the number of events that meet the filter constraints * `MAX(property)` to get the maximum value of the property for events that meet the filter constraints * `SUM(property)` to get the sum of the property for the events that meet the filter constraints * `UNIQUE(property)`to get the count of the number of unique values for the property for events that meet the filter constraints * `AVG(property)` to get the average of the property for the events that meet the filter constraints * `Unique Count(property)` to get the unique count of the property for the events that meet the filter constraints * `Last Reported In Period(property)` to get the last reported value of the property in a time period for the events that meet the filter constraints * `Last Reported In History(property)` to get the last reported value of the property for the events that meet the filter constraints * `Historical Sum(property)` to get the historical sum of the property for the events that meet the filter constraints Measure also supports additional filtering and group by capabilities on metrics as well. ### Metrics in Product Pricing One or more metrics can then be added to a single product pricing as separately priced components. This allows you to offer plans that contain components of different billing types. For example, you can configure the plan to contain both metrics if you wish to offer a plan that is * seat-based at \$100/mo/user, and * has a reporting feature that is charged by usage (\$2/per report generation) # Overview Source: https://docs.getmeasure.com/pages/guides/setting-up-integrations Measure as a core revenue management platform is designed to seamlessly integrate with several third-party applications to streamline your workflows and automate tasks across multiple platforms. With our robust integrations, you can save time and increase productivity by automating repetitive tasks, syncing data between applications, and more. Measure supports integrations for engineering, product, sales, and revenue teams which includes CRMs, payment providers, e-signature platforms, accounting platforms, tax management platforms and BI tools via data pipelines. To get started with our standard integrations, simply navigate to the Integrations tab in the Measure dashboard. From there, you can choose which third-party software tools you would like to integrate with and follow the step-by-step instructions to set up the integration. ## Custom Integrations with Webhooks Measure also enables custom integrations with your application via webhooks. [Webhooks](/pages/guides/webhooks) enable callbacks to be triggered by specific events, such as a new customer or subscription creation, invoice generation or a successful payment confirmation. # Slack Source: https://docs.getmeasure.com/pages/guides/slack-notifications Slack integration sends real-time notifications to your channels for revenue events like payments, contracts, and subscription changes. ## Key Capabilities * **Contract notifications**: Get notified when contracts are signed or fully executed * **Invoice notifications**: Track paid invoices and failed payment recovery * **Payment notifications**: Alert on failed payments * **Subscription notifications**: Monitor subscription creation, updates, cancellations, and usage threshold breaches ## Custom Rules Configure notification rules with matching conditions: * Customer name * Customer MRR * Invoice amount * Subscription MRR * Other custom fields This ensures you only receive notifications for scenarios you want to monitor. # Snowflake Source: https://docs.getmeasure.com/pages/guides/snowflake Snowflake integration enables you to export billing and subscription data to your Snowflake data warehouse for advanced analytics, reporting, and integration with your broader data infrastructure. ## Key Capabilities * **Automated daily sync**: Billing data automatically syncs to your Snowflake warehouse on a daily basis * **Complete data export**: Export customers, subscriptions, invoices, payments, prices, credits, discounts and contracts * **Schema management**: Measure manages table schemas and handles schema evolution as new fields are added ## Available Data Export comprehensive billing data to Snowflake: | Table | Description | | ----------------------------------- | ---------------------------------------------------- | | **Customers** | Customer records with metadata and custom fields | | **Products and Prices** | Product catalog and pricing plans | | **Subscriptions** | Active and historical subscription data | | **Contracts** | Contract records with terms and status | | **Credits and Discounts** | Applied credits and discount configurations | | **Invoices and Invoice Line Items** | Invoice records with detailed line items and status | | **Payments** | Payment transactions, refunds, failures, and retries | Each dataset is modeled with stable primary keys and foreign-key relationships so you can confidently join across objects and time. ## Use Cases * **Revenue analytics**: Build custom dashboards combining billing data with product and marketing data * **Financial reporting**: Feed billing data into finance and FP\&A reporting tools * **Customer health scoring**: Combine billing metrics with product usage for customer health analysis * **Data warehousing**: Centralize billing data alongside other business data for unified analytics # SOC 2 Compliance Source: https://docs.getmeasure.com/pages/guides/soc-2-compliance Measure is designed for correctness and security in alignment with industry best practices, at scale. With **SOC 2 Type 2** compliance, our customers are ensured an enhanced level of trust in our platform. SOC 2 (System and Organization Controls 2) is a rigorous framework developed by the American Institute of Certified Public Accountants (AICPA). It focuses on the security, availability, processing integrity, confidentiality, and privacy of customer data within a service organization. SOC 2 has two types, Type 1 and Type 2. * **Type 1** evaluates the design of system controls at a point in time. * **Type 2** certification goes a step further by assessing how well these controls are implemented over a specified period, typically a minimum of six months. Please refer to our detailed [trust page](https://app.sprinto.com/trust-center/view/7fb3cc8f-f37b-4ad6-8335-223c07e28bba). If you are interested in retrieving our SOC 2 Type 2 Compliance Report, please reach out to us at [support@getmeasure.com](mailto:support@getmeasure.com). # Sphere Source: https://docs.getmeasure.com/pages/guides/sphere Sphere calculates taxes on Measure invoices in real-time based on your nexus registrations and customer location. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product type * **Product tax mapping**: Map Measure products to Sphere tax codes to ensure correct tax treatment * **Nexus threshold tracking**: Monitor transaction volume against economic nexus thresholds in each jurisdiction * **Flexible control**: Enable or disable tax calculation at the integration level ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the transaction details to Sphere, which returns the applicable tax amounts based on your product mappings and the customer's location. ## Configuration Connect Measure to Sphere using API key authentication. Once connected, map your Measure products to Sphere tax codes to ensure accurate tax treatment. # Square Source: https://docs.getmeasure.com/pages/guides/square Measure integrates directly with Square to power secure, flexible online payment processing for your business. Square is a trusted name in payment processing, known for its ease of use, fast setup, and strong security. With support for a wide range of online payment methods and no long-term contracts, Square is an ideal choice for businesses looking to start accepting payments quickly without added complexity. This integration is great for digital-first businesses that want simple, developer-friendly billing with a reliable and well-supported payment processor. This feature is in beta. Please reach out to us to enable this on your account. # Stripe Source: https://docs.getmeasure.com/pages/guides/stripe Stripe integration enables automated payment collection, secure payment method storage, and subscription migration from Stripe Billing to Measure. ## Key Capabilities * **Automated payment collection**: Invoices and contracts configured for automatic payment charge the customer's stored payment method automatically * **Secure payment storage**: Payment methods are stored in Stripe's PCI-compliant vault, keeping sensitive card data off your servers * **Multiple payment methods**: Support for cards, ACH, and other payment methods available through Stripe * **Test mode support**: Connect in test mode to validate your payment workflows before going live ## Payment Processing When payment collection is enabled, Measure automatically charges customers based on your invoice and contract settings: * **Invoice payments**: Charge payment methods on file when invoices are finalized * **Contract payments**: Collect payment as part of the contract signing workflow * **Failed payment handling**: Integrate with Measure's [payment recovery](/pages/guides/payment-recovery) workflows for failed charges ## Stripe Tax Measure integrates with Stripe Tax for automated tax calculation. See [Stripe Tax](/pages/guides/stripe-tax) for details. ## Migration from Stripe Billing Measure provides migration tools to transition existing subscriptions from Stripe Billing. Import your customers, subscriptions, and payment methods to continue billing without disruption. See [Data Import and Migration](/pages/guides/data-import-and-migration) for migration details. # Stripe Tax Source: https://docs.getmeasure.com/pages/guides/stripe-tax Stripe Tax calculates taxes on Measure invoices in real-time based on your nexus registrations and customer location. Ideal if you already use Stripe as your payment processor. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product type * **Product tax mapping**: Map Measure products to Stripe tax codes to ensure correct tax treatment * **Nexus threshold tracking**: Monitor transaction volume against economic nexus thresholds in each jurisdiction * **Unified platform**: Manage payments and tax through your existing Stripe dashboard ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the transaction details to Stripe Tax, which returns the applicable tax amounts based on your product mappings and the customer's location. ## Unified Payment and Tax If you use Stripe as your payment processor, Stripe Tax provides a natural extension of your existing infrastructure. Both payments and tax calculations flow through your Stripe integration, reducing complexity and keeping your financial data in one place. # Subprocessors Source: https://docs.getmeasure.com/pages/guides/subprocessors Measure uses range of third-party services to power our infrastructure, customer support and development processes to help us deliver reliable, secure services. Last updated March 2026. We periodically review our subprocessors and third parties to validate their security and compliance policies, and our use of them in order to provide services. ## Infrastructure subprocessors The following entities act as infrastructure providers as well as processors of data. Depending on your use of Measure, data you provide to us may be shared with some or all them but only in the context of fulfilling the services you ask us to provide. | Entity Name | Location | Purpose | | ------------- | ------------ | --------------------------------- | | Amazon | US | Cloud hosting | | Cloudflare | Global (CDN) | Content delivery network provider | | Render | US | Website hosting services | | Sentry | US | Error reporting | | Datadog | US | App logging | | Dropbox Sign | US | Compliant electronic signatures | | Postmark | US | Product email notifications | | Stripe | US/EU | Payment services provider | | Square | US | Payment services provider | | Authorize.net | US | Payment services provider | | Razorpay | India | Payment services provider | | Helcim | Canada | Payment services provider | | Attio | US/EU | CRM integration | | Pipedrive | US/EU | CRM integration | | Salesforce | US/EU | CRM integration | | HubSpot | US/EU | CRM integration | | Quickbooks | US/Canada/EU | Payment services provider | | Xero | US/Canada/EU | Payment services provider | | Avalara | US/EU | Tax services provider | | TaxJar | US | Tax services provider | | Resend | US | Email service provider | | SendGrid | US | Email service provider | | Slack | US/EU | Communications service provider | ## Customer support and development subprocessors The following entities enable us to build product, provide support and increase brand presence for our prospects and customers. | Entity Name | Location | Purpose | | ---------------- | -------- | -------------------------------------------- | | Google Workspace | US | Email and cloud storage of documents | | Github | US | Source code control and versioning | | Notion | US | Project management and internal documents | | Dropbox Sign | US | Electronic signatures | | Front App | US | Support and tickets management | | Pipedrive | EU | CRM | | Render | US | Website hosting services | | Slack | US | Internal communications and customer support | | Pagerduty | US | Engineering alerting and error reporting | | Zenduty | US | Engineering alerting and error reporting | | MailChimp | US | Customer communications | | Mintlify | US | Public documentation and policies | | LinkedIn | US | Customer case studies, marketing | | Figma | US | Design and prototyping | | Zapier | US | Workflow automation | | Clay | US | GTM data enrichment | | Fathom | US | AI meeting notes | | Anthropic | US | AI-assisted GTM workflows | # Subscriptions Source: https://docs.getmeasure.com/pages/guides/subscriptions Subscriptions are the core recurring billing mechanism supported by Measure. They map a customer to a group of product pricing plans that are billed at a cadence. Subscriptions can be created both through the API as well as in the Measure dashboard. Product prices that are attached to subscriptions must have at least one recurring charge. One-time prices can be added on creation as well. ```json theme={null} { "id": "subs_xyz", "company_id": "cmp_xyz", "customer_id": "cus_xyz", "bundle_pricing_id": "bundle_xyz", "start_date": "2023-01-12T05:40:31Z", "end_date": null, "renewal_date": "2023-04-12T05:40:31Z", "term": { "frequency": "MONTH", "count": 1 }, "auto_renews": true, "auto_charges": true, "metadata": {}, "change_date": null, "change_config": null, "cancel_date": null, "cancel_config": null, "pause_date": null, "pause_config": null, "next_invoice_date": "2023-04-12T05:40:31Z", "mrr": { "value_in_cents": 3995, "currency": "USD" }, "arr": { "value_in_cents": 47940, "currency": "USD" } } ``` There are other key actions that can be performed on subscriptions that your application might want to support such as ### Changing subscriptions Customers typically go through subscription lifecycles of either upgrades or downgrades or simple changes. Changes to plans can be done immediately or scheduled for a future date. They can also be prorated immediately or on the next invoice. You can also reset the billing anchor which implies that going forward the subscription cadence is set from the change date. ### Pausing subscriptions Payments for subscriptions can be paused with invoicing in draft or void mode. The subscription lifecycle continues as usual (for example, future subscription cancellation). ### Cancelling subscriptions Plans can be cancelled with the options to end immediately, at the end of the billing period, at renewal or at a custom date. Cancellations can be issued with refunds (last payment or prorated). ### Trial subscriptions Subscriptions can be set up in trial mode enable your users to try your product before they purchase it. Measure allows you to automatically enroll your customers into a plan with or without a credit card at the end of the trial and track trial conversion metrics to understand the funnel better. # Seat or Object-Based Billing Source: https://docs.getmeasure.com/pages/guides/syncing-objects In addition to [Usage-based billing](/pages/guides/kickstart-usage-based-billing-in-measure) or [Credits-based billing](/pages/guides/credits-based-billing), Measure can make any persistent model or object in your system billable. ### Objects vs Usage > The core difference is that in Object-based, objects are persistently billed until you say we shouldn't (object billing) where Usage-based relies on a ticker that counts up and resets after a desired period (month, year etc). In **Object-based Billing**, you charge your customers based on the number of custom objects they are assigned or are part of their plan. * Example: For project management tools like Asana, Jira, or Clickup, customers are charged per seat or license that a user occupies * Example: A company selling a home monitoring system can set up generic objects like "Devices" or more specific objects like "Camera", "Motion Detector" etc and charge customers based on the number of objects - Beginner Plan with 5 Devices *OR* 3 Cameras and 2 Motion Detectors In **Usage-based Billing**, you charge your customers based on the amount or frequency of the actual usage of a service or resource, such as **API calls** or **Cloud Storage** * Example: Twilio's SMS and Voice API where the customer is charged per SMS sent/received, or per minute for phone calls. If your product pricing aligns more with the usage-based model, go here: [Usage-Based Billing](/pages/guides/kickstart-usage-based-billing-in-measure) ## Object Ingestion You can leverage the Measure API to sync object-based items to do state based metric calculations. For instance, this would apply to counting the number of seats used by customers in your product or the number of servers or instances spun up by your service on behalf of your customers. Measure manages complete management of proration. tracking and invoicing for these models in your product. The objects can be synced into Measure through individual CRUD operations or object actions can be sent in bulk through the [Ingest Objects](/api-references/objects/ingest-objects) API. ```bash theme={null} curl --request POST \ --url https://api.getmeasure.com/api/v1/companies/company_id/objects \ --header 'accept: application/json' \ --header 'authorization: Bearer my_token' \ --header 'content-type: application/json' \ --data ' { "customer_id": "cus_2Z8glHJ9VcYQ1pgAjtJhE14Uucv", "customer_identifier": "external_customer_id", "object_identifier": "external_object_id", "item_id": "collaborator_object_id", "properties":{ "is_active": "true", "role": "editor", "collaborator_email": "[email protected]" } } ' ``` This billing model is particularly useful for enabling true-ups for your customers at a desired frequency. You can establish a regular sync of these objects from your application with the use of the [Objects](/api-references/objects/ingest-objects) API. Measure also supports the same aggregators for object-based billing. You can create complex matching rules to create highly specific billable metrics on objects. # Taxes Source: https://docs.getmeasure.com/pages/guides/taxes Measure simplifies global tax compliance by providing flexible tools to handle tax calculations automatically. Whether you're using a third-party tax platform or our built-in engine, Measure ensures that the correct taxes are applied to every invoice. ### Automated Tax Collection via Integrations For robust, real-time tax calculations, Measure integrates with leading tax compliance platforms. These integrations automatically determine the correct tax rates based on customer location, product taxability, and complex jurisdictional rules. This is the recommended approach for businesses operating in multiple tax regions. For a complete list of supported tax platforms and setup guides, please see our [Integrations section](/guides/setting-up-integrations). ### Manual Tax Configuration Measure also includes a built-in tax engine for businesses with simpler tax needs. You can configure standard tax rates at a company level, which will be applied to all invoices. This is useful for applying a single, consistent tax rate across your customer base. ### Customer-Specific Tax Overrides For customers who require special tax treatment, Measure allows you to set customer-level tax overrides. This feature lets you apply unique tax rates for specific customers, which will take precedence over any company-level or automated tax settings. For example, when working with a tax-exempt organization like a non-profit, you can create an override to apply a 0% tax rate to their invoices, ensuring accurate and compliant billing. # TaxJar Source: https://docs.getmeasure.com/pages/guides/taxjar TaxJar calculates taxes on Measure invoices in real-time based on your nexus registrations and customer location. ## Key Capabilities * **Real-time calculation**: Taxes are calculated during invoice generation based on customer address and product type * **Product tax mapping**: Map Measure products to TaxJar tax categories to ensure correct tax treatment * **Nexus threshold tracking**: Monitor sales activity against economic nexus thresholds in each jurisdiction * **Exemption certificates**: Manage tax-exempt customers and apply exemptions automatically to their invoices * **AutoFile**: Automatically submit sales tax returns in enrolled states based on your Measure transaction data ## How It Works The integration calculates taxes seamlessly during your billing workflow. When an invoice is generated, Measure sends the transaction details to TaxJar, which returns the applicable tax amounts based on your product mappings, the customer's location, and any applicable exemptions. ## Reporting and Filing TaxJar aggregates your Measure transaction data into state-by-state sales tax reports ready for filing. With AutoFile enabled, TaxJar can automatically submit returns in enrolled states, reducing manual compliance work. # Terms of Service Source: https://docs.getmeasure.com/pages/guides/terms-of-service # SaaS Metrics Source: https://docs.getmeasure.com/pages/guides/tracking-key-business-metrics In addition to enabling billing for your application, Measure makes it possible to track real-time holistic revenue numbers instead of waiting to reconcile multiple individually-running metrics systems at a regular cadence. For instance, your Monthly Recurring Revenue (MRR) or churn metrics are immediately updated as soon as subscriptions are created or cancelled and even when contracts for enterprise sales are signed or terminated. These metrics are currently surfaced through the Measure dashboard. Here's a list of all the business reporting metrics supported by Measure: ### Revenue * **MRR (Monthly Recurring Revenue)**: The predictable revenue generated every month from active subscriptions * **ARR (Annual Recurring Revenue)**: The total recurring revenue expected in a year based on the MRR * **MRR Growth Rate**: The percentage increase or decrease in MRR over a specific period * **Total Revenue**: The sum of all revenue generated from subscriptions, one-time payments, and other services * **Fees**: The amount charged for additional services or transaction costs outside of the core subscription * **Net Revenue**: Total revenue after deducting any applicable fees or refunds * **Other Revenue**: Revenue from sources outside the core subscriptions or typical revenue streams * **Invoiced Revenue**: The total amount billed to customers via invoices, whether paid or unpaid ### Subscriptions * **Active Subscriptions**: The number of currently active and ongoing customer subscriptions * **New Subscriptions**: The number of new subscriptions started within a specific time period * **Upgrades**: Subscriptions that have been moved to a higher plan or tier with more features * **Downgrades**: Subscriptions that have been moved to a lower plan or tier with fewer features * **Failed Charges**: The number of payment attempts that failed or were declined * **Refunds**: The total amount of money returned to customers for any reason ### License * **Active Licenses**: The number of currently active licenses for usage-based billing * **ARPL (Average Revenue per License)**: The average revenue generated per active license ### Credits * **Amounts Created**: The total monetary value generated by customers that hasn’t been consumed yet * **Amounts Consumed**: The monetary value customers have consumed through usage * **Units Created**: The total units or credits available for customer usage * **Units Consumed**: The number of units or credits customers have used ### Customers * **Active Customers**: The total number of customers with at least one active subscription * **New Customers**: The number of customers acquired during a specific period * **ARPU (Average Revenue per User)**: The average revenue generated per customer * **Total Revenue Per User**: The cumulative revenue generated from each customer * **LTV (Customer Lifetime Value)**: The predicted total revenue generated by a customer during their entire relationship with the business * **Reactivations**: The number of previously churned customers who resumed their subscriptions ### Connected Accounts (Stripe) Stripe's connected accounts allow individuals or businesses to accept payments using the platform’s payment infrastructure. * **Total Revenue**: The total income from all sources including subscriptions, one-time sales, and other services through stripe * **Application Fees**: The connected fees charged to customers for receiving payments via Stripe ### Trials * **New Trials**: The number of customers starting a trial of the product within a specific period * **Active Trials**: The number of ongoing trials that have not yet converted or expired * **Converted Trials**: The number of trial users that have transitioned to paying customers ### Churn * **User Churn**: The percentage of customers who cancel their subscriptions within a given period * **Revenue Churn**: The percentage of revenue lost from downgrades or customer cancellations * **Net Revenue Churn**: The revenue churn offset by any upgrades or expansion from remaining customers * **Churned Customers**: The number of customers who have cancelled their subscriptions in a given period # Trust Page Source: https://docs.getmeasure.com/pages/guides/trust-page # Webhooks Source: https://docs.getmeasure.com/pages/guides/webhooks Webhooks enable real-time updates from Measure to your application. Webhooks can be setup in the Measure dashboard by specifying a URL endpoint in your application to receive the relevant webhook payload when events you have subscribed to occur. We currently use [Convoy Service](https://getconvoy.io/) to send webhooks to your servers. ## Full list of webhooks Please take a look at the [Webhooks Reference](/webhook-references) for a full list of webhooks. ## Setting up webhooks Webhooks can be enabled and configured through the Measure dashboard under the Developers section. You can subscribe to specific events or all events. 1. Go to the **Webhooks** sub-section under **Developers**. 2. Click on **New Webhook** button 3. Add a **Target URL**, **Description** and select the events you want to listen to. Then click **Add Webhook** 4. Copy the **secret**. Once you create the webhook, a secret will be provided that can be used to verify the events received. Make sure to copy the secret since you will not be able to retrieve it again. Once you set up a webhook, you can continue to subscribe to a number of webhook event types to perform actions in your application. We continue to add more webhook event types, so feel free to reach out to us if you need a specific webhook event type. ## Security Measure will only send webhooks via a `POST` request to an HTTPS endpoint. Each request will also contain `X-Maple-Signature` header that represents the signature of the request. This signature can be verified to ensure that the webhook came from our servers, prevent replay attacks and ensure a zero downtime key rotation. See this [blog post](https://getconvoy.io/blog/generating-stripe-like-webhook-signatures/) for more details. A sample header may look something like this: ``` X-Maple-Signature: t=1492774577, v1=ansdoj213e98jqd928u3eudh239eu2j9d2jd8ejd238eu23ei2d9j23e8u23eue3, v0=6ffbb59b2300aae63f272406069a9788598b792a944a07aba816edb039989a39 ``` ## Receiving webhooks ### Verifying webhook signature We recommend using [Convoy SDKs](https://docs.getconvoy.io/sdk/sdk) to verify the signature. They have support for a few common programming languages (Go, Ruby, Python, Javascript, PHP). The following code will verify the code and a `200`status code as the response ```bash Go theme={null} func handleWebhook(w http.ResponseWriter, r *http.Request) { body, err := io.ReadAll(r.Body) webhooks := convoy.NewWebhook( &convoy.WebhookOpts{ Secret: os.Getenv("WEBHOOKS_SECRET"), Hash: "SHA512", Encoding: convoy.Base64Encoding, }, ) err = webhooks.VerifyPayload(body, r.Header.Get("X-Maple-Signature")) if err != nil { log.Errorf("webhooks not verified err = %s", err) return } log.Debugf("received body: %s", body) // Do something with the body w.Header().Set("Content-Type", "application/json; charset=UTF-8") w.WriteHeader(200) } ``` ```bash Javascript theme={null} import { Webhook } from "convoy.js"; async function verifyWebhhok(req) { try { // ensure you are getting JSON and not text const body: any = await req.json(); // Read signature from `X-Maple-Signature` header in the request const signature = req.get("x-maple-signature") as string; // Read secret from environment variable const secret = ""; // verfiy an advanced signature const webhook = new Webhook({ header: signature, payload: body , secret: secret, hash: "sha512", encoding: "base64", }); const verified = webhook.verify(); if (!verified) { throw new Error("Invalid signature"); } return true; } catch (err) { console.error("Error handling webhook:", err); return false; } } ``` ```bash Python theme={null} from convoy.utils.webhook import Webhook @router.post("/webhook/measure_billing") async def handle_measure_billing_webhook( request: Request, ) -> Response: signature = request.headers.get("X-Maple-Signature") body = await request.body() webhook = Webhook( secret=secret, hash="SHA512", encoding="base64", ) try: webhook.verify_signature(body.decode(), signature) except Exception as e: .. ``` ### Understanding webhook data Your endpoint must be configured to read the webhook event object. Each event has a `event_type`, `created_at`, `data_type` and `data`. ```json theme={null} { event_type: "customer.updated", data_type: "customer", created_at: 1681498548, data: { object: { id: "cus_2OQfabsJ8GIBwetfIRQLeCewrtBO", ... } } } ``` ### Responding to webhooks Your endpoint must return a successful status code (`2XX`) within 30s. Measure webhooks have a built-in retry mechanism for any `non-2xx`(`3XX`,`4XX`, and `5XX`) status codes. They will be retried 10 times with an exponential backoff strategy. # Xero Source: https://docs.getmeasure.com/pages/guides/xero Xero integration syncs invoices, credit notes, and payments from Measure to keep your accounting records up to date. ## Key Capabilities * **Invoice sync**: Automatically sync invoices, credit notes, and payments from Measure to Xero * **Customer mapping**: Map customer records between Measure and Xero * **Product mapping**: Map Measure products and pricing plans to Xero items for accurate revenue reporting * **Tax rate mapping**: Map Measure tax rates to Xero for accurate tax calculations ## Data Synchronization The integration is a one-way sync from Measure to Xero. Measure remains the source of truth for billing data, and Xero reflects your invoicing operations. Data syncs automatically at regular intervals. You can also trigger a manual sync from the Measure dashboard. # Overview Source: https://docs.getmeasure.com/pages/introduction/introduction Measure is an end-to-end revenue management platform that unifies billing, contracts, and payments, enabling engineering, product, sales, and finance teams to operate with greater efficiency while maintaining accuracy and control. Designed for reliability and scale, Measure supports any billing model (subscriptions, usage-based, seat-based, or hybrid), allowing you to launch new offerings and adjust pricing without re-architecting your infrastructure. Working with Measure involves these main steps: * **Define your offerings**: Configure your product catalog, pricing plans, and packaging * **Onboard and bill customers**: Create customers, subscriptions, and contracts via the Measure dashboard, checkout links, or the [Measure REST API](/pages/guides/authentication) * **Capture usage and entitlements**: Ingest events or sync objects for usage-based and seat-based billing * **Automate revenue operations**: Configure invoicing, payments, and integrations to accounting, tax, and payment platforms for end-to-end automation To get started, contact us at [hello@getmeasure.com](mailto:hello@getmeasure.com) to request an account. Thereafter, revenue can be managed through the Measure dashboard or the API. Refer to the guides below for detailed documentation. # Who is Measure for? Source: https://docs.getmeasure.com/pages/introduction/who ## CEOs and Founders Measure provides a live view of core business metrics, including MRR, active subscriptions, and customer count, that update as deals are signed, without extended reconciliation or manual spreadsheet work. It supports iteration on pricing and sales motions without deploying additional pricing tools or requiring engineering changes. Metrics remain current for fundraises, due diligence, and acquisition. Billing and invoicing are handled without uncapped percentage-of-revenue fees. Solution overview for founder-led teams. ## Sales and Revenue Operations Measure supports proposal creation, custom deals with automated approvals, and post-sales workflows. Deals can be tracked from contract creation through signature, execution, and payment, with integrations to common CRMs. * **Deal workflow**: Custom deals with branded templates, built-in signatures, and automated reminders. * **Quote-to-cash-to-provision**: Recurring invoicing driven by contract terms, payments, and provisioning. * **Deal desk automation**: Workflow and approval rules so teams follow guidelines. Contract workflows reduce manual steps for invoicing and payment. Solution overview for sales and revenue operations. ## Finance Measure provides a single source of truth for accounts receivables. Invoicing, revenue collection, and recovery can be automated in one product, replacing processes that span spreadsheets, siloed systems, and third-party tools. * **Revenue recovery**: Transparent invoices, collection through multiple payment processors, and configurable dunning. * **Revenue reporting**: MRR, churn, aged receivables, and deferred revenue in real time. * **Revenue recognition**: Configurable recognition schedules for usage-based, credits-based, and other pricing models. Solution overview for finance teams. ## Product & Engineering Measure supports usage-based, credits-based, and seat-based billing plus feature entitlements with minimal integration. It reduces the need for custom pricing and packaging builds and the dependency of pricing changes on engineering availability. Product can own pricing and packaging while engineering uses stable infrastructure for access and entitlements. Pricing can be iterated without substantial engineering effort or delays to product work. Solution overview for product and engineering teams. # Why Measure? Source: https://docs.getmeasure.com/pages/introduction/why Revenue management typically involves a tangled mess of systems owned by multiple stakeholders including finance, sales, product, and engineering. For engineering and product, the focus tends to stay on revenue-driving features; over time, billing becomes obsolete or tightly coupled to a single offering. That creates a serious bottleneck for growth: launching new products, experimenting with pricing and packaging, and scaling from product-led to sales-led motions. Measure powers the **end-to-end revenue workflow** for engineering, product, revops, sales, and finance in one platform built for modern pricing and any sales motion. Leading options like [Stripe Billing](https://stripe.com/billing), [Chargebee](https://www.chargebee.com/), and [Maxio](https://maxio.com/) each have strengths, but they fall short when you need **flexible pricing, integrated quote-to-cash, and predictable cost at scale**. Measure is purpose-built to fill those gaps. See [how Measure compares](https://getmeasure.com/compare) to these solutions in depth. ### Usage, Seat, and Credits-Based Billing Many platforms require your application to compute and push final usage amounts for invoicing, which forces you to track usage, handle high volume, and work around API rate limits. That makes real-time, accurate usage visibility for customers difficult or impossible. Measure handles computation and scaling for high-volume usage and property changes so you get **accurate, live usage tracking** out of the box, without turning billing into an engineering project. Unlike Chargebee or Maxio, usage-based and hybrid models are **native and quick to configure**, not bolted on. ### Pricing Management and Billing Interval Flexibility Other platforms often limit you to a single billing frequency per subscription, or make multi-frequency and complex pricing painful to implement. That blocks common enterprise patterns: e.g., yearly license fees with monthly overages, or multi-year deals with indexed adjustments. Measure lets you **bill different metrics at different frequencies** in the same subscription, with true-ups, minimums, and the flexibility sales and finance need for negotiated, enterprise-style deals. ### Flexible Payment Processing Stripe Billing ties you to Stripe Payments. That can restrict locale-specific payment methods and better processing rates from other providers. Disabling or de-emphasizing card payments in favor of ACH or bank transfers is often difficult. Measure can use Stripe Payments **and** other providers such as Helcim and Square. You stay in control of processing rates and payment methods as you grow and expand geographies, without extra engineering to add new processors. ### Sales-Led Flows and Quote-to-Cash Stripe offers basic quotes; Chargebee and others often rely on **separate tools** for e-signatures and contract tracking, which slows the sales cycle and creates data silos. Maxio’s CPQ and reporting can feel heavy and slow to adapt to modern, negotiated pricing. Measure provides **integrated quote-building, e-signatures, and contract management** with custom pricing, minimums, and discount handling. Completed contracts flow automatically into subscriptions and revenue tracking, while CRM integrations keep sales in their tools with accurate billing and pipeline visibility. ### Revenue Recovery and Dunning Most tools send basic payment-failure emails. Measure goes further with **proactive dunning**: credit card expiry notifications, highly configurable invoice reminders, and (coming soon) self-serve customer portals so users can update payment methods and avoid churn before it happens. ### Revenue Recognition and Business Metrics Other platforms often offer limited or lagging metrics, with MRR and attribution hard to map. Measure delivers **robust, real-time business metrics** and revenue recognition tuned for usage-based, hybrid, and traditional subscription models, so you can run the business from one source of truth. ### Pricing Stripe and others charge a **percentage of revenue**; as you close larger deals, your billing cost grows with every dollar. Chargebee and Maxio add implementation and onboarding fees and can become prohibitively expensive for mid-market and scaling teams. Measure uses a **flat fee per paid subscription**. Your cost to run billing stays predictable as revenue grows, and you can run large enterprise deals alongside smaller ones in the same system, without the platform fraying or the bill spiking. *** # contract.created Source: https://docs.getmeasure.com/webhook-references/contracts/contractcreated webhook contract.created Triggered when a contract is created through the dashboard or through the API # contract.executed Source: https://docs.getmeasure.com/webhook-references/contracts/contractexecuted webhook contract.executed Triggered when a contract completes execution from signature to a subscription or one-time invoice # contract.signed Source: https://docs.getmeasure.com/webhook-references/contracts/contractsigned webhook contract.signed Triggered whenever a signatory signs the contract # contract.updated Source: https://docs.getmeasure.com/webhook-references/contracts/contractupdated webhook contract.updated Triggered when the properties of a contract are updated through dashboard or through the API # credit.created Source: https://docs.getmeasure.com/webhook-references/credits/creditcreated webhook credit.created Triggered when a credit is created through the dashboard or through the API # credit.expired Source: https://docs.getmeasure.com/webhook-references/credits/creditexpired webhook credit.expired Triggered when a credit expires # credit.revoked Source: https://docs.getmeasure.com/webhook-references/credits/creditrevoked webhook credit.revoked Triggered when a credit is deleted through the dashboard or through the API # credit.updated Source: https://docs.getmeasure.com/webhook-references/credits/creditupdated webhook credit.updated Triggered when properties of a credit are updated such as the name through the dashboard or through the API # customer.created Source: https://docs.getmeasure.com/webhook-references/customer/customercreated webhook customer.created Triggered when a customer is created through the dashboard or the API # customer.mrr.changed Source: https://docs.getmeasure.com/webhook-references/customer/customermrrchanged webhook customer.mrr.changed Triggered when the mrr value for the customer is updated # customer.payment_method.attached Source: https://docs.getmeasure.com/webhook-references/customer/customerpayment_methodattached webhook customer.payment_method.attached Triggered when a payment method is added to the customer # customer.payment_method.detached Source: https://docs.getmeasure.com/webhook-references/customer/customerpayment_methoddetached webhook customer.payment_method.detached Triggered when a payment method is removed from a customer # customer.updated Source: https://docs.getmeasure.com/webhook-references/customer/customerupdated webhook customer.updated Triggered when any property on the customer is updated # ingest.events.failed Source: https://docs.getmeasure.com/webhook-references/events-ingest/ingesteventsfailed webhook ingest.events.failed Triggered when billable events fail upon asynchronous ingestion # invoice_payment_retry_schedule.completed Source: https://docs.getmeasure.com/webhook-references/invoice/invoice_payment_retry_schedulecompleted webhook invoice_payment_retry_schedule.completed Triggered when all automated retries for payment have been completed # invoice_reminder_schedule.completed Source: https://docs.getmeasure.com/webhook-references/invoice/invoice_reminder_schedulecompleted webhook invoice_reminder_schedule.completed Triggered when all reminders for payment on an invoice have been completed # invoice.created Source: https://docs.getmeasure.com/webhook-references/invoice/invoicecreated webhook invoice.created Triggered when an invoice is generated from the dashboard, automatic recurring subscriptions or from the API # invoice.paid Source: https://docs.getmeasure.com/webhook-references/invoice/invoicepaid webhook invoice.paid Triggered when an invoice is fully paid # invoice.voided Source: https://docs.getmeasure.com/webhook-references/invoice/invoicevoided webhook invoice.voided Triggered when an invoice is voided from the dashboard # item.created Source: https://docs.getmeasure.com/webhook-references/item/itemcreated webhook item.created Triggered when a billable item is created through the dashboard or the API # item.updated Source: https://docs.getmeasure.com/webhook-references/item/itemupdated webhook item.updated Triggered when a billable item is updated through the dashboard or the API # metric.created Source: https://docs.getmeasure.com/webhook-references/metric/metriccreated webhook metric.created Triggered when a billable metric is created through the dashboard or the API # metric.updated Source: https://docs.getmeasure.com/webhook-references/metric/metricupdated webhook metric.updated Triggered when a billable metric is updated through the dashboard or the API # payment.failed Source: https://docs.getmeasure.com/webhook-references/payments/paymentfailed webhook payment.failed Triggered when an invoice has a failed payment through the payment provider # payment.success Source: https://docs.getmeasure.com/webhook-references/payments/paymentsuccess webhook payment.success Triggered when an invoice is successfully paid either through the payment provider or a payment logged through the dashboard # subscription.cancelled Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptioncancelled webhook subscription.cancelled Triggered when the subscription is cancelled from the dashboard or through the API # subscription.changed Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionchanged webhook subscription.changed Triggered when the pricing plan on a subscription is changed # subscription.created Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptioncreated webhook subscription.created Triggered when a subscription is created for a customer through the dashboard or the API # subscription.default_usage_threshold_exceeded Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptiondefault_usage_threshold_exceeded webhook subscription.default_usage_threshold_exceeded Triggered when usage thresholds set on the subscription are exceeded # subscription.mrr.changed Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionmrrchanged webhook subscription.mrr.changed Triggered when the mrr value for the subscription is updated # Subscriptionpaused Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionpaused https://api.getmeasure.com/api/v1/docs/webhooks_spec.json webhook subscription.paused Triggered when a subscription is paused from the dashboard or through the API # subscription.renewed Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionrenewed webhook subscription.renewed Triggered when the subscription renews at the term end # Subscriptiontrial extended Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptiontrial_extended https://api.getmeasure.com/api/v1/docs/webhooks_spec.json webhook subscription.trial_extended Triggered when the trial end date on a subscription is extended # subscription.unpaid Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionunpaid webhook subscription.unpaid Triggered when a subscription status becomes unpaid typically through a payment retry or invoice reminder campaign or through the API # subscription.updated Source: https://docs.getmeasure.com/webhook-references/subscription/subscriptionupdated webhook subscription.updated Triggered when properties the subscription such as the metadata, net terms, auto-charge status are updated. Please note that a different webhook is triggered when the pricing plan is changed on the subscription. # Team memberadded Source: https://docs.getmeasure.com/webhook-references/team-members/team_memberadded https://api.getmeasure.com/api/v1/docs/webhooks_spec.json webhook team_member.added Triggered when a team member accepts an invitation and joins the team # Team memberremoved Source: https://docs.getmeasure.com/webhook-references/team-members/team_memberremoved https://api.getmeasure.com/api/v1/docs/webhooks_spec.json webhook team_member.removed Triggered when a team member is removed from the team