# Hyperline CLI Source: https://docs.hyperline.co/api-reference/docs/ai/cli Use the Hyperline CLI — an agent-first command-line tool — to query customers, subscriptions, invoices, and events directly from your terminal. The [Hyperline CLI](https://www.npmjs.com/package/@hyperline/cli) lets you manage your billing operations directly from the terminal. It's designed to be **agent-first** — optimized for AI agents like Claude Code, Cursor, Windsurf, and any tool that can run shell commands. ## Why a CLI for AI agents? AI agents work with tools to accomplish tasks. Today, most agents use MCP (Model Context Protocol) to connect to external services. While MCP works well, it has limitations when used at scale: * **Context bloat** — MCP servers expose dozens of tools, each with full schemas that consume valuable context window space. * **Slower on complex tasks** — For multi-step workflows, agents using MCP need to discover tools, read schemas, and format structured requests for each operation. On complex questions, MCP agents can loop for minutes trying to find the right tool combination. CLIs solve these problems: * **Token-efficient** — Short commands like `hyperline customers list` are natural for a text-predicting model to write and require minimal context to understand. * **No tool discovery overhead** — Agents don't need to load a catalog of tools or read JSON schemas. They just run commands and read the output. * **Composable** — CLI output can be piped, filtered with `jq`, or chained with other commands — patterns that agents handle natively. ## Installation ```bash theme={null} npm install -g @hyperline/cli ``` Verify the installation: ```bash theme={null} hyperline --version ``` ## Authentication ### Browser login The simplest way to authenticate — opens your browser to securely log in with your Hyperline account: ```bash theme={null} hyperline login ``` Credentials are stored locally in `~/.hyperline/`. To log out: ```bash theme={null} hyperline logout ``` ### API key For server environments, CI/CD pipelines, or AI agents running without a browser: ```bash theme={null} # Via environment variable export HYPERLINE_API_KEY=sk_test_... # Or inline hyperline customers list --api-key sk_test_... ``` API keys can be generated from your account [Settings](https://app.hyperline.co/app/settings/api). Keep your API key secret. Do not commit it to version control — use environment variables or a secrets manager instead. For sandbox environments, set the base URL via environment variable or flag: ```bash theme={null} export HYPERLINE_API_URL=https://api.sandbox.hyperline.co # Or per-command hyperline customers list --base-url https://api.sandbox.hyperline.co ``` ## Company selection If you have access to multiple companies, the CLI uses the last used company by default. To switch to a specific company: ```bash theme={null} hyperline company select ``` ## Usage The CLI follows a consistent `hyperline ` pattern: ```bash theme={null} # List customers hyperline customers list # Get a specific invoice hyperline invoices get --id inv_xxxxx # Create a new customer hyperline customers create --name "Acme Inc" --currency USD ``` ### Available resources | Resource | Description | | -------------------- | ----------------------------------------------------------- | | `customers` | Create, update, list, and manage your customer base | | `subscriptions` | Handle subscription lifecycle, cancellations, and templates | | `invoices` | Create, list, and manage invoices and transactions | | `products` | Define and update your product catalog | | `quotes` | Generate and manage quotes | | `wallets` | Prepaid wallet management and top-ups | | `coupons` | Create discount coupons and promotion codes | | `webhooks` | Configure webhook endpoints | | `payments` | Track and manage payments | | `analytics` | Access billing metrics | | `exports` | Export your billing data | | `custom-properties` | Extend resources with custom fields | | `taxes` | View tax rates and configurations | | `invoicing-entities` | Manage your billing entities | Use `--help` on any command to see available actions and options: ```bash theme={null} hyperline customers --help hyperline invoices list --help ``` ### Output formats By default, the CLI outputs human-readable text. Use `--output json` for structured output: ```bash theme={null} # Human-readable output hyperline customers list # JSON output for scripting hyperline customers list --output json # Pipe to other tools hyperline customers list --output json | jq '.[].name' ``` ### Global options | Option | Description | | ------------------- | -------------------------------------------- | | `--api-key ` | API key (overrides `HYPERLINE_API_KEY`) | | `--base-url ` | API base URL (overrides `HYPERLINE_API_URL`) | | `--output ` | `json` or `text` (default: `text`) | | `--help` | Show help | | `--version` | Show version | ## Setting up for AI agents ### Claude Code Add the Hyperline CLI to your project's `CLAUDE.md` so Claude knows it's available: ```markdown theme={null} ## Tools Hyperline CLI is available for billing operations. Authenticate with: `export HYPERLINE_API_KEY=sk_...` Usage: `hyperline [options]` Use `--output json` when you need to process the data. ``` ### Cursor / Windsurf Add instructions to your project rules (`.cursor/rules/` or `.windsurfrules`) so the agent knows to use the CLI: ```markdown theme={null} ## Billing Use the Hyperline CLI for any billing-related tasks. Run `hyperline ` commands in the terminal. Use `--output json | jq` for filtering and processing data. ``` ### Any agent with shell access Any AI agent that can execute shell commands can use the Hyperline CLI. Set the `HYPERLINE_API_KEY` environment variable in the agent's environment, and the CLI is ready to use — no additional configuration or tool registration needed. ## CLI vs MCP — which should I use? | | CLI | MCP | | -------------------- | ------------------------------------------------------- | ---------------------------------------------------------- | | **Best for** | AI agents with shell access, scripting, automation | AI assistants without terminal access (Claude.ai, ChatGPT) | | **Setup** | `npm install -g @hyperline/cli` | Add MCP server URL to your client | | **Auth** | API key or browser login | OAuth or API key | | **Context cost** | Minimal — just command strings | Higher — full tool schemas loaded in context | | **Multi-step tasks** | Excellent — pipe, chain, and compose commands | Can struggle with complex workflows | | **Works with** | Claude Code, Cursor, Windsurf, any terminal-based agent | Claude.ai, ChatGPT, any MCP-compatible client | You can use both. The MCP server is great for conversational AI assistants, while the CLI shines for agents that work in the terminal. Learn how to set up the Hyperline MCP server for AI assistants without terminal access. # Hyperline MCP Source: https://docs.hyperline.co/api-reference/docs/ai/mcp Connect AI assistants like Claude and Cursor to your Hyperline account through the Model Context Protocol for billing data lookups and actions. Connect your AI tools to Hyperline using the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction), an open standard that lets AI assistants interact with your billing data, manage customers, and automate revenue operations. ## What is Hyperline MCP? Hyperline MCP is our hosted MCP server that gives AI tools secure access to your Hyperline account. It's designed to work seamlessly with popular AI assistants like Claude, ChatGPT, Cursor, and more. ### Why use Hyperline MCP? * **Natural language billing management** — Manage customers, subscriptions, and invoices through conversational AI instead of navigating through multiple screens * **Full account access** — AI tools can search, read, create, and update records across your Hyperline account—customers, subscriptions, invoices, products, and usage data * **Easy setup** — Connect through OAuth with one-click installation for supported AI tools, or use an API token for direct authentication * **Optimized for AI** — Built specifically for AI agents with efficient data formatting and human-readable responses * **Secure by design** — Authenticates with your Hyperline credentials, with read operations auto-approved while write operations request confirmation ### What can you do with Hyperline MCP? * **Customer management** — Look up customer details, find contacts by email or name, and create new customer records * **Subscription operations** — View active subscriptions, check renewal dates, and manage subscription lifecycle * **Invoice handling** — Search invoices by status, view payment history, and track overdue payments * **Usage tracking** — Query usage data, check consumption metrics, and explore billing periods * **Revenue analytics** — Access MRR, ARR, and other key metrics through natural language queries * **Product catalog** — Browse products and pricing, understand your catalog structure ## Getting started ### Prerequisites Before connecting Hyperline MCP, ensure you have: 1. An active Hyperline account 2. An MCP-compatible AI client (Claude, ChatGPT, Cursor, VS Code, etc.) ### Authentication The Hyperline MCP server uses OAuth 2.0 for authentication. Most AI clients handle the OAuth flow automatically — you'll simply be redirected to log in with your Hyperline credentials. If your client doesn't support OAuth (for example, in a server or machine-to-machine context), you can authenticate using an API token instead. API tokens can be generated from your workspace [Settings](https://app.hyperline.co/app/settings/api). Some AI clients support OAuth but do not support dynamic client registration. In that case, the client may ask for an OAuth **Client ID** in addition to the MCP server URL. If your client has a **Client ID** or **OAuth client ID** field: 1. Enter the MCP server URL: `https://mcp.hyperline.co/mcp` 2. Use dynamic client registration if the client offers it 3. If dynamic registration is not available, contact Hyperline support to get the static OAuth Client ID for your environment Avoid using a shared API key when you need per-user Hyperline permissions. OAuth keeps access tied to the Hyperline user who authorizes the AI client, so existing roles and permissions still apply. ### Connecting to Hyperline MCP Add the following server URL to your AI client: ``` https://mcp.hyperline.co/mcp ``` For sandbox environments, use `https://sandbox.mcp.hyperline.co/mcp` instead. **For Claude Desktop or Claude.ai:** 1. Open **Settings** → **Connectors** 2. Select **Add custom connector** 3. Enter a name (e.g., `hyperline`) and the URL: `https://mcp.hyperline.co/mcp` 4. Follow the OAuth prompts to log in to your Hyperline account Run the following command to add the Hyperline MCP server: ```bash theme={null} claude mcp add --transport http hyperline https://mcp.hyperline.co/mcp ``` 1. Navigate to **Settings** → **Apps** → **Advanced settings** → Enable **Developer mode** 2. Select **Create App** 3. Fill in the Name (e.g., `Hyperline`) and MCP Server URL 4. Add the MCP Server URL: `https://mcp.hyperline.co/mcp` 5. Complete the OAuth flow to authenticate with Hyperline 1. Use Command + Shift + P (Ctrl + Shift + P on Windows) to open the command palette 2. Search for "Open MCP settings" 3. Select **Add custom MCP** to open the `mcp.json` file 4. Configure the server: ```json theme={null} { "mcpServers": { "hyperline": { "url": "https://mcp.hyperline.co/mcp" } } } ``` 1. Create a `.vscode/mcp.json` file in your project 2. Configure the server: ```json theme={null} { "servers": { "hyperline": { "type": "http", "url": "https://mcp.hyperline.co/mcp" } } } ``` Add `https://mcp.hyperline.co/mcp` as a remote MCP server and complete the OAuth authentication when prompted. If your client doesn't support OAuth, use your API token for direct authentication instead. Once connected, you'll be authenticated with access to your Hyperline account data. If your MCP client runs in a server environment without a browser (e.g., a backend agent or automated pipeline), you can skip OAuth and authenticate directly with an API key. Generate an API key from your workspace [Settings](https://app.hyperline.co/app/settings/api), then pass it in the `Authorization` header when connecting to the MCP server: ``` Authorization: Bearer ``` For example, in an MCP client configuration that supports custom headers: ```json theme={null} { "mcpServers": { "hyperline": { "url": "https://mcp.hyperline.co/mcp", "headers": { "Authorization": "Bearer " } } } } ``` Keep your API key secret. Do not commit it to version control — use environment variables or a secrets manager instead. ## Multi-company access If your Hyperline user has access to multiple companies, the MCP server defaults to the first (oldest) company linked to your account. To target a specific company, include the `Hyperline-CompanyId` header in your MCP server configuration: ```json theme={null} { "mcpServers": { "hyperline": { "url": "https://mcp.hyperline.co/mcp", "headers": { "Authorization": "Bearer ", "Hyperline-CompanyId": "" } } } } ``` You can retrieve the list of companies your account has access to using the [`/v1/companies`](/api-reference/endpoints/companies/list-companies) endpoint. ## Supported tools The Hyperline MCP server exposes over 100 tools covering the full breadth of your billing operations. These include listing and retrieving customers, quotes, subscriptions, invoices, and product information, as well as actions like creating and voiding invoices, generating quotes, assigning subscriptions, querying usage data, and accessing revenue metrics — among many others. Once connected, your AI assistant automatically discovers all available tools. Simply describe what you need in natural language, and the assistant will use the right tools to get it done. ## Sample prompts ### Customer and account lookup | Prompt | What it does | | --------------------------------------------- | --------------------------------------------------------- | | "Find all customers with overdue invoices" | Searches for customers with unpaid invoices past due date | | "What's the email for Acme Corp?" | Looks up contact information for a specific customer | | "Show me everything we know about customer X" | Retrieves comprehensive customer information | | "Find customers in the Enterprise plan" | Filters customers by subscription plan | | "List customers created in the last 30 days" | Shows recently acquired customers | ### Subscriptions and billing | Prompt | What it does | | ---------------------------------------------------------- | -------------------------------------- | | "What subscriptions does Acme Corp have?" | Lists all subscriptions for a customer | | "Show me subscriptions renewing next week" | Finds upcoming renewals | | "Which customers are on the Pro plan?" | Lists customers filtered by plan | | "Create a subscription for customer X on the Starter plan" | Creates a new subscription | ### Invoices and payments | Prompt | What it does | | -------------------------------------------- | ---------------------------------- | | "List unpaid invoices from the last 30 days" | Searches for outstanding invoices | | "What's the total amount billed this month?" | Calculates monthly billing total | | "Show me the payment history for Acme Corp" | Retrieves customer payment records | | "Find invoices over \$10,000" | Filters invoices by amount | ### Revenue analytics | Prompt | What it does | | --------------------------------------------- | ---------------------------------- | | "What's my current MRR?" | Returns Monthly Recurring Revenue | | "Show me revenue trends for the last quarter" | Displays revenue metrics over time | | "How many active subscriptions do we have?" | Counts active subscriptions | | "What's our customer churn this month?" | Calculates churn metrics | ## Security best practices Treat your credentials and billing data as sensitive information. Only connect to AI applications you trust, and use sandbox credentials when experimenting. ### Tool safety Hyperline MCP uses MCP safety annotations: * **Read operations** — Auto-approved for seamless searching and viewing * **Write operations** — Request user confirmation before creating or updating data ### User permissions Hyperline MCP respects your existing user permissions. The tools available through the MCP server depend on the roles and permissions configured for your user account in your workspace [Settings](https://app.hyperline.co/app/settings/members), or API key scopes. AI assistants can only access and modify what you are authorized to do in Hyperline. You can revoke access at any time by deleting API keys or revoking user access. ### Rate limits Standard API rate limits apply to all MCP operations. See [Rate limiting](/api-reference/docs/rate-limiting) for details. In most cases, normal conversational use stays well within rate limits. ## Troubleshooting If your AI assistant can't connect to Hyperline: 1. **Verify your credentials** — Make sure the credentials are correct and haven't been regenerated or revoked 2. **Check the environment** — Ensure you're using the correct URL for your environment (production vs sandbox) 3. **Test the connection** — Try a simple request like "List customers" to verify the connection works 4. **Check permissions** — Ensure your Hyperline user has the necessary permissions for the operations you're attempting Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Build with LLMs Source: https://docs.hyperline.co/api-reference/docs/ai/overview Use Hyperline documentation and APIs with AI assistants, LLMs, and agent frameworks through CLI, MCP server, and structured machine-readable docs. You can use large language models (LLMs) to assist in building Hyperline integrations. This page explains how to access our documentation in LLM-friendly formats and how to connect AI assistants directly to your Hyperline account. ## Using documentation with LLMs ### llms.txt The [llms.txt file](https://llmstxt.org) is an industry standard that helps LLMs index content efficiently, similar to how a sitemap helps search engines. AI tools use this file to understand your documentation structure and find relevant content. We automatically host an `llms.txt` file that lists all available pages: [docs.hyperline.co/llms.txt](https://docs.hyperline.co/llms.txt) ### skill.md The [skill.md specification](https://agentskills.io/specification) is a structured, machine-readable format that describes what AI agents can accomplish with Hyperline. While `llms.txt` tells agents where to find information, `skill.md` tells them what capabilities are available, what inputs are required, and what constraints apply. We automatically host a `skill.md` file: [docs.hyperline.co/skill.md](https://docs.hyperline.co/skill.md) Agents can process this file using the [skills CLI](https://www.npmjs.com/package/skills): ```bash theme={null} npx skills add docs.hyperline.co/skill.md ``` ### Documentation MCP Server The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) is an open standard that allows AI assistants to connect directly to external services. When connected to our documentation MCP server, AI tools can search our docs during response generation — providing more accurate answers than generic web searches. Connect your AI tools to our documentation MCP server at `https://docs.hyperline.co/mcp`: 1. Navigate to the [Connectors](https://claude.ai/settings/connectors) page in the Claude settings 2. Select **Add custom connector** 3. Add the server name (e.g., `hyperline-docs`) and URL: `https://docs.hyperline.co/mcp` 4. Select **Add** 5. When using Claude, select the attachments button (the + icon) 6. Select your MCP server Run the following command to add the Hyperline Docs MCP server: ```bash theme={null} claude mcp add --transport http hyperline-docs https://docs.hyperline.co/mcp ``` 1. Use Command + Shift + P (Ctrl + Shift + P on Windows) to open the command palette 2. Search for "Open MCP settings" 3. Select **Add custom MCP** to open the `mcp.json` file 4. Configure the server: ```json theme={null} { "mcpServers": { "hyperline-docs": { "url": "https://docs.hyperline.co/mcp" } } } ``` 1. Create a `.vscode/mcp.json` file in your project 2. Configure the server: ```json theme={null} { "servers": { "hyperline-docs": { "type": "http", "url": "https://docs.hyperline.co/mcp" } } } ``` ## Hyperline MCP Server Beyond accessing documentation, you can connect AI assistants directly to your Hyperline account to **interact with your billing data** using natural language. The Hyperline MCP server enables you to: * Query and manage customers * View and create subscriptions * Generate invoices * Access analytics and revenue metrics * And more This allows you to ask your AI assistant questions like: * "Show me all customers with overdue invoices" * "What's my current MRR?" * "Create a new subscription for customer X" Learn how to set up and use the Hyperline MCP server to connect AI assistants to your billing data. ## Hyperline CLI For AI agents that work in the terminal (Claude Code, Cursor, Windsurf), the Hyperline CLI offers a lighter, faster alternative to MCP. Commands like `hyperline customers list` are token-efficient and require no tool discovery — making agents faster and more reliable on complex, multi-step tasks. Learn how to install and use the Hyperline CLI for agent-first billing operations. # Currency amounts Source: https://docs.hyperline.co/api-reference/docs/amount Understand how Hyperline represents monetary values in the API — currency, integer amounts in minor units, and rounding rules across endpoints. Learn about [currency settings](../../docs/account/settings#currencies) in Hyperline. On the technical side, our APIs always represent currencies using their **three-letter ISO 4217 code** (see a complete list [here](https://en.wikipedia.org/wiki/ISO_4217#Active_codes_\(List_One\))), and accept and return integer amounts in the **currency's smallest unit**. For **European currencies**, this means that amounts are represented in **cents**. If you want to convert an amount with decimals into its Hyperline format you need to multiply it by `100`. For example, an amount of €`34.17` (Euro, a two-decimal currency) will be represented in Hyperline as `3417`. Hyperline also supports **zero-decimal currencies** and **three-decimal currencies**. In this case, you need to apply the right multiplier (or none). For example, an amount of `F CFA 12065` (West African CFA franc, a zero-decimal currency) will be represented in Hyperline as `12065`. # Authentication Source: https://docs.hyperline.co/api-reference/docs/authentication Authenticate to the Hyperline API with bearer tokens, manage API keys, and configure secure access for production and sandbox environments. The Hyperline API requires either an **API key** or an **access token** to identify and authorise calls. API keys are associated with a single Hyperline account, and an access token represents delegated access to a specific account (used for [third-party apps](./third-party-app)). You can have more than one token or key at any point in time. Those tokens are able to authenticate to Hyperline and perform actions on your account so it's important that you keep them safe in the same way that you would a password. ## Manage API keys ### Generate an API key Generating an **API key** is very simple and allows you to use Hyperline's API or integrations such as Zapier. As a Hyperline admin: 1. Go to your workspace [Settings](https://app.hyperline.co/app/settings/api), section API 2. Select `+ New API key` 3. Add a name for this key, and select the appropriate scopes (in most cases you'll need read/write access) 4. Copy the key and store it in a safe space, you won't be able to see it later in Hyperline API keys are prefixed either with `prod_` or `test_` to easily identify and distinguish them between environments. ### Use an authentication token API keys or access tokens must be provided with every API call, specified in the `Authorization` header after a `Bearer` prefix. All requests happen using HTTPS. For example: ```sh theme={null} curl -H "Authorization: Bearer " https://api.hyperline.co/v1/customers ``` We also support HTTP Basic Authentication, where the `username` is the API key and the `password` is left blank, but we recommend using Bearer Authentication because it's simpler for debugging. ### Keep your data safe Your API keys should be treated as **highly sensitive information** - think of a token like a password. You should only give tokens to services you fully trust. If leaked, tokens could be used maliciously - they can provide someone with access to all of your Hyperline data. If you suspect a token has been compromised, revoke it and replace it with a new one. Tokens should never be shared with support teams or your customers. ### Revoke a key Workspace admins can permanently revoke tokens from the [API Settings](https://app.hyperline.co/app/settings/api) in Hyperline. To revoke a token, select the `…` icon on the line of the key name, then `Delete` to permanently delete it. A deleted key cannot be recovered. # Dates & timezones Source: https://docs.hyperline.co/api-reference/docs/dates-and-timezones Understand how Hyperline represents dates, datetimes, and timezones across the API — ISO 8601 formatting, UTC defaults, and billing-cycle conventions. All dates in the Hyperline API are handled in UTC (Coordinated Universal Time). When sending dates to the API, you must convert your local timezone dates to UTC. Similarly, all dates returned by the API will be in UTC format. ## Working with customer timezones When creating subscriptions for customers in specific timezones, you'll need to convert the desired local time to UTC before sending it to the API. ### Examples Let's say you want to create a subscription that starts at midnight (00:00) in Paris timezone (Europe/Paris): ```javascript theme={null} // Example 1: January 1st, 2024 at 00:00 Paris time // Paris is UTC+1 in winter, so we need to convert to UTC (23:00 previous day) "2023-12-31T23:00:00Z" // Example 2: July 1st, 2024 at 00:00 Paris time // Paris is UTC+2 in summer (due to daylight saving), so we need to convert to UTC (22:00 previous day) "2024-06-30T22:00:00Z" ``` Note that the `Z` suffix in the date string indicates that the timestamp is in UTC. ## Best practices * Always use ISO 8601 format for dates * Include the UTC indicator (`Z`) in your timestamps * Consider daylight saving time when converting from local timezones * Use a reliable date library (like `date-fns` or `luxon`) to handle timezone conversions # Error handling Source: https://docs.hyperline.co/api-reference/docs/error-handling Handle Hyperline API errors safely: HTTP status codes, error response payloads, validation failures, retry guidance, and common troubleshooting. The Hyperline API uses conventional HTTP response codes to indicate the success or failure of an API request. This page details how to handle errors effectively and what to expect in error responses. ## HTTP status codes The API uses standard HTTP status codes to indicate the success or failure of requests: * **2xx Success**: The request was successful * **4xx Client error**: The request was invalid or cannot be processed * **5xx Server error**: An internal server error occurred ## Error response format When an error occurs, the API returns a JSON response with a `message` property containing a human-readable description of the error: ```json theme={null} { "message": "The requested resource was not found" } ``` ## Common error codes ### 400 Bad request The request was malformed or contains invalid parameters. ```json theme={null} { "message": "Cannot assign a subscription to a customer without a currency set" } ``` Common validation errors include: * Missing required fields * Invalid parameter values ### 401 Unauthorized The request lacks valid authentication credentials. ```json theme={null} { "message": "Missing authentication token" } ``` ### 404 Not found The requested resource was not found. ```json theme={null} { "message": "Product not found" } ``` ### 429 Too many requests The request rate limit has been exceeded. See [Rate limiting](./rate-limiting) for more details. ## Getting help If you encounter an error that you cannot resolve, please: 1. Check the error message for guidance 2. Verify your request format and parameters 3. Ensure your authentication credentials are valid 4. Contact our support team with the error details and request information # Getting started with the Hyperline API Source: https://docs.hyperline.co/api-reference/docs/getting-started Start building with the Hyperline API: create your API key, make your first request, explore key endpoints, and integrate billing into your product. We offer a complete set of resources — APIs, a webhook system, low-code solutions, and developer tools — to help you build a full technical integration. Our main principle is to minimize the technical workload on your end and abstract away the complexities of managing a billing system, so you can focus on delivering your core product value. The Hyperline API follows REST principles and uses JSON-encoded data payloads. It adheres to industry standards and delivers a user-friendly interface, with straightforward operations, detailed error messages, and predictable behavior. **Sandbox environment** Hyperline provides a test mode (sandbox environment) where no real money or banking operations are involved. This allows you to test flows without affecting your live data or interacting with the banking networks. Sandbox does not block outbound emails. Actions that send customer or account emails in production can send emails from sandbox to the configured addresses, so use internal or dedicated test addresses. To do this, you can switch on the **test mode** option on your Hyperline account. ## Not a developer? Hyperline offers plenty of options to get started with pricing and billing capabilities without any code implementation. For this, you can check out our [product documentation](../../docs). ## OpenAPI specification The Hyperline API is fully documented using the OpenAPI specification. You can retrieve the complete OpenAPI file to generate client libraries, import into API testing tools, or integrate with your development workflow at: [https://api.hyperline.co/openapi](https://api.hyperline.co/openapi). ## Services endpoints ### Production environment | Service | Base URL | | -------------------- | ------------------------------------------------------------ | | Main API | [https://api.hyperline.co](https://api.hyperline.co) | | Events ingestion API | [https://ingest.hyperline.co](https://ingest.hyperline.co) | | MCP server | [https://api.hyperline.co/mcp](https://api.hyperline.co/mcp) | | Browser application | [https://app.hyperline.co](https://app.hyperline.co) | ### Sandbox environment (test mode) | Service | Base URL | | -------------------- | ---------------------------------------------------------------------------- | | Main API | [https://sandbox.api.hyperline.co](https://sandbox.api.hyperline.co) | | Events ingestion API | [https://sandbox.ingest.hyperline.co](https://sandbox.ingest.hyperline.co) | | MCP server | [https://sandbox.api.hyperline.co/mcp](https://sandbox.api.hyperline.co/mcp) | | Browser application | [https://sandbox.app.hyperline.co](https://sandbox.app.hyperline.co) | # Idempotent requests Source: https://docs.hyperline.co/api-reference/docs/idempotent-requests Safely retry Hyperline API requests using idempotency keys to avoid duplicate operations across customer, subscription, and payment endpoints. The Hyperline API supports idempotency, allowing you to safely retry requests without accidentally performing the same operation twice. This is especially useful when a network error or timeout prevents you from knowing whether a request succeeded. ## How it works Pass a unique `Idempotency-Key` header with any mutating request (`POST`, `PUT`, `PATCH`). If the request succeeds, Hyperline caches the response for **24 hours**. Any subsequent request with the same key returns the cached response instead of re-executing the operation. ``` POST /v1/invoices Idempotency-Key: a8098c1a-f86e-11da-bd1a-00112444be1e ``` ## Generating idempotency keys Use a V4 UUID or any sufficiently random string (at least 16 characters). The key must be unique per **operation intent** — generate a new key for each distinct operation. ```javascript theme={null} const { randomUUID } = require("crypto"); const response = await fetch("https://api.hyperline.co/v1/invoices", { method: "POST", headers: { Authorization: `Bearer ${apiKey}`, "Idempotency-Key": randomUUID(), "Content-Type": "application/json", }, body: JSON.stringify({ customer_id: "cus_123", ... }), }); ``` ## Behavior | Scenario | Result | | ----------------------------------------------- | --------------------------------------------- | | First request with a key | Executes normally, caches response | | Retry with same key and same body | Returns cached response (no re-execution) | | Request with same key but different body or URL | Returns `417 Expectation Failed` | | Concurrent requests with the same key | Returns `409 Conflict` for the second request | ## Error responses **409 Conflict - Request in progress** A request with the same idempotency key is currently being processed. Wait for the original request to complete before retrying. **417 Expectation Failed - Intent mismatch** A completed request exists for this key, but the new request has a different method, URL, or body. This usually means you accidentally reused a key for a different operation. Generate a new key for the new request. ## Best practices * **Generate keys client-side** before sending the request, so retries reuse the same key. * **One key per operation** — do not reuse a key for logically different requests. * **Retry on network errors** — if a request times out, retry with the same key. The operation will not be duplicated. * **Do not retry on 4xx errors** (except 409/429) — these indicate a problem with your request that retrying won't fix. ## Supported endpoints Idempotency keys are accepted on all mutating endpoints (`POST`, `PUT`, `PATCH`). They are ignored on `GET` requests since those are already safe to retry. # Pagination and filtering Source: https://docs.hyperline.co/api-reference/docs/pagination Paginate and filter Hyperline API list endpoints with cursor-based pagination, page sizes, and per-endpoint filter parameters for efficient queries. All list requests can be paginated and filtered using the same query format. For convenience, we've made sure all *list-based* endpoints return data with the same structure. ## Pagination We're using 2 parameters for pagination: * `take` is the number of items the API will return, default is **50**, max is **100** * `skip` is the number of items the API will skip, default is **0** So if you want to get the first 50 items of a list, you don't need any parameters. If you need items from the 350th to the 425th, you'll use `take=75` and `skip=350`. Here's an example with the customer list: ```sh theme={null} curl --request GET \ --url 'https://api.hyperline.co/v1/customers?take=10&skip=10' \ --header 'Authorization: Bearer ' ``` The API will always return a similarly shaped payload containing: * `data` the items you requested * `meta` the contextual information (total number of items, number selected...) For instance for customers: ```json theme={null} { "meta": { "total": 2, "taken": 2, "skipped": 0 }, "data": [ { "id": "cus_3fhwCWcL0Rx5MQ" // other properties }, { "id": "cus_9huL9ahn7KQqHo" // other properties } ] } ``` ## Sorting Some list endpoints support sorting results using the `sort` and `order` query parameters: * `sort` specifies the field to sort by (e.g., `created_at`, `emitted_at`) * `order` specifies the sort direction: `asc` (ascending) or `desc` (descending) For example: ```sh theme={null} curl --request GET \ --url 'https://api.hyperline.co/v1/invoices?sort=emitted_at&order=desc' \ --header 'Authorization: Bearer ' ``` Not all list endpoints support sorting. Refer to each endpoint's documentation to see which sort fields are available. ## Filtering Our API is offering many filtering capabilities so you can always find what you're looking for. Filters are passed as query parameters using a common pattern. `fieldName__operator=value` For instance: * `GET /v1/customers?name__contains=instagram` will return all customers with the name containing instagram * `GET /v1/customers?id__in=123,456,789` will return customers with ID equal to 123, 456, or 789 ## List of available operators * `equals` (or just `=xxx`) * `not` * `lt` * `lte` * `gt` * `gte` * `contains` * `startsWith` * `endsWith` * `in` * `notIn` * `isNull` * `isNotNull` Numerical operators can be applied to numbers or dates. Not all fields can be filtered, please refer to each model in the API Reference to see which ones are available. # Rate limiting Source: https://docs.hyperline.co/api-reference/docs/rate-limiting Understand Hyperline API rate limits, response headers, and best practices to handle 429 responses with retries and exponential backoff strategies. Our API implements rate limiting to ensure fair usage and protect the system from abuse. This page details our rate limiting policies and how to handle them effectively. ## Rate limits ### Core API | Operation type | Limit | Window | | -------------------------------- | ----- | ---------- | | Read (GET) | 200 | 10 seconds | | Write (POST, PUT, PATCH, DELETE) | 50 | 10 seconds | ### Events ingestion API The events ingestion API has separate rate limits: | Operation type | Limit | Window | | -------------- | ----- | ---------- | | All requests | 1,000 | 10 seconds | Additionally, the following payload size limits apply: * **`POST /v1/events/batch`**: maximum of 5,000 events per request * **`DELETE /v1/events`**: maximum of 5,000 event IDs per request ## Rate limit headers API responses include the following rate limit headers: * `X-RateLimit-Limit`: The maximum number of requests allowed in the current window * `X-RateLimit-Remaining`: The number of requests remaining in the current window * `X-RateLimit-Reset`: The date and time when the rate limit window resets * `Retry-After`: The minimum number of seconds to wait before retrying (only when the limit has been reached) ## Handling rate limits When you exceed the rate limit, the API will return a **429 Too Many Requests** HTTP status code. The response body will be: ```json theme={null} Too many requests ``` ### Best practices 1. **Monitor rate limits**: Track the `X-RateLimit-Remaining` header to anticipate when you're approaching the limit 2. **Implement backoff**: When you receive a 429 response: * Wait until the date specified in the `X-RateLimit-Reset` header * Consider implementing exponential backoff for retries 3. **Batch requests**: When possible, combine multiple operations into a single request 4. **Caching**: Cache responses when appropriate to reduce the number of API calls ## Example response headers Rate limit not exceeded: ```text theme={null} HTTP/1.1 200 OK X-RateLimit-Limit: 200 X-RateLimit-Remaining: 150 X-RateLimit-Reset: 2025-04-15T10:18:08.107Z ``` Rate limit exceeded: ```text theme={null} HTTP/1.1 429 Too Many Requests X-RateLimit-Limit: 200 X-RateLimit-Remaining: 0 X-RateLimit-Reset: 2025-04-15T10:18:08.107Z Retry-After: 5 ``` ## Custom rate limits If your application requires higher rate limits, please contact our support team. We'll work with you to establish appropriate limits based on your use case. # React components Source: https://docs.hyperline.co/api-reference/docs/react-components Embed Hyperline checkout, customer portal, and payment method components directly in your React application with the official React SDK. Hyperline provides built-in React components to: * Display a customer's subscriptions * Preview and update the payment method * List and download invoices * List and update billing information This doc assumes that you already have a basic working knowledge of [React](https://react.dev/) and that you have already set up a React project. ## Getting started First install the `@hyperline/react-components` NPM package. ```sh Install the package theme={null} npm install @hyperline/react-components ``` To allow a customer to see their Hyperline data, you need to generate a unique authentication token on your server side. You can use our API and the [create auth token endpoint](../../api-reference/endpoints/integrations/create-component-token) for this. ```sh cURL theme={null} curl -X POST 'https://api.hyperline.co/v1/integrations/components/token' \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer ' \ # You can create an [api key here](https://app.hyperline.co/app/settings/api) -d '{ "customer_id": "" }' ``` Then, integrate the React components. You will most likely generate a new token every time your customer accesses the page. ```ts theme={null} import { Subscriptions, PaymentMethod } from "@hyperline/react-components"; export default function HyperlineSubscriptions() { return ( ", mode: "production" // if you're using our sandbox, set "sandbox" here locale: "en" // optional }} /> ); } export default function HyperlinePaymentMethod() { return ( ", mode: "production" // if you're using our sandbox, set "sandbox" here locale: "en" // optional }} onPaymentMethodCreated={() => do something} // optional, from 0.2.20 onPaymentMethodDeleted={() => do something} // optional, from 0.2.20 /> ); } ``` ## Components ### Subscriptions List all active subscriptions ```tsx theme={null} " }} /> ``` ### Subscription Display a subscription by ID ```tsx theme={null} " }} /> ``` ### InvoicesList List and download all invoices and refunds ```tsx theme={null} " }} /> ``` ### PaymentMethod Display the current payment method, delete it if allowed, or add a new payment method ```tsx theme={null} " }} /> ``` ### CustomerBillingInfoForm Display a form with all billing info, with an optional callback when the form has been successfully saved. ```tsx theme={null} {}} options={{ token: "" }} /> ``` ## Component options When using the components, you will need to provide an `options` prop with the following parameters: | Name | Description | Type | Default value | Required | | ---------- | ----------------------------------------- | --------------------- | ------------- | -------- | | token | The token specific to your customer | string | | ☑️ | | mode | Which Hyperline environment are you using | production \| sandbox | production | | | appearance | Customise the appearance of the component | Object | | | ### Appearance You can change the colors and fonts of the component. ```tsx theme={null} ", appearance: { variables: { borderRadius: "10px", colorBackground: "#000000", colorPrimary: "#e1e2f3", colorPrimaryHover: "#d0d1e5", colorPrimaryDisabled: "#667", colorBorder: "#445", colorText: "#f1f2f3", colorTextSecondary: "#dededf", fontFamily: "sacramento" }, fonts: [ { src: "url(https://fonts.gstatic.com/s/sacramento/v13/buEzpo6gcdjy0EiZMBUG4C0f_f5Iai0.woff2)", family: "sacramento" } ] } }} /> ``` ### Variables They are meant to customise all elements at once. | Variable name | Description | | ---------------------- | ------------------------------------------------------------------------------------------------------------------ | | `borderRadius` | Change the roundness of the elements: Buttons, tables, ... | | `colorBackground` | Most elements have a transparent background. In other cases, you can customise the background color of the element | | `colorPrimary` | Color used for buttons and accent text | | `colorPrimaryHover` | Hover color for buttons | | `colorPrimaryDisabled` | Color of disabled buttons | | `colorBorder` | The color of all our regular borders | | `colorText` | Default text color | | `colorTextSecondary` | Text color of secondary text | | `fontFamily` | Font used. If you need to import a font, please read the next section | ### Fonts Set your application's font. * `src` Url of the font file * `family` Name of the font - this is the name you'll use for the `fontFamily` variable ```ts theme={null} ``` # Third-party app Source: https://docs.hyperline.co/api-reference/docs/third-party-app Build a third-party app that connects to multiple Hyperline accounts via OAuth, with scoped permissions and secure token-based authorization. Hyperline supports the creation of external integrations, so your product can connect with any Hyperline account. This capability allows external apps to build use-cases such as: * Automating or white-labeling billing-specific needs * Allowing your app to view the data of a Hyperline account * Enabling your app to manage the customer base of a Hyperline account * Allowing your app to manage the product catalog of a Hyperline account * Allowing your app to manage recurring subscriptions or one-time payments of a Hyperline account * Fetching invoices from a Hyperline account This list is non-exhaustive and a variety of flows can be built leveraging this kind of app. ## Getting started Hyperline uses the **OAuth** standard to allow your app to access data from a connected account with the user's consent. This prevents having to manually exchange API keys. For example, with the user's consent, using OAuth you can call the subscription API on behalf of your user to create a Hyperline subscription. Our API supports the Authorization Code Grant flow ([RFC 6749 section 4.1](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1)), which allows your application to get separate access tokens for each connected Hyperline account. We recommend using a well-established library for making OAuth requests. You can find some recommendations [here](https://oauth.net/code/). ## Registering your app ### Prerequisites The third-party app creation capability is granted manually by Hyperline. Please contact our support if you are interested and want to enable it. ### Creating an app The first thing you need to do is [create a new app](../../api-reference/endpoints/third-party-apps/create-app) using the Apps API. You will receive a Client ID and Client Secret, both of which should be kept secret. These credentials can be used to: 1. Redirect users to your app's authorization form (Client ID) 2. Exchange auth codes for access tokens (Client ID & Client Secret) 3. Renew your access tokens 4. Deauthorize users from your app (Client ID & Client Secret) Use the create new app API, including the following attributes in a JSON body: * `name`: displayed to the user during the authorization flow * `description` (optional): to show more details to the user * `logo_uri` (optional): to customise the authorization screen with your brand * `callbacks`: URLs whitelisted to use as a callback/redirect after authorization (e.g. a URL within your app that processes authorizations) For now, apps can only be managed (listed, updated, deleted) using our API. ## OAuth flow To initiate the flow, you need to direct your user to [`https://api.hyperline.co/v1/oauth/authorize`](../endpoints/oauth2/authorize) (or `https://sandbox.api.hyperline.co/v1/oauth/authorize`). You must append these four query parameters to the URL: * `client_id`: received upon app registration * `redirect_uri`: where the user will be sent after authorization, it must match the URL you set when registering your app * `response_type=code`: the only supported mode at the moment * `state`: a random string to prevent CSRF attacks that you verify when the user returns to your app - [more information](https://auth0.com/docs/secure/attack-protection/state-parameters) This endpoint will redirect the user to the Hyperline login page. After authorization, the user is redirected to your `redirect_uri` with the `code` and `state` query parameters. You must ensure that the query parameter `state` matches the original state you passed at the start of the flow. If it does, you can exchange the provided code for tokens by making a POST request to [`https://api.hyperline.co/v1/oauth/tokens`](../endpoints/oauth2/generate-tokens) (`https://sandbox.api.hyperline.co/v1/oauth/tokens`), including the following attributes in a JSON body: * `client_id`: as above * `client_secret`: received upon app registration * `grant_type: "authorization_code"` * `code`: as provided in the query parameters * `redirect_uri`: must match the value set at the `1. Authorize` step You'll then receive tokens in the JSON body: ```json Response JSON body theme={null} { "access_token": "", "refresh_token": "", "expires_in": 3600, "token_type": "bearer" } ``` Access tokens must be provided with every API call, specified in the `Authorization` header after a Bearer prefix. For example: ```sh API call using cURL theme={null} curl -H "Authorization: Bearer " https://api.hyperline.co/v1/customers ``` ### Token expiration Access tokens are time limited — you need to refresh them periodically using the refresh token. The time limits are listed below. * Access token: 24h * Refresh token: does not expire automatically (can be revoked) You can use the `expires_in` field to know the number of seconds left before the app access token expires. Be sure to renew it before this reaches zero. ## Managing tokens ### Refresh a token If you wish to renew an access token, you can make a POST request to [`https://api.hyperline.co/v1/oauth/tokens`](../endpoints/oauth2/generate-tokens) (or `https://sandbox.api.hyperline.co/v1/oauth/tokens`), including the following attributes in a JSON body: * `client_id`: received upon app registration * `client_secret`: received upon app registration * `grant_type: "refresh_token"` * `refresh_token`: received during the first authorization flow ### Revoke a token Once issued, access tokens cannot be revoked in the same way as cookies with session IDs for server-side sessions. As a result, tokens should be refreshed periodically if the user remains active. You can revoke refresh tokens in case they become compromised. Simply make a POST request to [`https://api.hyperline.co/v1/oauth/revoke`](../endpoints/oauth2/revoke-token) (or `https://sandbox.api.hyperline.co/v1/oauth/revoke`), including the following attributes in a JSON body: * `client_id`: received upon app registration * `client_secret`: received upon app registration * `token`: refresh token you want to revoke ## Multiple accounts Learn about [multiple accounts](../../docs/getting-started/sandbox#multiple-accounts) on Hyperline. Each access token grants access to all companies associated with the user. To retrieve a list of all user-accessible companies, utilize the [`https://api.hyperline.co/v1/companies`](../endpoints/companies/list-companies) endpoint. For targeting a particular company, include the `Hyperline-CompanyId` header in each API request. If a user has access to multiple companies and you don't specify the `Hyperline-CompanyId` header, the first company (oldest one) linked to the user will be used. We advise including this header by default when constructing a third-party app/flow. # API upgrades Source: https://docs.hyperline.co/api-reference/docs/upgrades Track Hyperline API changes, deprecations, and upgrades — see what's changed across versions and plan migrations for breaking changes safely. ## August 4, 2026 * Added `volume` and `bulk` options on `Product.price_configurations[].type` for credit products on `/v1/products` GET, POST and `/v1/products/{id}` GET, PUT endpoints ## August 3, 2026 * Added `phase_duration` option on `Subscription.phases[].products[].metering_interval_type` on `/v2/subscriptions/{id}` PUT endpoint ## July 31, 2026 * Added `/v1/price-configurations/{id}` GET endpoint * Added `Product.price_configurations[].integrations` on `/v1/products` GET, POST and `/v1/products/{id}` GET, PUT endpoints ## July 29, 2026 * Added `ES-CE` and `ES-ML` country code options to customer, invoicing entity, organisation, product price configuration, and subscription template fields ## July 28, 2026 * Added `/v1/taxes/rates` POST endpoint * Added `/v1/taxes/rates/{id}` PATCH endpoint * Added `/v1/taxes/rates/{id}` DELETE endpoint ## July 22, 2026 * Added `CustomProperty.required` on `/v1/custom-properties` GET, POST and `/v1/custom-properties/{id}` PUT endpoints ## July 21, 2026 * Added `/v1/features/{code}` DELETE endpoint ## July 20, 2026 * Added `/v1/customers/{id}/arr-history` GET endpoint * Added `/v1/subscriptions/{id}/arr-history` GET endpoint ## July 17, 2026 * Added `Coupon.deleted_at` on `/v1/coupons` and `/v1/coupons/{id}` GET endpoints * Deprecation warning * Deprecating `Coupon.deletedAt` in favor of `Coupon.deleted_at` on `/v1/coupons/{id}` GET endpoint. The `deletedAt` field will be removed in a future version. ## July 15, 2026 * Added `/v1/products/{id}` DELETE endpoint * Added `subscription_template_id` and `invoicing_entity_id` approval condition fields on `/v1/approvals/workflows` GET, POST and `/v1/approvals/workflows/{id}` GET, PUT endpoints ## July 10, 2026 * Added `Customer.domain` on `/v1/customers` GET, POST endpoints * Added `Customer.domain` on `/v1/customers/{id}` GET, PUT endpoints * Added `Customer.domain` on `/v1/customers/batch` POST endpoint * Added `Customer.domain` on `/v2/customers` GET endpoint ## July 9, 2026 * Added `Product.accounting[].integrations` on `/v1/products` GET, POST endpoints * Added `Product.accounting[].integrations` on `/v1/products/{id}` GET, PUT endpoints ## July 8, 2026 * Added `Quote.crm_opportunity_id` on `/v1/quotes/{id}` PATCH endpoint ## July 7, 2026 * Added `/v1/invoices/send-email` POST endpoint * Added `Subscription.phases[].products[].children_usage_aggregation` on `/v2/subscriptions` GET endpoint * Added `Subscription.phases[].products[].children_usage_aggregation` on `/v2/subscriptions/{id}` GET, PUT endpoints ## July 3, 2026 * Added `Product.credits_grant_mode` on `/v1/products` GET, POST endpoints * Added `Product.credits_grant_mode` on `/v1/products/{id}` GET, PUT endpoints ## July 2, 2026 * Added `/v1/bank-accounts/{id}/transactions` GET endpoint ## June 30, 2026 * Added `quote.activated` webhook * Added `credit_balances` option on `CreateExport.name` on `/v1/exports` POST endpoint ## June 23, 2026 * Added `Subscription.phases[].name` on `/v2/subscriptions/{id}` GET endpoint * Added `SubscriptionPhase.name` on `/v2/subscriptions/{id}/phases` GET endpoint * Added `SubscriptionPhase.name` on `/v2/subscriptions/{id}/phases/{phaseId}` GET endpoint ## June 19, 2026 * Added `/v1/quotes/templates` GET endpoint * Added `/v1/quotes/templates/{id}` GET endpoint ## June 18, 2026 * Added `/v1/approvals/workflows` GET endpoint * Added `/v1/approvals/workflows` POST endpoint * Added `/v1/approvals/workflows/{id}` GET endpoint * Added `/v1/approvals/workflows/{id}` PUT endpoint * Added `/v1/approvals/workflows/{id}` DELETE endpoint ## June 17, 2026 * Added `/v1/catalog/versions` GET endpoint * Added `/v1/catalog/versions/draft` GET endpoint * Added `/v1/catalog/versions/draft` POST endpoint * Added `/v1/catalog/versions/draft/publish` POST endpoint * Added `/v1/catalog/versions/draft` DELETE endpoint * Added `/v1/catalog/versions/{id}` GET endpoint * Added `/v1/catalog/versions/{id}/revert` POST endpoint * Added `/v1/catalog/export` GET endpoint * Added optional `name` and `description` payload fields on `/v1/catalog/versions/draft` POST endpoint * Added `CatalogSnapshot.format`, `CatalogSnapshot.sourceClientId`, `CatalogSnapshot.exportedAt`, `CatalogSnapshot.checksum`, `CatalogSnapshot.trackedEntityTypes`, and `CatalogSnapshot.resources` on `/v1/catalog/export` GET endpoint * Added wallet debit deletion support on `/v1/invoices/{id}/transactions/{transactionId}` DELETE endpoint * Added `netsuite` option on `provider_name` for `/v1/customers/providers-bulk-update` POST endpoint * Added `Product.price_configurations[].price_book_id` support on `/v1/products` POST endpoint ## June 16, 2026 * Added `contract_clause_ids` on `/v1/quotes` POST endpoint * Added `contract_clause_ids` on `/v1/quotes/{id}` PATCH endpoint * Added `cancellation_reason` on `subscription.cancellation_scheduled` and `subscription.cancelled` webhook payloads ## June 15, 2026 * Added `/v1/quotes/{id}/duplicate` POST endpoint ## June 13, 2026 * Added `payment_method_status`, `smart_segment.payment_risk`, `paid_invoice_count`, `paid_late_invoice_count`, `late_payment_rate`, and `average_late_payment_delay_days` segment condition fields on `/v1/customers/segments` GET, POST, PATCH endpoints ## June 11, 2026 * Added `Product.integrations` on `/v1/products` GET, POST endpoints * Added `Product.integrations` on `/v1/products/{id}` GET, PUT endpoints * Added `Coupon.integrations` on `/v1/coupons` GET, POST endpoints * Added `Coupon.integrations` on `/v1/coupons/{id}` GET, PUT endpoints * Added `SubscriptionCoupon.integrations` on `/v2/subscriptions` GET endpoint * Added `SubscriptionCoupon.integrations` on `/v2/subscriptions/{id}` GET endpoint ## June 9, 2026 * Added `/v1/quotes/{id}/finalize` POST endpoint * Added `last_renewal` option on `SubscriptionTransition.application_schedule` on `/v2/subscriptions/transitions` POST endpoint * Added `last_renewal` option on `SubscriptionTransition.application_schedule` on `/v2/subscriptions/transitions` GET endpoint * Added `last_renewal` option on `SubscriptionTransition.application_schedule` on `/v2/subscriptions/transitions/{id}` GET endpoint * Added `WalletTransaction.comment` on `/v1/wallets/{id}/transactions` GET endpoint * Added `comment`, `bank_account_id`, and `reference` on `/v1/wallets/{id}/load` POST endpoint for paid wallet loads * Added `type` on `/v1/wallets/{id}/load` POST endpoint to distinguish paid and free wallet loads * Added `Aggregator.operation` `sql_formula` option on `/v1/aggregators` GET endpoint * Added `Aggregator.operation` `sql_formula` option on `/v1/aggregators/{id}` GET endpoint * Added `Aggregator.formula_sql` on `/v1/aggregators` GET endpoint * Added `Aggregator.formula_sql` on `/v1/aggregators/{id}` GET endpoint * Added `Aggregator.unit_name` on `/v1/aggregators` GET, POST, PUT endpoints * Added `Product.aggregator.formula_sql` and `Product.aggregator.unit_name` on `/v1/products` GET endpoint * Added `Product.unit_name` support on `/v1/products` POST endpoint for seat, dynamic, and credit products ## June 3, 2026 * Added `Customer.taxability` on `/v1/customers` GET, POST endpoints * Added `Customer.taxability` on `/v1/customers/{id}` GET, PUT endpoints ## June 2, 2026 * Added `/v1/audit-logs` GET endpoint ## June 1, 2026 * Added `/v1/features` GET endpoint * Added `/v1/features/{code}` GET endpoint * Added `/v1/features` POST endpoint * Added `/v1/features/{code}` PUT endpoint * Added `/v1/features/{code}/archive` PUT endpoint * Added `/v1/features/{code}/unarchive` PUT endpoint * Added `/v1/products/{id}/features` GET endpoint * Added `/v1/products/{id}/features/{code}` PUT endpoint * Added `/v1/products/{id}/features/{code}` DELETE endpoint * Added `/v1/customers/{id}/features` GET endpoint * Added `/v1/customers/{id}/features/{code}` PUT endpoint * Added `/v1/customers/{id}/features/{code}` DELETE endpoint ## May 31, 2026 * Added one-off quote creation with `invoice` payload on `/v1/quotes` POST endpoint * Added one-off quote update with `invoice` payload on `/v1/quotes/{id}` PATCH endpoint * Added `Quote.type` `one_off` option on `/v1/quotes` GET endpoint * Added `Quote.type` `one_off` option on `/v1/quotes/{id}` GET endpoint * Added `Quote.invoice_id` on `/v1/quotes` GET endpoint for one-off quotes * Added `Quote.invoice_id` on `/v1/quotes/{id}` GET endpoint for one-off quotes * Added `Coupon.repeat` `duration` option on `/v1/coupons` GET, POST endpoints * Added `Coupon.repeat` `duration` option on `/v1/coupons/{id}` GET, PUT endpoints * Added `Coupon.duration` on `/v1/coupons` GET, POST endpoints * Added `Coupon.duration` on `/v1/coupons/{id}` GET, PUT endpoints * Added `duration_count` and `duration_period` on `/v1/promotion-codes` POST endpoint ## May 29, 2026 * Added `/v1/transactions/{id}/refund` POST endpoint ## May 27, 2026 * Major * Added a hard cap to offset pagination on `/v1/customers` GET and `/v1/invoices` GET endpoints. Requests with `skip + take` greater than `10000` now return `400`; use `/v2/customers` GET or `/v2/invoices` GET cursor pagination for deeper queries. * Draft quote subscription configuration can no longer be updated with `/v2/subscriptions/{id}` PUT endpoint. Use `/v1/quotes/{id}` PATCH endpoint with the `subscription` payload instead. * Added `/v1/quotes/{id}` PATCH endpoint * Added `/v1/aggregators/{id}/usage` GET endpoint * Added `/v1/aggregators/{id}/usage/timeseries` POST endpoint * Added `/v1/aggregators/{id}/usage/group-by-customer` POST endpoint * Added `/v1/aggregators/{id}/usage/events` POST endpoint * Added `/v1/customers/{id}/usage` GET endpoint * Added `/v1/customers/{id}/usage/{aggregator_id}` GET endpoint * Added `/v1/customers/{id}/usage/{aggregator_id}/timeseries` POST endpoint * Added `/v1/customers/{id}/usage/{aggregator_id}/events` POST endpoint ## May 26, 2026 * Added `Invoice.custom_properties` on `/v1/invoices` GET, POST endpoints * Added `Invoice.custom_properties` on `/v1/invoices/{id}` GET, PATCH endpoints * Added `Invoice.custom_properties` support on `/v1/invoices/batch` POST endpoint * Added `Invoice.custom_properties` support on `/v2/invoices/batch` POST endpoint * Added `/v1/invoices/{id}/events` GET endpoint * Added `Subscription.cancellation_source` on `/v2/subscriptions` GET endpoint * Added `Subscription.cancellation_source` on `/v2/subscriptions/{id}` GET endpoint ## May 25, 2026 * Added `/v2/customers` GET endpoint * Added `/v2/customers/{id}` GET endpoint * Deprecation warning * Deprecating `/v1/customers` GET endpoint in favor of `/v2/customers` GET endpoint * Deprecating `/v1/customers/{id}` GET endpoint in favor of `/v2/customers/{id}` GET endpoint ## May 21, 2026 * Added `trigger_refund` and `refund_method` on `/v1/invoices/{id}/credit-notes` POST endpoint * Added `WalletSettings.credit_note_refund_to_wallet_enabled` on `/v1/wallets/settings` GET, PATCH endpoints. When enabled, credit note refunds default to the customer's wallet when `refund_method` is omitted. ## May 20, 2026 * Added `/v2/invoices` GET endpoint * Added `/v2/invoices/{id}` GET endpoint * Deprecation warning * Deprecating `/v1/invoices` GET endpoint in favor of `/v2/invoices` GET endpoint * Deprecating `/v1/invoices/{id}` GET endpoint in favor of `/v2/invoices/{id}` GET endpoint ## April 16, 2026 * Major * Removed `SubscriptionProduct.charging_method` from regular (non-connected) seat products on `/v2/subscriptions` GET endpoint. Field is now only present for connected seat products. * Added `Subscription.invoice_schedule` on `/v2/subscriptions` GET, POST, PUT endpoints * Added `SubscriptionProduct.seat_invoicing_schedule` on `/v2/subscriptions` GET, POST, PUT endpoints ## April 15, 2026 * Added `Subscription.products` on `/v2/subscriptions` GET endpoint * Added `Subscription.coupons` on `/v2/subscriptions` GET endpoint ## April 10, 2026 * Added `/v1/price-books` GET endpoint * Added `/v1/price-books/{id}` GET endpoint * Added `/v1/price-books` POST endpoint * Added `/v1/price-books/{id}` PUT endpoint * Added `/v1/price-books/{id}` DELETE endpoint * Added `/v1/price-books/{id}/products` POST endpoint * Added `/v1/price-books/{id}/products/{productId}` DELETE endpoint * Added `/v1/users` GET endpoint * Added `/v1/users/{id}` GET endpoint * Added `/v1/users/roles` GET endpoint * Added `/v1/users/roles/{id}` GET endpoint ## April 8, 2026 * Added `Quote.require_tax_id` on `/v1/quotes` GET endpoint * Added `Quote.require_tax_id` on `/v1/quotes/{id}` GET endpoint * Added `Quote.require_tax_id` on `/v1/quotes` POST endpoint * Added `SubscriptionTransition.actor` on `/v2/subscriptions/{id}` GET endpoint * Added `SubscriptionTransition.actor` on `/v2/subscriptions` GET endpoint * Added `PriceConfiguration.aggregator_filter_id` on `/v1/price-configurations` GET endpoint * Added `PriceConfiguration.aggregator_filter.aggregator_id` on `/v1/price-configurations` GET endpoint * Added `aggregator_filter_id` support on `/v1/products` PUT endpoint for dynamic price configurations ## April 2, 2026 * Added `Customer.segment_ids` on `/v1/customers` GET endpoint * Added `Customer.segment_ids` on `/v1/customers/{id}` GET endpoint ## March 30, 2026 * Added `Aggregator.thresholds` on `/v1/aggregators` GET, POST, PUT endpoints * Added `Aggregator.default_interval_count` on `/v1/aggregators` GET, POST, PUT endpoints * Added `Aggregator.default_interval_period` on `/v1/aggregators` GET, POST, PUT endpoints ## March 20, 2026 * Major * Changed `PaymentMethod.last_4_digits` from number to string on `/v1/customers/{id}/payment-methods` GET endpoint * Changed `PaymentMethod.last_4_digits` from number to string on `/v1/customers/{id}/payment-methods/{paymentMethodId}` GET endpoint * Changed `PaymentMethod.last_4_digits` from number to string on `/v1/customers/{id}/payment-methods` POST endpoint * Added `Subscription.custom_properties` on `/v2/subscriptions/{id}` PUT endpoint * Added `Provider.slug` on provider endpoints ## March 19, 2026 * Major * Changed `Quote.display_price_tiers` from boolean to enum on `/v1/quotes` GET, POST endpoints. Accepts `all`, `matching`, or `none`. Boolean values are still accepted for backward compatibility (`true` → `all`, `false` → `matching`) ## March 18, 2026 * Added `/v1/subscriptions/{id}/valuation` GET endpoint * Added `/v1/quotes/{id}/valuation` GET endpoint * Added `/v1/customers/{id}/valuation` GET endpoint ## February 18, 2026 * Added `Transaction.integrations` on `/v1/invoices` GET endpoint * Added `Transaction.integrations` on `/v1/invoices/{id}` GET endpoint * Added `Transaction.integrations` on `/v1/invoices` POST endpoint * Added `Transaction.integrations` on `/v2/invoices/simulate` POST endpoint * Added `sort` and `order` query params on `/v1/invoices` GET endpoint (supports `created_at` and `emitted_at`) * Deprecation warning * Deprecating `Transaction.provider_id` in favor of `Transaction.integrations[].entity_id` ## February 10, 2026 * Added `/v2/wallets` GET endpoint * Major Deprecation warning * Deprecating `/v1/wallets` GET endpoint ## February 9, 2026 * Added `/v1/events` GET endpoint * Added `Invoice.line_items[].original_line_item_id` on `/v1/invoices` GET endpoint * Added `Invoice.line_items[].original_line_item_id` on `/v1/invoices/{id}` GET endpoint ## February 5, 2026 * Added `/v2/invoices/batch` POST endpoint * Added `invoice.batch.creation_succeeded`, `invoice.batch.creation_failed` webhooks ## January 29, 2026 * Added `/v1/wallets/{id}/transactions/{transactionId}/revert` POST endpoint * Added `WalletTransaction.original_transaction_id` on `/v1/wallets/{id}/transactions` GET endpoint * Added `WalletTransaction.reverted_by` on `/v1/wallets/{id}/transactions` GET endpoint ## January 28, 2026 * Added `Invoice.line_items[].display_unit_amount` on `/v1/invoices` GET, POST endpoints * Added `Invoice.line_items[].display_unit_amount` on `/v1/invoices/{id}` GET, PATCH endpoints * Added `Invoice.line_items[].display_service_period` on `/v1/invoices` GET, POST endpoints * Added `Invoice.line_items[].display_service_period` on `/v1/invoices/{id}` GET, PATCH endpoints ## January 26, 2026 * Added `Customer.custom_payment_initiation_delay` on `/v1/customers` GET, POST endpoints * Added `Customer.custom_payment_initiation_delay` on `/v1/customers/{id}` GET, PUT endpoints * Added `InvoicingEntity.registration_number` on `/v1/invoicing-entities` GET, POST endpoints * Added `InvoicingEntity.registration_number` on `/v1/invoicing-entities/{id}` GET, PUT endpoints ## January 11, 2026 * Added `Subscription.display_quote_value`, `Subscription.display_taxes`, `Subscription.display_price_tiers`, `Subscription.display_phase_value`, `Subscription.display_first_invoice_amount`, `Subscription.display_documents_in_preview`, `Subscription.display_subscription_on_update` on `/v2/subscriptions` GET, POST endpoints ## January 9, 2026 * Added `/v2/subscriptions/transitions` POST endpoint * Added `/v2/subscriptions/transitions` GET endpoint * Added `/v2/subscriptions/transitions/{id}` GET endpoint * Added `/v2/subscriptions/transitions/{id}/cancel` POST endpoint * Added `subscription_transition.completed` webhook ## December 30, 2025 * Added `auto_load_threshold` field to wallet endpoints ## December 18, 2025 * Added `wallet.low_projected_balance` webhook ## December 11, 2025 * Added `Customer.tax_ids` and `Customer.tax_rate_custom` on `/v1/customers` GET, POST endpoints * Added `Customer.tax_ids` and `Customer.tax_rate_custom` on `/v1/customers/{id}` GET, PUT endpoints * Added `Invoice.customer.tax_id` on `/v1/invoices` GET endpoint * Added `Invoice.customer.tax_id` on `/v1/invoices/{id}` GET endpoint * Major Deprecation warning * Deprecating `Customer.vat_number` and `Customer.vat_number_valid` in favor of `Customer.tax_ids` * Deprecating `Customer.vat_rate_custom` in favor of `Customer.tax_rate_custom` * Deprecating `Invoice.customer.vat_number` in favor of `Invoice.customer.tax_id` ## December 4, 2025 * Added `custom_properties` query param on `/v2/subscriptions` GET endpoint ## December 1, 2025 * Added `Customer.shipping_address` on `/v1/customers` GET, POST endpoints * Added `Customer.shipping_address` on `/v1/customers/{id}` GET, PUT endpoints ## November 28, 2025 * Added `Invoice.public_url` on `/v1/invoices/{id}` GET endpoint ## November 19, 2025 * Added `/v1/exports` POST endpoint * Added `/v1/exports/{id}` GET endpoint * Added `/v1/exports/{id}/download` GET endpoint ## October 31, 2025 * Added `/v1/customers/{id}/credits/{id}` PUT endpoint ## October 23, 2025 * Added `Invoice.coupons` on `/v1/invoices` POST endpoint * Added `Invoice.coupons` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.coupons` on `/v1/invoices/batch` POST endpoint ## October 16, 2025 * Added `Coupon.product_ids` on `/v1/coupons` GET endpoint * Added `Coupon.product_ids` on `/v1/coupons` POST endpoint * Added `Coupon.product_ids` on `/v1/coupons/{id}` GET endpoint * Added `Coupon.product_ids` on `/v1/coupons/{id}` PUT endpoint * Added `/v1/subscriptions/templates` GET endpoint * Added `/v1/subscriptions/templates/{id}` GET endpoint * Added `Subscription.template_id` on `/v2/subscriptions` POST endpoint * Added `Subscription.template_configuration_id` on `/v2/subscriptions` POST endpoint * Major Deprecation warning * Deprecating `/v1/plans` GET endpoint * Deprecating `/v1/plans/{id}` GET endpoint ## October 1, 2025 * Added `product_id`, `customer_id`, `updated_at` query params on `/v1/customers/credits` GET endpoint ## September 30, 2025 * Added `Customer.is_government_affiliated` on `/v1/customers` POST, GET, PUT endpoints ## September 26, 2025 * Added `/v1/customers/credits` GET endpoint * Added `Credit.auto_topup` on `/v1/customers/{id}/credits` POST, GET endpoints * Added `Credit.auto_topup` on `/v1/customers/{id}/credits/{creditId}` GET endpoint ## September 23, 2025 * Added `/v1/quotes/{id}/approve` POST endpoint ## September 19, 2025 * Added `Customer.integrations` on `/v1/customers` GET endpoint ## September 16, 2025 * Added `period_start` and `period_end` query params on `/v1/invoices` GET endpoint ## September 15, 2025 * Added `Subscription.activation_strategy` on `/v2/subscriptions` GET endpoint ## September 11, 2025 * Added `Subscription.phases[].do_not_invoice_phase` on `/v2/subscriptions/{id}` GET endpoint * Added `Subscription.phases[].do_not_invoice_phase` on `/v2/subscriptions` POST endpoint * Added `Subscription.phases[].do_not_invoice_phase` on `/v2/subscriptions/{id}` PUT endpoint ## September 10, 2025 * Added `/v1/invoices/{id}/uncollectible` POST endpoint ## September 5, 2025 * Added `Subscription.phases` on `/v2/subscriptions/{id}` PUT endpoint ## August 27, 2025 * Added `Invoice.source` on `/v1/invoices` GET endpoint * Added `Invoice.source` on `/v1/invoices/{id}` GET endpoint ## August 25, 2025 * Added `/v1/bank-accounts` GET endpoint * Added `/v1/bank-accounts/{id}` GET endpoint ## August 18, 2025 * Added `/v1/subscriptions/{id}/simulate-updates` POST endpoint * Added `plan.created`, `plan.updated` and `plan.deleted` webhooks ## August 8, 2025 * Added `Quote.updated_at` on `/v1/quotes` GET endpoint * Added `Quote.updated_at` on `/v1/quotes/{id}` GET endpoint * Added `PriceConfiguration.price_book_id` on `/v1/price-configurations` GET endpoint ## July 21, 2025 * Added `Subscription.crm_opportunity_id` on `/v2/subscriptions` POST endpoint * Added `Subscription.crm_opportunity_id` on `/v2/subscriptions/{id}` PUT endpoint ## July 17, 2025 * Added `reason` on `/v1/subscriptions/{id}/cancel` POST endpoint * Added `Subscription.cancellation_reason` on `/v2/subscriptions` GET endpoint * Added `Subscription.cancellation_reason` on `/v2/subscriptions/{id}` GET endpoint ## July 11, 2025 * Added `/v1/customers/{id}/payment-methods` POST endpoint * Added `Transaction.provider_name` and `Transaction.provider_transaction_id` on `/v1/invoices/{id}/transactions` POST endpoint ## July 7, 2025 * Added `/v1/files` GET, POST endpoints * Added `/v1/files/{id}` DELETE endpoint * Added `/v1/files/{id}/download` GET endpoint * Added `Invoice.properties` on `/v1/invoices` GET, POST endpoints * Added `Invoice.properties` on `/v1/invoices/{id}` GET, PATCH endpoints ## July 3, 2025 * Added `/v1/subscriptions/{id}/renew` POST endpoint ## June 27, 2025 * Added `Invoice.coupons` and `Invoice.transactions` on `/v1/invoices` GET endpoint ## June 18, 2025 * Added `Subscription.name` on `/v2/subscriptions/{subscriptionId}` GET endpoint * Added `Subscription.name` on `/v2/subscriptions` GET endpoint ## June 13, 2025 * Added `Subscription.generate_document`, `Subscription.document_name` and `Subscription.add_vat_to_document` on `/v2/subscriptions` POST endpoint ## June 11, 2025 * Added `/v1/invoices/{id}/credit-notes` POST endpoint * Added `Invoice.integrations` on `/v1/invoices/{id}` GET endpoint * Added `Customer.integrations` on `/v1/customers/{id}` GET endpoint * Added `PaymentMethod.integration` on `/v1/customers/{id}/payment-methods/{id}` GET endpoint * Major Deprecation warning * Deprecating `Customer.providers` in favor of `Customer.integrations` ## June 6, 2025 * Added `/v1/price-configurations` GET endpoint * Added `/v1/price-configurations/{id}` DELETE endpoint ## May 16, 2025 * Added `purchase_order` query param on `/v2/subscriptions` GET endpoint ## May 9, 2025 * Added `/v1/promotion-codes` GET, POST endpoints * Added `/v1/promotion-codes/{id}` GET, PATCH, DELETE endpoints ## April 30, 2025 * Added `Subscription.contract_terms` on `/v2/subscriptions/{subscriptionId}` GET endpoint * Added `Subscription.contract_terms` on `/v2/subscriptions` POST endpoint * Added `Quote.subscription.contract_terms` on `/v1/quotes` POST endpoint * Added `Invoice.bank_account_id` on `/v1/invoices/{id}` GET endpoint * Added `Invoice.bank_account_id` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.payment_method_type` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.payment_method_id` on `/v1/invoices/{id}` PATCH endpoint ## April 18, 2025 * Added `Subscription.billing_cycle_alignment` on `/v2/subscriptions` POST endpoint ## April 8, 2025 * Added `Invoice.type` on `/v1/invoices` POST endpoint * Added `Invoice.type` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.document_name` on `/v1/invoices` POST endpoint * Added `Invoice.document_name` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.tax_scheme` on `/v1/invoices` POST endpoint * Added `Invoice.tax_scheme` on `/v1/invoices/{id}` PATCH endpoint * Added `Invoice.line_items` on `/v1/invoices/{id}` PATCH endpoint ## April 4, 2025 * Added `Subscription.trial` on `/v2/subscriptions` POST endpoint * Added `Quote.subscription.trial` on `/v1/quotes` POST endpoint * Major Deprecation warning * Deprecating `Subscription.trial_ends_at` and `Subscription.trial_delay_first_invoice` in favor of `Subscription.trial` * Deprecating `Quote.subscription.trial_ends_at` and `Quote.subscription.trial_delay_first_invoice` in favor of `Quote.subscription.trial` ## March 31, 2025 * Added `/v1/invoices/{id}/charge` POST endpoint * Added `Invoice.transactions[].chargeback` on `/v1/invoices/{id}` GET endpoint * Added `Subscription.phases[].billing_cycle_alignment` on `/v2/subscriptions/{subscriptionId}` GET endpoint * Added `SubscriptionPhase.billing_cycle_alignment` on `/v2/subscriptions/{subscriptionId}/phases` GET endpoint * Added `SubscriptionPhase.billing_cycle_alignment` on `/v2/subscriptions/{subscriptionId}/phases/{phaseId}` GET endpoint * Added `Subscription.phases[].billing_cycle_alignment` on `/v2/subscriptions` POST endpoint * Added `Quote.subscription.phases[].billing_cycle_alignment` on `/v1/quotes` POST endpoint * Added `subscription.reinstated` webhook ## March 24, 2025 * Added `PaymentMethod.status` on `/v1/customers/{id}/payment-methods` GET endpoint * Added `PaymentMethod.status` on `/v1/customers/{id}/payment-methods/{paymentMethodId}` GET endpoint * Added `Customer.price_book_id` on `/v1/customers` GET endpoint * Added `Customer.price_book_id` on `/v1/customers/{id}` GET endpoint ## March 11, 2025 * Added `/v1/products/{id}/archive` PUT endpoint * Added `/v1/products/{id}/unarchive` PUT endpoint ## March 6, 2025 * Added `/v1/invoices/{id}/transactions` POST endpoint * Added `/v1/invoices/{id}/transactions/{transactionId}` DELETE endpoint * Added `provider_id` on `/v1/customers/providers-bulk-update` POST endpoint ## February 27, 2025 * Added `Subscription.phases` on `/v2/subscriptions` POST endpoint * Added `Subscription.phases` on `/v2/subscriptions/{id}` GET endpoint ## February 4, 2025 * Added `Invoice.payment_method_id` on `/v1/invoices` POST endpoint * Added `Invoice.line_items[].tax_rate` on `/v1/invoices` POST endpoint ## January 28, 2025 * Added `Invoice.line_items[].product_id` on `/v1/invoices` POST endpoint ## January 15, 2025 * Added `Subscription.quote` on `/v2/subscriptions/{id}` GET endpoint ## January 14, 2025 * Added `/v2/subscriptions/{id}/phases` GET endpoint * Added `/v2/subscriptions/{id}/phases/{phaseId}` GET endpoint * Added `Subscription.current_phase_id` on `/v2/subscriptions` GET endpoint * Added `Subscription.current_phase_id` on `/v2/subscriptions/{id}` GET endpoint ## January 10, 2025 * Added `Quote.original_subscription_id` on `/v1/quotes` GET endpoint * Added `Quote.original_subscription_id` on `/v1/quotes/{id}` GET endpoint ## January 8, 2025 * Added `/v1/invoices/{id}` DELETE endpoint ## November 6, 2024 * Added `/v1/customers/{id}/unarchive` PUT endpoint * Added `/v1/invoices/{id}` PATCH endpoint * Added `/v1/subscriptions/{id}/activate` POST endpoint ## October 23, 2024 * Added `/v1/customers/{id}/payment-methods` GET endpoint * Added `/v1/customers/{id}/payment-methods/{paymentMethodId}` GET, DELETE endpoints ## October 8, 2024 * Added `/v1/companies` POST endpoint ## August 21, 2024 * Added `custom_property.created`, `custom_property.updated`, `custom_property.deleted`, `custom_property.value_created`, `custom_property.value_updated`, `bank_account.created`, `bank_account.deleted` webhooks ## August 20, 2024 * Added `/v1/taxes/rates` GET endpoint * Added `/v1/taxes/rates/{id}` GET endpoint * Added `Product.accounting` on `/v1/products/{id}` GET, POST, PUT endpoints * Added `Invoice.line_items[].tax_rate_id` on `/v1/invoices` GET endpoint * Added `Invoice.line_items[].tax_rate_id` on `/v1/invoices/{id}` GET endpoint * Added `Customer.custom_payment_delay` on `/v1/customers` GET endpoint * Added `Customer.custom_payment_delay` on `/v1/customers/{id}` GET, POST, PUT endpoints ## August 12, 2024 * Added `Subscription.custom_properties` on `/v2/subscriptions` GET, POST endpoints * Added `Subscription.custom_properties` on `/v2/subscriptions/{id}` GET, PUT endpoints ## August 7, 2024 * Added `/v1/quotes/{id}/sign` POST endpoint * Added `/v1/invoices/{id}/void` POST endpoint ## July 30, 2024 * Added `Customer.timezone` on `/v1/customers` GET, POST endpoints * Added `Customer.timezone` on `/v1/customers/{id}` GET, PUT endpoints ## July 3, 2024 * Added `/v1/organisations/{id}` GET endpoint * Added `/v1/organisations/{id}` PATCH endpoint * Added `Customer.organisation_id` and `Customer.organisation_invoicing` on `/v1/customers` POST endpoint * Added `Customer.organisation_id` and `Customer.organisation_invoicing` on `/v1/customers/{id}` GET, PUT endpoints * Added `Subscription.contract_start` and `Subscription.contract_end` on `/v2/subscriptions/*` endpoints * Added `Subscription.products[].attached_at` and `Subscription.products[].detached_at` on `/v2/subscriptions/*` endpoints * Added `/v1/subscriptions/{id}/reinstate` POST endpoint * Added `update_prices` `SubscriptionUpdate.type` on `/v1/subscriptions/{id}/update` POST endpoint * Added `/v1/subscriptions/{id}/update-many` POST endpoint * Major Deprecation warning * Deprecating `Subscription.starts_at` in favor of `Subscription.contract_start` * Major * Removing `SubscriptionUpdate.payload.billing_item_ids` in favor of `SubscriptionUpdate.payload.product_ids` for `add_coupon` update type * Removing `add_item` `SubscriptionUpdate.type` in favor of `add_product` * Removing `remove_item` `SubscriptionUpdate.type` in favor of `remove_product` ## June 26, 2024 * Added `/v1/quotes` POST endpoint * Added `/v1/quotes/{id}/download` GET endpoint * Added `/v1/quotes/{id}/send` POST endpoint * Added `/v1/quotes/{id}/void` POST endpoint ## June 12, 2024 * Added `Customer.custom_properties` on `/v1/customers` GET endpoint ## May 27, 2024 * Added `/v1/quotes` GET endpoint * Added `/v1/quotes/{id}` GET endpoint * Added `/v1/quotes/{quoteId}/files/{id}/download` GET endpoint ## April 2, 2024 * Major Removed deprecated subscription endpoints * Removed `GET /v1/subscriptions` in favor of `GET /v2/subscriptions` * Removed `GET /v1/subscriptions/{id}` in favor of `GET /v2/subscriptions/{id}` * Removed `POST /v1/subscriptions` in favor of `POST /v2/subscriptions` * Removed `GET /v1/billing-plans/{id}` in favor of `GET /v1/plans/{id}` * Removed `GET /v1/billing-scenarios` * Removed `GET /v1/billing-scenarios/{id}` ## March 6, 2024 * Added `/v1/subscriptions/{id}/pause` PUT endpoint * Added `/v1/subscriptions/{id}/reactivate` PUT endpoint * Added `/v1/subscriptions/refresh` POST endpoint ## March 5, 2024 * Added `/v1/webhooks/endpoints` GET, POST endpoints * Added `/v1/webhooks/endpoints/{id}` GET, PUT, DELETE endpoints ## March 1, 2024 * Major Removed unit concept on wallets (only money pocket) in favor of credit-type products to manage credit units. * Removed `WalletBalance.units` * Removed `WalletSettings.unit_credit_prices` * Removed `WalletTransaction.units` and `WalletTransaction.transaction_id` ## February 28, 2024 * Major Removed unique current customer subscription in favor of subscriptions array. * Removed `Customer.current_subscription_id` on `/v1/customers` GET endpoint * Removed `Customer.current_subscription` on `/v1/customers/{id}` GET endpoint ## February 20, 2024 * Added `Customer.type` on `/v1/customers` GET, POST and PUT endpoints * Added `Customer.invoice_emails` on `/v1/customers` GET, POST and PUT endpoints * Added `Customer.vat_rate_custom` on `/v1/customers` GET, POST and PUT endpoints * Added `external` option on `Customer.payment_method_type` on `/v1/customers` POST and PUT endpoints ## February 16, 2024 * Major Planned for April 1, 2024 * Removing `GET /v1/subscriptions` in favor of `GET /v2/subscriptions` * Removing `GET /v1/subscriptions/{id}` in favor of `GET /v2/subscriptions/{id}` * Removing `POST /v1/subscriptions` in favor of `POST /v2/subscriptions` * Major Planned for February 28, 2024 * Removing `Customer.current_subscription_id` on `/v1/customers` GET endpoint in favor of `Customer.subscriptions` * Removing `Customer.current_subscription` on `/v1/customers/{id}` GET endpoint in favor of `Customer.subscriptions` # Webhooks Source: https://docs.hyperline.co/api-reference/docs/webhooks Receive webhook messages from Hyperline for customer, subscription, invoice, and payment events with signing, delivery, and retry guidance. Webhooks are automated messages sent from Hyperline when something happens on our system. They have a specific payload for each action they notify and are sent to a unique URL, an HTTPS endpoint on your server. Webhooks are a great way to integrate your application with Hyperline as you can fine-tune product flows and build deeper integrations based on your needs, with little development work on your end. ## Add a webhook endpoint To start listening to webhook messages sent by Hyperline, go to your [webhooks settings](https://app.hyperline.co/app/settings/webhooks) in the app, select **Add Endpoint**, provide the termination URL that you control, and select the event types you want to listen to. You can add as many URLs as you want, if you want to segregate the events you want to listen to. That's it! You will now receive webhook calls when the event occurs on the Hyperline system. ## Event types A complete list of the event types and the shape of the event payload can be found in the product Webhooks page, on the "Event Catalog" tab. Here is a preview of the events you can be notified of: * `customer.created`, `customer.updated`, `customer.archived`, `customer.recovered`, `customer.deleted` * `subscription.created`, `subscription.trial_ended`, `subscription.activated`, `subscription.reactivated`, `subscription.contract_started`, `subscription.contract_renewed`, `subscription.paused`, `subscription.phase_activated`, `subscription.updated`, `subscription.cancellation_scheduled`, `subscription.cancelled`, `subscription.voided`, `subscription.errored`, `subscription.charged`, `subscription.commitment_renewed`, `subscription.reinstated`, `subscription.analytics_updated` * `subscription_transition.completed` * `invoice.created`, `invoice.grace_period.started`, `invoice.late`, `invoice.ready`, `invoice.reminder_sent`, `invoice.settled`, `invoice.errored`, `invoice.chargeback`, `invoice.voided`, `invoice.uncollectible`, `invoice.deleted` * `invoice.batch.creation_succeeded`, `invoice.batch.creation_failed` * `credit_note.ready`, `credit_note.settled`, `credit_note.voided` * `checkout.created`, `checkout.completed` * `payment_method.created`, `payment_method.activated`, `payment_method.errored`, `payment_method.deleted`, `payment_method.expiring_soon`, `payment_method.expired` * `wallet.credited`, `wallet.debited`, `wallet.low_projected_balance` * `credit.created`, `credit.updated`, `credit.balance_refreshed`, `credit.low_balance`, `credit.balance_at_zero`, `credit.topup_transaction_created`, `credit.usage_transaction_created`, `credit.expiration_transaction_created` * `quote.created`, `quote.updated`, `quote.approval_requested`, `quote.approved`, `quote.sent`, `quote.viewed`, `quote.signed`, `quote.voided` * `bank_account.created`, `bank_account.deleted`, `bank_account.errored` * `custom_property.created`, `custom_property.updated`, `custom_property.deleted`, `custom_property.value_created`, `custom_property.value_updated` * `product.created`, `product.updated`, `product.archived`, `product.recovered`, `product.deleted` * `plan.created`, `plan.updated`, `plan.deleted` * `coupon.created`, `coupon.updated`, `coupon.deleted` * `pricebook.created`, `pricebook.updated`, `pricebook.deleted` * `approval_workflow.created`, `approval_workflow.updated`, `approval_workflow.deleted` * `approval_request.created`, `approval_request.step_approved`, `approval_request.step_rejected`, `approval_request.approved`, `approval_request.rejected`, `approval_request.cancelled` * `daily_analytics.ready` * `dataloader.failed` * `aggregator.updated`, `aggregator.threshold_crossed` * `event.price_calculated` * `agent.run.completed` Checkout sessions do not expire automatically, so Hyperline does not emit a `checkout.expired` event. A checkout remains open until it is completed, cancelled, or errored. ## Consuming webhooks Webhook calls will always be `POST` HTTPS requests containing a JSON body with this format: ```json theme={null} { "event_type": ".", "data": {} } ``` Your endpoint must quickly return a 2xx (status code 200-299) response prior to any complex logic that could cause a timeout (max 15s). Another important aspect of handling webhooks is to verify the signature and timestamp when processing them. ## Testing events The easiest way to be more confident in your endpoint configuration is to start receiving events as quickly as possible. The "Testing" tab is here to help you send example events to your endpoint. After sending an example event, you can select the message to view the message payload, all of the message attempts, and whether it succeeded or failed. Additionally, the Logs section is here to help you have a complete view of past call attempts with their date, status, and payload. ## Event delivery ### Replaying events If you want to replay a single (or multiple) events, you can find the message from the UI, open the options menu next to any of the attempts, and select **Resend**. It's a great help if your service had downtime or if your endpoint was misconfigured. ### Retry schedule Each message is attempted based on the following schedule, where each period is started following the failure of the preceding attempt: * Immediately * 5 seconds * 5 minutes * 30 minutes * 2 hours * 5 hours * 10 hours * 10 hours (in addition to the previous) If an endpoint is removed or disabled, delivery attempts to the endpoint will be disabled as well. ### Event ordering Hyperline doesn't guarantee delivery of events in the order in which they're generated. You can find more details about why guaranteeing order doesn't really work in [this article](https://www.svix.com/blog/guaranteeing-webhook-ordering). Your endpoint shouldn't expect delivery of events in a specific order. We recommend designing your system in a way that doesn't require ordering. Additionally, you can use the API to fetch any missing objects (for example, you can fetch the subscription details using the ID provided in the `subscription.created` event payload). ### Static source IP addresses In case your webhook receiving endpoint is behind a firewall or NAT, you may need to allow traffic from our webhook servers' static IP addresses. In such scenarios, we recommend that you whitelist the following IP addresses: ``` 52.215.16.239 54.216.8.72 63.33.109.123 2a05:d028:17:8000::/56 ``` ## Best practices ### Handling duplicate events Webhook endpoints might occasionally receive the same event more than once. You can guard against duplicated event receipts by making your event processing [idempotent](https://en.wikipedia.org/wiki/Idempotence). One way of doing this is logging the events you've processed, and then not processing already-logged events. ### Prevent stale data As webhooks can be retried, another update can occur once your server is finally able to process the event. Therefore, we advise you to query the latest version of the related entity upon receiving a webhook. ### Verify webhooks Verifying webhooks is an important part of the consumption. Because of the way webhooks work, attackers can impersonate services by simply sending a fake webhook to an endpoint. This is a potential security hole for your application. In order to prevent it, every webhook and its metadata is **signed** with a unique key for each endpoint. This signature can then be used to verify the webhook indeed comes from Hyperline, and only process it if it is. Another potential security hole is what's called replay attacks. A replay attack is when an attacker intercepts a valid payload (including the signature), and re-transmits it to your endpoint. This payload will pass signature validation, and will therefore be acted upon. To mitigate this attack, a timestamp (`webhook-timestamp` header) is included in every request for when the webhook attempt occurred. We recommend you reject webhooks with a timestamp that is more than five minutes away (past or future) from the current time. **Verifying signatures** Each webhook call includes three headers with additional information that are used for verification: * `webhook-id`: the unique message identifier for the webhook message. This identifier is unique across all messages but will be the same when the same webhook is being resent (e.g. due to a previous failure). * `webhook-timestamp`: timestamp in seconds since epoch. * `webhook-signature`: the Base64 encoded list of signatures (space delimited). **Constructing the signed content** The content to sign is composed by concatenating the id, timestamp, and payload, separated by the full-stop character (`.`). In code, it will look something like: ``` signedContent = "${webhook_id}.${webhook_timestamp}.${body}" ``` Where `body` is the raw body of the request. The signature is sensitive to any changes, so even a small change in the body will cause the signature to be completely different. This means that you should not change the body in any way before verifying. **Determining the expected signature** `HMAC` with `SHA-256` is used to sign webhooks. So to calculate the expected signature, you should HMAC the `signed_content` from above using the base64 portion of your signing secret (this is the part after the `whsec_` prefix) as the key. For example, given the secret `whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw` you will want to use `MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw`. Here is an example of how you can calculate the signature in Node.js: ```js theme={null} const crypto = require("crypto"); const signedContent = `${webhook_id}.${webhook_timestamp}.${body}`; const secret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw"; // Need to base64 decode the secret const secretBytes = new Buffer(secret.split("_")[1], "base64"); const signature = crypto .createHmac("sha256", secretBytes) .update(signedContent) .digest("base64"); console.log(signature); ``` This generated signature should match one of the ones sent in the `webhook-signature` header. This header is composed of a list of space-delimited signatures and their corresponding version identifiers. The signature list is most commonly of length one, though there could be any number of signatures. For example: ``` v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE= v1,bm9ldHUjKzFob2VudXRob2VodWUzMjRvdWVvdW9ldQo= v2,MzJsNDk4MzI0K2VvdSMjMTEjQEBAQDEyMzMzMzEyMwo= ``` Make sure to remove the version prefix and delimiter (e.g. v1,) before verifying the signature. # Create accounting rule Source: https://docs.hyperline.co/api-reference/endpoints/accounting/create-accounting-rule post /v1/accounting/rules Create a new accounting rule for account code routing or journal posting. # Delete accounting rule Source: https://docs.hyperline.co/api-reference/endpoints/accounting/delete-accounting-rule delete /v1/accounting/rules/{id} Soft-delete an accounting rule. # Get accounting rule Source: https://docs.hyperline.co/api-reference/endpoints/accounting/get-accounting-rule get /v1/accounting/rules/{id} Retrieve a single accounting rule by its identifier. # List accounting rules Source: https://docs.hyperline.co/api-reference/endpoints/accounting/list-accounting-rules get /v1/accounting/rules Retrieve existing accounting rules with optional filtering. # Resolve accounting rule Source: https://docs.hyperline.co/api-reference/endpoints/accounting/resolve-accounting-rule post /v1/accounting/rules/resolve Preview which account codes would be resolved for a given context. # Update accounting rule Source: https://docs.hyperline.co/api-reference/endpoints/accounting/update-accounting-rule put /v1/accounting/rules/{id} Update an existing accounting rule. # Get aggregator usage Source: https://docs.hyperline.co/api-reference/endpoints/aggregators->-usage/get-aggregator-usage get /v1/aggregators/{id}/usage Retrieve a usage row for an aggregator (name, unit and thresholds). # Get aggregator usage events Source: https://docs.hyperline.co/api-reference/endpoints/aggregators->-usage/get-aggregator-usage-events get /v1/aggregators/{id}/usage/events List raw billable events for an aggregator across every customer of the client. # Get aggregator usage grouped by customer Source: https://docs.hyperline.co/api-reference/endpoints/aggregators->-usage/get-aggregator-usage-grouped-by-customer get /v1/aggregators/{id}/usage/group-by-customer Per-customer total usage for an aggregator over a period, ordered by total DESC, paginated. # Get aggregator usage timeseries Source: https://docs.hyperline.co/api-reference/endpoints/aggregators->-usage/get-aggregator-usage-timeseries get /v1/aggregators/{id}/usage/timeseries Get client-wide usage for an aggregator bucketed by month, day or hour. # Create aggregator Source: https://docs.hyperline.co/api-reference/endpoints/aggregators/create-aggregator post /v1/aggregators Create a new aggregator. # Delete aggregator Source: https://docs.hyperline.co/api-reference/endpoints/aggregators/delete-aggregator delete /v1/aggregators/{id} Delete an existing aggregator. # Get aggregator Source: https://docs.hyperline.co/api-reference/endpoints/aggregators/get-aggregator get /v1/aggregators/{id} Retrieve the details of an existing aggregator. # List aggregators Source: https://docs.hyperline.co/api-reference/endpoints/aggregators/list-aggregators get /v1/aggregators Retrieve existing aggregators. # Update aggregator Source: https://docs.hyperline.co/api-reference/endpoints/aggregators/update-aggregator put /v1/aggregators/{id} Update the details of an existing aggregator. # Get analytics Source: https://docs.hyperline.co/api-reference/endpoints/analytics/get-analytics get /v1/analytics Retrieve your pre-computed account's analytics (ARR, revenues, churn, etc). # Create approval workflow Source: https://docs.hyperline.co/api-reference/endpoints/approval-workflows/create-approval-workflow post /v1/approvals/workflows Create a new approval workflow. # Delete approval workflow Source: https://docs.hyperline.co/api-reference/endpoints/approval-workflows/delete-approval-workflow delete /v1/approvals/workflows/{id} Delete an existing approval workflow. # Get approval workflow Source: https://docs.hyperline.co/api-reference/endpoints/approval-workflows/get-approval-workflow get /v1/approvals/workflows/{id} Retrieve a single approval workflow. # List approval workflows Source: https://docs.hyperline.co/api-reference/endpoints/approval-workflows/list-approval-workflows get /v1/approvals/workflows Retrieve approval workflows with optional filtering. # Update approval workflow Source: https://docs.hyperline.co/api-reference/endpoints/approval-workflows/update-approval-workflow put /v1/approvals/workflows/{id} Update an existing approval workflow. # List audit logs Source: https://docs.hyperline.co/api-reference/endpoints/audit-logs/list-audit-logs get /v1/audit-logs Retrieve existing audit logs. Sorted by `happened_at` descending. # Get bank account Source: https://docs.hyperline.co/api-reference/endpoints/bank-accounts/get-bank-account get /v1/bank-accounts/{id} Retrieve a specific bank account by ID. # List bank accounts Source: https://docs.hyperline.co/api-reference/endpoints/bank-accounts/list-bank-accounts get /v1/bank-accounts Retrieve existing bank accounts. # List bank transactions Source: https://docs.hyperline.co/api-reference/endpoints/bank-accounts/list-bank-transactions get /v1/bank-accounts/{id}/transactions Retrieve transactions for a specific connected bank account. # Delete billable events Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/delete-billable-events delete /v1/events Delete existing billable events. # Get billable event prices Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/get-billable-event-prices get /v1/events/prices Get previous price simulation results for a billable event. You can search by either calculation_id / record_id or both. # Get events Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/get-events get /v1/events Retrieve billable events filtered by event type. # Ingest billable event Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/ingest-billable-event post /v1/events Ingest a new billable event. This endpoint is idempotent, an event with the same id will be updated if it already exists. # Ingest billable events Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/ingest-billable-events post /v1/events/batch Ingest several billable events in batch (limited to max 5000 events per request). This endpoint is idempotent, an event with the same id, will be updated if it already exists. # Simulate billable event prices Source: https://docs.hyperline.co/api-reference/endpoints/billable-events/simulate-billable-event-prices post /v1/events/simulate-prices Simulate prices for a single billable event without ingesting it. # Create catalog draft Source: https://docs.hyperline.co/api-reference/endpoints/catalog/create-catalog-draft post /v1/catalog/versions/draft Create the pending draft from the current live catalog. Returns the existing draft when one is already pending. # Discard catalog draft Source: https://docs.hyperline.co/api-reference/endpoints/catalog/discard-catalog-draft delete /v1/catalog/versions/draft Archive the pending catalog draft without applying its changes. # Export catalog Source: https://docs.hyperline.co/api-reference/endpoints/catalog/export-catalog get /v1/catalog/export Export the live product catalog as a portable snapshot (the same artifact the app exports), usable for backups or imports into another organisation. # Get catalog draft Source: https://docs.hyperline.co/api-reference/endpoints/catalog/get-catalog-draft get /v1/catalog/versions/draft Retrieve the pending catalog draft, or null when no draft exists. # Get catalog version Source: https://docs.hyperline.co/api-reference/endpoints/catalog/get-catalog-version get /v1/catalog/versions/{id} Retrieve a single catalog version. # List catalog versions Source: https://docs.hyperline.co/api-reference/endpoints/catalog/list-catalog-versions get /v1/catalog/versions Retrieve the product catalog versions: the pending draft followed by published versions. Requires catalog versioning to be enabled. # Publish catalog draft Source: https://docs.hyperline.co/api-reference/endpoints/catalog/publish-catalog-draft post /v1/catalog/versions/draft/publish Apply the pending draft to the live catalog and mark it as a published version. # Revert catalog version Source: https://docs.hyperline.co/api-reference/endpoints/catalog/revert-catalog-version post /v1/catalog/versions/{id}/revert Publish a new catalog version restoring the state of a previous published version (revert). Fails while a draft is pending. # Create company Source: https://docs.hyperline.co/api-reference/endpoints/companies/create-company post /v1/companies Create a new company to which the authentication token will have access to. # List companies Source: https://docs.hyperline.co/api-reference/endpoints/companies/list-companies get /v1/companies Retrieve all companies that the authentication token has access to. # Create promotion code Source: https://docs.hyperline.co/api-reference/endpoints/coupons->-promotion-codes/create-promotion-code post /v1/promotion-codes Create a new promotion code. # Delete promotion code Source: https://docs.hyperline.co/api-reference/endpoints/coupons->-promotion-codes/delete-promotion-code delete /v1/promotion-codes/{id} Delete an existing promotion code. # Get promotion code Source: https://docs.hyperline.co/api-reference/endpoints/coupons->-promotion-codes/get-promotion-code get /v1/promotion-codes/{id} Retrieve the details of an existing promotion code. # List promotion codes Source: https://docs.hyperline.co/api-reference/endpoints/coupons->-promotion-codes/list-promotion-codes get /v1/promotion-codes Retrieve existing promotion codes. # Update promotion code Source: https://docs.hyperline.co/api-reference/endpoints/coupons->-promotion-codes/update-promotion-code patch /v1/promotion-codes/{id} Update the details of an existing promotion code. # Create coupon Source: https://docs.hyperline.co/api-reference/endpoints/coupons/create-coupon post /v1/coupons Create a new coupon. # Delete coupon Source: https://docs.hyperline.co/api-reference/endpoints/coupons/delete-coupon delete /v1/coupons/{id} Delete an existing coupon. # Get coupon Source: https://docs.hyperline.co/api-reference/endpoints/coupons/get-coupon get /v1/coupons/{id} Retrieve the details of an existing coupon. # List coupons Source: https://docs.hyperline.co/api-reference/endpoints/coupons/list-coupons get /v1/coupons Retrieve existing coupons. # Update coupon Source: https://docs.hyperline.co/api-reference/endpoints/coupons/update-coupon put /v1/coupons/{id} Update the details of an existing coupon. # Create custom property Source: https://docs.hyperline.co/api-reference/endpoints/custom-properties/create-custom-property post /v1/custom-properties Create a new custom property. # Delete custom property Source: https://docs.hyperline.co/api-reference/endpoints/custom-properties/delete-custom-property delete /v1/custom-properties/{id} Delete an existing custom property. # List custom properties Source: https://docs.hyperline.co/api-reference/endpoints/custom-properties/list-custom-properties get /v1/custom-properties Retrieve all custom properties previously created. # Update custom property Source: https://docs.hyperline.co/api-reference/endpoints/custom-properties/update-custom-property put /v1/custom-properties/{id} Update an existing custom property. # Create credit product Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/create-credit-product post /v1/customers/{id}/credits Create a credit entity for a given product with an optional balance. # Create credits usage Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/create-credits-usage post /v1/customers/{id}/credits/{productId}/usage Create a usage entry for a credit product. This will impact the balance of the customer by `usage_retained`. # Get credit product Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/get-credit-product get /v1/customers/{id}/credits/{productId} Retrieve the details of an existing credit product for a customer. # List all credit products Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/list-all-credit-products get /v1/customers/credits Retrieve credit products for all customers. # List credit products Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/list-credit-products get /v1/customers/{id}/credits Retrieve credit products attached to a customer. # List credit transactions Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/list-credit-transactions get /v1/customers/{id}/credits/{productId}/transactions Retrieve all credit transactions associated with a credit product. # Purchase credits Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/purchase-credits post /v1/customers/{id}/credits/{productId}/purchase Purchase a number of credits. This action will generate an invoice and charge the customer. # Topup credits Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/topup-credits post /v1/customers/{id}/credits/{productId}/topup Topup a number of free credits. This action will not charge the customer. # Update credit product Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/update-credit-product put /v1/customers/{id}/credits/{productId} Update the configuration of a customer's credit product. # Update credit topup expiration Source: https://docs.hyperline.co/api-reference/endpoints/customers->-credits/update-credit-topup-expiration patch /v1/customers/{id}/credits/{productId}/transactions/{transactionId} Update the expiration date of a topup credit transaction. Only non-expired topup transactions can be updated. # Delete customer feature Source: https://docs.hyperline.co/api-reference/endpoints/customers->-features/delete-customer-feature delete /v1/customers/{id}/features/{code} Delete a feature override from a customer. # Resolve customer features Source: https://docs.hyperline.co/api-reference/endpoints/customers->-features/resolve-customer-features get /v1/customers/{id}/features Resolve feature values for a customer. # Set customer feature Source: https://docs.hyperline.co/api-reference/endpoints/customers->-features/set-customer-feature put /v1/customers/{id}/features/{code} Set a feature override for a customer. # Create payment method Source: https://docs.hyperline.co/api-reference/endpoints/customers->-payment-methods/create-payment-method post /v1/customers/{id}/payment-methods Import an existing customer payment method from a connected payment provider. # Delete payment method Source: https://docs.hyperline.co/api-reference/endpoints/customers->-payment-methods/delete-payment-method delete /v1/customers/{id}/payment-methods/{paymentMethodId} Delete an existing customer payment method. # Get payment method Source: https://docs.hyperline.co/api-reference/endpoints/customers->-payment-methods/get-payment-method get /v1/customers/{id}/payment-methods/{paymentMethodId} Retrieve the details of an existing customer payment method. # List payment methods Source: https://docs.hyperline.co/api-reference/endpoints/customers->-payment-methods/list-payment-methods get /v1/customers/{id}/payment-methods Retrieve payment methods attached to a customer. # Create segment Source: https://docs.hyperline.co/api-reference/endpoints/customers->-segments/create-segment post /v1/customers/segments Create a new customer segment. # Delete segment Source: https://docs.hyperline.co/api-reference/endpoints/customers->-segments/delete-segment delete /v1/customers/segments/{id} Delete an existing customer segment. # Get segment Source: https://docs.hyperline.co/api-reference/endpoints/customers->-segments/get-segment get /v1/customers/segments/{id} Retrieve the details of an existing customer segment. # List segments Source: https://docs.hyperline.co/api-reference/endpoints/customers->-segments/list-segments get /v1/customers/segments Retrieve all customer segments. # Update segment Source: https://docs.hyperline.co/api-reference/endpoints/customers->-segments/update-segment patch /v1/customers/segments/{id} Update an existing customer segment. # Get customer usage events Source: https://docs.hyperline.co/api-reference/endpoints/customers->-usage/get-customer-usage-events get /v1/customers/{id}/usage/{aggregator_id}/events List raw billable events for a customer and a specific aggregator over a period. # Get customer usage for an aggregator Source: https://docs.hyperline.co/api-reference/endpoints/customers->-usage/get-customer-usage-for-an-aggregator get /v1/customers/{id}/usage/{aggregator_id} Get the usage of a customer for a specific aggregator over a period. # Get customer usage timeseries Source: https://docs.hyperline.co/api-reference/endpoints/customers->-usage/get-customer-usage-timeseries get /v1/customers/{id}/usage/{aggregator_id}/timeseries Get the usage of a customer for an aggregator bucketed by month, day or hour. # List customer usage Source: https://docs.hyperline.co/api-reference/endpoints/customers->-usage/list-customer-usage get /v1/customers/{id}/usage List one usage row per aggregator for a single customer over a period. Use `GET /v1/aggregators/{id}/usage/group-by-customer` for the inverse: one row per customer for a single aggregator. # Archive customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/archive-customer put /v1/customers/{id}/archive Archive an existing customer. # Bulk update providers/customers mapping Source: https://docs.hyperline.co/api-reference/endpoints/customers/bulk-update-providerscustomers-mapping post /v1/customers/providers-bulk-update Bulk update providers/customers mapping, make sure to check the query response to see if all customers were updated. # Create customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/create-customer post /v1/customers Create a new customer. # Create customers batch Source: https://docs.hyperline.co/api-reference/endpoints/customers/create-customers-batch post /v1/customers/batch Create a batch of new customers. # Delete customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/delete-customer delete /v1/customers/{id} Delete an existing customer. The customer must be archived prior to the deletion. # Get customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer get /v2/customers/{id} Retrieve the details of an existing customer. # Get customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer-1 get /v1/customers/{id} We recommend using the `GET /v2/customers/{id}` endpoint instead. # Get customer ARR history Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer-arr-history get /v1/customers/{id}/arr-history List the subscription-level ARR evolutions for a customer in reverse chronological order. # Get customer portal Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer-portal get /v1/customers/{id}/portal Retrieve the URL of the customer portal. # Get customer tax rates Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer-tax-rates get /v1/customers/{id}/taxes/rates Retrieve the eligible tax rates for a customer. # Get customer valuation Source: https://docs.hyperline.co/api-reference/endpoints/customers/get-customer-valuation get /v1/customers/{id}/valuation Compute aggregated valuation metrics across all active subscriptions for a customer. # List customers Source: https://docs.hyperline.co/api-reference/endpoints/customers/list-customers get /v1/customers We recommend using the `GET /v2/customers` endpoint instead. # List customers Source: https://docs.hyperline.co/api-reference/endpoints/customers/list-customers-1 get /v2/customers Retrieve existing customers. # Unarchive customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/unarchive-customer put /v1/customers/{id}/unarchive Unarchive an archived customer. # Update customer Source: https://docs.hyperline.co/api-reference/endpoints/customers/update-customer put /v1/customers/{id} Update the details of an existing customer. # Create export Source: https://docs.hyperline.co/api-reference/endpoints/exports/create-export post /v1/exports Prepare an export of a given type for download. You can check the export readiness status using the GET endpoint. Once the export is ready, download the export using the download endpoint. # Download export Source: https://docs.hyperline.co/api-reference/endpoints/exports/download-export get /v1/exports/{exportId}/download Download the file associated with a specific export. Pass `as_redirect=true` to receive a 302 redirect to a short-lived S3 signed URL instead of the file body. # Get export Source: https://docs.hyperline.co/api-reference/endpoints/exports/get-export get /v1/exports/{exportId} Retrieve the details of an existing export. # List exports Source: https://docs.hyperline.co/api-reference/endpoints/exports/list-exports get /v1/exports List previously created exports, most recent first. # Archive feature Source: https://docs.hyperline.co/api-reference/endpoints/features/archive-feature put /v1/features/{code}/archive Archive a feature definition. # Create feature Source: https://docs.hyperline.co/api-reference/endpoints/features/create-feature post /v1/features Create a feature definition. # Delete feature Source: https://docs.hyperline.co/api-reference/endpoints/features/delete-feature delete /v1/features/{code} Delete an archived feature definition that is not in use. # Get feature Source: https://docs.hyperline.co/api-reference/endpoints/features/get-feature get /v1/features/{code} Retrieve a feature definition. # List features Source: https://docs.hyperline.co/api-reference/endpoints/features/list-features get /v1/features List feature definitions. # Unarchive feature Source: https://docs.hyperline.co/api-reference/endpoints/features/unarchive-feature put /v1/features/{code}/unarchive Unarchive a feature definition. # Update feature Source: https://docs.hyperline.co/api-reference/endpoints/features/update-feature put /v1/features/{code} Update a feature definition. # Create file Source: https://docs.hyperline.co/api-reference/endpoints/files/create-file post /v1/files Create a new file. # Delete file Source: https://docs.hyperline.co/api-reference/endpoints/files/delete-file delete /v1/files/{id} Delete an existing file. # Download file Source: https://docs.hyperline.co/api-reference/endpoints/files/download-file get /v1/files/{id}/download Download an existing file content. # List files Source: https://docs.hyperline.co/api-reference/endpoints/files/list-files get /v1/files Retrieve existing files. # Create component token Source: https://docs.hyperline.co/api-reference/endpoints/integrations/create-component-token post /v1/integrations/components/token Create a new token for embedded components. # List invoice events Source: https://docs.hyperline.co/api-reference/endpoints/invoices->-events/list-invoice-events get /v1/invoices/{id}/events Retrieve billable events for an invoice, with per-event pricing computed against the invoice's billing rules. Works for any invoice status: draft and open invoices compute pricing live, finalized invoices serve the snapshot taken at issuance. Per-event amounts are gross — discounts (coupons, percentage, fixed amount) are applied at the line-item or invoice level, not redistributed across events. Use the invoice endpoint to read `discount_amount` if you need the net. # Create transaction Source: https://docs.hyperline.co/api-reference/endpoints/invoices->-transactions/create-transaction post /v1/invoices/{id}/transactions Create a transaction linked to an existing invoice. This may update the invoice status to paid/partially paid. # Delete transaction Source: https://docs.hyperline.co/api-reference/endpoints/invoices->-transactions/delete-transaction delete /v1/invoices/{id}/transactions/{transactionId} Delete a scheduled transaction or wallet debit linked to an existing invoice. # Charge invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/charge-invoice post /v1/invoices/{id}/charge Manually trigger the payment of the invoice. # Create credit note Source: https://docs.hyperline.co/api-reference/endpoints/invoices/create-credit-note post /v1/invoices/{id}/credit-notes Create a credit note for an existing invoice. # Create invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/create-invoice post /v1/invoices Create a new invoice. # Create invoices Source: https://docs.hyperline.co/api-reference/endpoints/invoices/create-invoices post /v2/invoices/batch Create invoices async in batch. Results can be tracked via webhooks with the `invoice.batch.creation_succeeded` and `invoice.batch.creation_failed` events. # Delete invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/delete-invoice delete /v1/invoices/{id} Delete an invoice in `draft` status or imported from an external source. For other statuses, the `POST /v1/invoices/{id}/void` endpoint must be used. # Download invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/download-invoice get /v1/invoices/{id}/download Download the PDF of an existing invoice. If the invoice is in draft or open status, the PDF will be generated without redirect # Get invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/get-invoice get /v1/invoices/{id} We recommend using the `GET /v2/invoices/{id}` endpoint instead. # Get invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/get-invoice-1 get /v2/invoices/{id} Retrieve the details of an existing invoice. # List invoices Source: https://docs.hyperline.co/api-reference/endpoints/invoices/list-invoices get /v1/invoices We recommend using the `GET /v2/invoices` endpoint instead. # List invoices Source: https://docs.hyperline.co/api-reference/endpoints/invoices/list-invoices-1 get /v2/invoices Retrieve existing invoices. By default, invoices with status open are not included. # Mark as uncollectible Source: https://docs.hyperline.co/api-reference/endpoints/invoices/mark-as-uncollectible post /v1/invoices/{id}/uncollectible Mark an invoice as uncollectible, useful for keeping track of bad debts that can be written off for accounting purposes. # Send invoice emails Source: https://docs.hyperline.co/api-reference/endpoints/invoices/send-invoice-emails post /v1/invoices/send-email Send a specific email (`email_type`) to the customer for a list of invoices, asynchronously in batch. An invoice whose status doesn't resolve to the requested email is skipped. Results can be tracked via webhooks with the `invoice.batch.email_succeeded`, `invoice.batch.email_skipped` and `invoice.batch.email_failed` events. # Update invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/update-invoice patch /v1/invoices/{id} Update an invoice. Draft and grace_period invoices allow full edits; finalized invoices are restricted (paid: custom_note and purchase_order only; uncollectible: metadata only — properties, custom_note, custom_properties). # Upload PDF to invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/upload-pdf-to-invoice post /v1/invoices/{id}/upload Upload a PDF file to an existing invoice. # Validate draft invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/validate-draft-invoice post /v1/invoices/{id}/validate Send a draft invoice for payment, set the status to `to_pay` and its number. This is not reversible. # Void invoice Source: https://docs.hyperline.co/api-reference/endpoints/invoices/void-invoice post /v1/invoices/{id}/void Void an invoice in a `to_pay` status. This action generates a corresponding credit note. # Create invoicing entity Source: https://docs.hyperline.co/api-reference/endpoints/invoicing-entities/create-invoicing-entity post /v1/invoicing-entities Create a new invoicing entity to send invoices from. # Delete invoicing entity Source: https://docs.hyperline.co/api-reference/endpoints/invoicing-entities/delete-invoicing-entity delete /v1/invoicing-entities/{id} Soft deletes an invoicing entity. This action won't delete the associated invoices. # Get invoicing entity Source: https://docs.hyperline.co/api-reference/endpoints/invoicing-entities/get-invoicing-entity get /v1/invoicing-entities/{id} Retrieve a specific invoicing entity. # List invoicing entities Source: https://docs.hyperline.co/api-reference/endpoints/invoicing-entities/list-invoicing-entities get /v1/invoicing-entities Retrieve existing invoicing entities. # Update invoicing entity Source: https://docs.hyperline.co/api-reference/endpoints/invoicing-entities/update-invoicing-entity put /v1/invoicing-entities/{id} Update an existing invoicing entity. # Authorize Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/authorize get /oauth/authorize Initiates OAuth authorization flow. # Generate tokens Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/generate-tokens post /oauth/tokens Exchange authorization code for access token or refresh an existing token. # Get user info Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/get-user-info get /oauth/userinfo Returns user information for the authenticated access token. # OAuth callback Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/oauth-callback get /oauth/callback Handles authorization callback and redirects to client's registered URI. # Register OAuth client Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/register-oauth-client post /oauth/register Register a dynamic OAuth client per RFC 7591. # Revoke token Source: https://docs.hyperline.co/api-reference/endpoints/oauth2/revoke-token post /oauth/revoke Revoke an access or refresh token. # Get organisation Source: https://docs.hyperline.co/api-reference/endpoints/organisations/get-organisation get /v1/organisations/{id} Retrieve the details of an existing organisation. # Patch organisation Source: https://docs.hyperline.co/api-reference/endpoints/organisations/patch-organisation patch /v1/organisations/{id} Update the details of an existing organisation. # Create payment Source: https://docs.hyperline.co/api-reference/endpoints/payments/create-payment post /v1/payments Initiate a new payment (limited to one-time): generate an invoice and charge it directly or with a checkout session # Add products to price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/add-products-to-price-book post /v1/price-books/{id}/products Add products to a price book by copying their default price configurations. # Create price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/create-price-book post /v1/price-books Create a new price book. # Delete price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/delete-price-book delete /v1/price-books/{id} Delete an existing price book. # Get price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/get-price-book get /v1/price-books/{id} Retrieve the details of an existing price book. # List price books Source: https://docs.hyperline.co/api-reference/endpoints/price-books/list-price-books get /v1/price-books Retrieve existing price books. # Remove product from price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/remove-product-from-price-book delete /v1/price-books/{id}/products/{productId} Remove a product and its price configurations from a price book. # Update price book Source: https://docs.hyperline.co/api-reference/endpoints/price-books/update-price-book put /v1/price-books/{id} Update the details of an existing price book. # Create price configuration Source: https://docs.hyperline.co/api-reference/endpoints/price-configurations/create-price-configuration post /v1/price-configurations Create a new price configuration on an existing product. # Delete price configuration Source: https://docs.hyperline.co/api-reference/endpoints/price-configurations/delete-price-configuration delete /v1/price-configurations/{id} Delete an existing price configuration. # Get price configuration Source: https://docs.hyperline.co/api-reference/endpoints/price-configurations/get-price-configuration get /v1/price-configurations/{id} Retrieve the details of an existing price configuration. # List price configurations Source: https://docs.hyperline.co/api-reference/endpoints/price-configurations/list-price-configurations get /v1/price-configurations Retrieve existing price configurations. # Update prices Source: https://docs.hyperline.co/api-reference/endpoints/price-configurations/update-prices put /v1/price-configurations/{id}/prices Update prices of an existing price configuration. # Delete product feature Source: https://docs.hyperline.co/api-reference/endpoints/products->-features/delete-product-feature delete /v1/products/{id}/features/{code} Delete a feature value from a product. # List product features Source: https://docs.hyperline.co/api-reference/endpoints/products->-features/list-product-features get /v1/products/{id}/features List feature values assigned to a product. # Set product feature Source: https://docs.hyperline.co/api-reference/endpoints/products->-features/set-product-feature put /v1/products/{id}/features/{code} Set a feature value for a product. # Archive product Source: https://docs.hyperline.co/api-reference/endpoints/products/archive-product put /v1/products/{id}/archive Archive an existing product. # Create product Source: https://docs.hyperline.co/api-reference/endpoints/products/create-product post /v1/products Create a new product. # Delete product Source: https://docs.hyperline.co/api-reference/endpoints/products/delete-product delete /v1/products/{id} Delete an archived product that is not in use. # Get product Source: https://docs.hyperline.co/api-reference/endpoints/products/get-product get /v1/products/{id} Retrieve the details of an existing product. Only the first 50 price configurations are returned, to retrieve all of them use `GET /v1/price-configurations`. # List products Source: https://docs.hyperline.co/api-reference/endpoints/products/list-products get /v1/products Retrieve existing products. # Unarchive product Source: https://docs.hyperline.co/api-reference/endpoints/products/unarchive-product put /v1/products/{id}/unarchive Unarchive an archived product. # Update product Source: https://docs.hyperline.co/api-reference/endpoints/products/update-product put /v1/products/{id} Update the details of an existing product. # Get quote template Source: https://docs.hyperline.co/api-reference/endpoints/quotes->-templates/get-quote-template get /v1/quotes/templates/{id} Retrieve the details of an existing quote template. # List quote templates Source: https://docs.hyperline.co/api-reference/endpoints/quotes->-templates/list-quote-templates get /v1/quotes/templates Retrieve existing quote templates. # Approve quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/approve-quote post /v1/quotes/{id}/approve Approve an existing quote (acting as the account owner). # Create quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/create-quote post /v1/quotes Create a new quote. # Download quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/download-quote get /v1/quotes/{id}/download Download an existing quote. # Download quote file Source: https://docs.hyperline.co/api-reference/endpoints/quotes/download-quote-file get /v1/quotes/{quoteId}/files/{id}/download Download a file (attachment or manually signed file) attached to an existing quote. # Duplicate quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/duplicate-quote post /v1/quotes/{id}/duplicate Create a draft duplicate of an existing quote. # Finalize quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/finalize-quote post /v1/quotes/{id}/finalize Finalize a draft quote by submitting it for approval or marking it approved when no approval is required. # Get quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/get-quote get /v1/quotes/{id} Retrieve the details of an existing quote. # Get quote valuation Source: https://docs.hyperline.co/api-reference/endpoints/quotes/get-quote-valuation get /v1/quotes/{id}/valuation Compute valuation metrics for an existing quote. # List quotes Source: https://docs.hyperline.co/api-reference/endpoints/quotes/list-quotes get /v1/quotes Retrieve existing quotes. # Send quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/send-quote post /v1/quotes/{id}/send Send an existing quote by email for signature. # Sign quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/sign-quote post /v1/quotes/{id}/sign Manually mark the quote as signed externally. Built-in Hyperline signature flow won't be used. # Update quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/update-quote patch /v1/quotes/{id} Update an existing quote. # Void quote Source: https://docs.hyperline.co/api-reference/endpoints/quotes/void-quote post /v1/quotes/{id}/void Void an existing quote. # Get subscription phase Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-phases/get-subscription-phase get /v2/subscriptions/{id}/phases/{phaseId} Retrieve the details of a phase for an existing subscription. # List subscription phases Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-phases/list-subscription-phases get /v2/subscriptions/{id}/phases Retrieve the details of the phases for an existing subscription. # Transition subscription to next phase Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-phases/transition-subscription-to-next-phase post /v2/subscriptions/{id}/next-phase Update a subscription and transition it to the next available phase. # Create subscription template Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/create-subscription-template post /v1/subscriptions/templates Create a new subscription template. # Create subscription template configuration Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/create-subscription-template-configuration post /v1/subscriptions/templates/{id}/configurations Add a configuration (currency/country, phases, products, contract terms) to a subscription template. # Delete subscription template Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/delete-subscription-template delete /v1/subscriptions/templates/{id} Delete a subscription template. Fails if a quote template depends on it. # Delete subscription template configuration Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/delete-subscription-template-configuration delete /v1/subscriptions/templates/{templateId}/configurations/{id} Delete a configuration from a subscription template. # Get subscription template Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/get-subscription-template get /v1/subscriptions/templates/{id} Retrieve an existing subscription template with its configurations details. # List subscription templates Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/list-subscription-templates get /v1/subscriptions/templates Retrieve existing subscription templates. # Update subscription template Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/update-subscription-template patch /v1/subscriptions/templates/{id} Update the name or description of a subscription template. # Update subscription template configuration Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-templates/update-subscription-template-configuration put /v1/subscriptions/templates/{templateId}/configurations/{id} Replace an existing configuration for a subscription template. # Cancel subscription transition Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-transitions/cancel-subscription-transition post /v2/subscriptions/transitions/{id}/cancel Cancel a scheduled subscription transition. # Create subscription transition Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-transitions/create-subscription-transition post /v2/subscriptions/transitions Transition a subscription to another subscription, configured from a subscription, a plan or a template. If the application_schedule is `immediately`, the transition is applied right away. # Get subscription transition Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-transitions/get-subscription-transition get /v2/subscriptions/transitions/{id} Retrieve the details of an existing subscription transition. # List subscription transitions Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions->-transitions/list-subscription-transitions get /v2/subscriptions/transitions Retrieve existing subscription transitions. # Activate subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/activate-subscription post /v1/subscriptions/{id}/activate Manually start a subscription for the first time. # Cancel subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/cancel-subscription post /v1/subscriptions/{id}/cancel Cancel an existing subscription. # Create subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/create-subscription post /v2/subscriptions Create a new subscription from a plan or manually with products. # Create subscription update Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/create-subscription-update post /v1/subscriptions/{id}/update Create an update to apply on an existing subscription. # Create subscription updates Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/create-subscription-updates post /v1/subscriptions/{id}/update-many Create multiple updates to apply at once to an existing subscription. # Get subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/get-subscription get /v2/subscriptions/{id} Retrieve the details of an existing subscription. # Get subscription ARR history Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/get-subscription-arr-history get /v1/subscriptions/{id}/arr-history List the ARR evolutions for a subscription in reverse chronological order. # Get subscription valuation Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/get-subscription-valuation get /v1/subscriptions/{id}/valuation Compute valuation metrics for an existing subscription. # List subscriptions Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/list-subscriptions get /v2/subscriptions Retrieve existing subscriptions. By default, draft, voided, and cancelled subscriptions are not included. # Pause subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/pause-subscription post /v1/subscriptions/{id}/pause Pause a subscription. If the subscription is already paused, updates its reactivation date. # Reactivate subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/reactivate-subscription post /v1/subscriptions/{id}/reactivate Reactivate a paused subscription. # Refresh seat products Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/refresh-seat-products post /v2/subscriptions/{id}/refresh-seat-products Triggers 'count' updates on connected seat products within the subscription. This action will use the dataloader query to retrieve and update the number of units for each seat product. # Refresh subscriptions Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/refresh-subscriptions post /v1/subscriptions/refresh Triggers refresh of subscriptions usage data and related open invoices. This action is used when the automatic billing update upon ingestion option is disabled for the account. # Reinstate subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/reinstate-subscription post /v1/subscriptions/{id}/reinstate Reinstate an existing subscription scheduled for cancellation. # Renew subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/renew-subscription post /v1/subscriptions/{id}/renew This action will move the subscription into the future up to a specific date (exclusive), as if the renewals had occurred. As a result, the corresponding future invoices will be generated. If the subscription is currently pending, this action will activate it. A limit of 36 renewals applies. # Simulate subscription updates Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/simulate-subscription-updates post /v1/subscriptions/{id}/simulate-updates Simulate the effect of updates on a subscription without actually applying them. # Update subscription Source: https://docs.hyperline.co/api-reference/endpoints/subscriptions/update-subscription put /v2/subscriptions/{id} Update configuration of a subscription including phases and products. # Create tax rate Source: https://docs.hyperline.co/api-reference/endpoints/taxes/create-tax-rate post /v1/taxes/rates Create a custom rate or a code mapping for a default rate. # Delete tax rate Source: https://docs.hyperline.co/api-reference/endpoints/taxes/delete-tax-rate delete /v1/taxes/rates/{id} Delete an existing custom or default tax rate mapping. # Get tax rate Source: https://docs.hyperline.co/api-reference/endpoints/taxes/get-tax-rate get /v1/taxes/rates/{id} Retrieve an existing custom or default tax rate mapping. # List tax rates Source: https://docs.hyperline.co/api-reference/endpoints/taxes/list-tax-rates get /v1/taxes/rates Retrieve existing custom and default tax rate mappings. # Update tax rate Source: https://docs.hyperline.co/api-reference/endpoints/taxes/update-tax-rate patch /v1/taxes/rates/{id} Update an existing custom or default tax rate mapping. # Create app Source: https://docs.hyperline.co/api-reference/endpoints/third-party-apps/create-app post /v1/apps Create a new third-party app. # Delete app Source: https://docs.hyperline.co/api-reference/endpoints/third-party-apps/delete-app delete /v1/apps/{id} Delete an existing third-party app. # List apps Source: https://docs.hyperline.co/api-reference/endpoints/third-party-apps/list-apps get /v1/apps Retrieve existing third-party apps. # Update app Source: https://docs.hyperline.co/api-reference/endpoints/third-party-apps/update-app put /v1/apps/{id} Update an existing third-party app. # Refund transaction Source: https://docs.hyperline.co/api-reference/endpoints/transactions/refund-transaction post /v1/transactions/{id}/refund Refund a settled banking transaction for its full amount. The related invoice will switch back to to pay status. Use the create credit note endpoint if you want to cancel (and optionally refund) the initial invoice. # Get user role Source: https://docs.hyperline.co/api-reference/endpoints/users->-roles/get-user-role get /v1/users/roles/{id} Retrieve the details of an existing user role. # List user roles Source: https://docs.hyperline.co/api-reference/endpoints/users->-roles/list-user-roles get /v1/users/roles Retrieve existing user roles. # Get user Source: https://docs.hyperline.co/api-reference/endpoints/users/get-user get /v1/users/{id} Retrieve the details of an existing user. # List users Source: https://docs.hyperline.co/api-reference/endpoints/users/list-users get /v1/users Retrieve existing users. # Create wallet Source: https://docs.hyperline.co/api-reference/endpoints/wallets/create-wallet post /v1/wallets Create a new wallet. # Get wallet Source: https://docs.hyperline.co/api-reference/endpoints/wallets/get-wallet get /v1/wallets/{id} Retrieve the details of an existing wallet. # Get wallet settings Source: https://docs.hyperline.co/api-reference/endpoints/wallets/get-wallet-settings get /v1/wallets/settings Retrieve the global settings of the wallets. # List wallet transactions Source: https://docs.hyperline.co/api-reference/endpoints/wallets/list-wallet-transactions get /v1/wallets/{id}/transactions Retrieve all transactions of an existing wallet. # List wallets Source: https://docs.hyperline.co/api-reference/endpoints/wallets/list-wallets get /v2/wallets Retrieve existing wallets. # Load wallet Source: https://docs.hyperline.co/api-reference/endpoints/wallets/load-wallet post /v1/wallets/{id}/load Load paid or free credits on an existing wallet. # Revert wallet load Source: https://docs.hyperline.co/api-reference/endpoints/wallets/revert-wallet-load post /v1/wallets/{id}/transactions/{transactionId}/revert Revert a credit wallet transaction. Voids the related credit note/document and creates a debit transaction. # Update wallet Source: https://docs.hyperline.co/api-reference/endpoints/wallets/update-wallet put /v1/wallets/{id} Update the details of an existing wallet. # Update wallet settings Source: https://docs.hyperline.co/api-reference/endpoints/wallets/update-wallet-settings patch /v1/wallets/settings Update the global settings of the wallets. # Create webhook endpoint Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/create-webhook-endpoint post /v1/webhooks/endpoints Create a new webhook endpoint. # Delete webhook endpoint Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/delete-webhook-endpoint delete /v1/webhooks/endpoints/{id} Delete an existing webhook endpoint. # Get webhook endpoint Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/get-webhook-endpoint get /v1/webhooks/endpoints/{id} Retrieve an existing webhook endpoint. # List webhook endpoints Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/list-webhook-endpoints get /v1/webhooks/endpoints Retrieve all webhook endpoints. # List webhook messages Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/list-webhook-messages get /v1/webhooks/messages Retrieve all webhook messages sent. Please note that, by default, this endpoint is limited to retrieving 90 days' worth of data relative to now. Messages that date back more than 90 days are still accessible, but their payloads are expunged. If an iterator is provided, the endpoint retrieves data spanning 90 days before/after the time indicated by the iterator ID. If you require data beyond those time ranges, you will need to explicitly set the before or after parameter as appropriate. # Update webhook endpoint Source: https://docs.hyperline.co/api-reference/endpoints/webhooks/update-webhook-endpoint put /v1/webhooks/endpoints/{id} Update an existing webhook endpoint. # Product updates June, 2025 Source: https://docs.hyperline.co/changelog/2025-06 Hyperline June 2025 release: multi-factor authentication, update subscription phases, cancellation reasons, bundle pricing, ChorusPro auto-transmission. ## Multi-Factor Authentication (MFA) Hyperline now supports advanced authentication via Multi-Factor Authentication (MFA or 2FA) for our enterprise clients. Supported methods include one-time passwords (OTP), one-time codes via email, and biometric authentication (e.g., Touch ID or passkeys). Once MFA is activated, it will be enforced for all account members at their next login. If a user belongs to multiple accounts, MFA will be required for each. ## Update subscription phases Subscription future phases can now be updated. Additionally, you can add new phases or remove existing ones. This allows you to plan contract changes in advance, such as pricing updates or multi-year configurations. ## Record cancellation reason You can now record the reason for cancelling a subscription. This will be displayed in the subscription details page and accessible from the API. ## New bundle pricing model The bundle pricing model is now available for seat-based products. This allows you to configure predefined bundles with specific quantity/price combinations, making only those options available when creating new quotes and subscriptions. ## Edit footer invoice In addition to the global invoice legal/additional information settings, you can now edit these footer sections of each invoice directly in the invoice editor. This allows for advanced invoice customization to meet ad-hoc needs. ## Switch between B2C and B2B on public pages Public pages (customer portal, checkout, and quote pages) now allow your customers to select between B2C (person) and B2B (corporate) typologies. This selection will determine the required form fields during these flows, and categorize more accurately the customers in Hyperline. ## ChorusPro auto-transmission As part of e-invoicing regulations, Hyperline now supports the automatic transmission of invoices to ChorusPro for Business-to-Government (B2G) customers. Until now, only PDF/XML file generation was available — this new capability removes the need for any manual action on the ChorusPro side by finance teams. # Product updates July, 2025 Source: https://docs.hyperline.co/changelog/2025-07 Hyperline July 2025 release: Apple Pay and Google Pay, expanded filters, customer files API, custom quote file names, external payment method imports. ## Apple Pay / Google Pay Hyperline now supports Apple Pay and Google Pay, enabling frictionless payments and removing the need to manually enter card details. With these methods, customers can also save their card for future use. The payment flow works the same as with credit or debit cards. ## More filters We've added new filters on list pages: * Customers can now be filtered by integration. * Invoices can now be filtered by plan and integration. * Subscriptions can now be filtered by product and coupon. ## Manage customer files via the API You can now list, create, delete, and download customer files through the API. This allows you to programmatically manage files and build advanced use cases for your product on top of Hyperline. ## Custom quote file names The name of a downloaded quote file can now be customized for your account. ## Import external payment methods Payment methods collected outside of Hyperline (for example, via an embedded PSP form in your product) can now be imported into Hyperline using the API. # Product updates August, 2025 Source: https://docs.hyperline.co/changelog/2025-08 Hyperline August 2025 release: edit subscription phases, prefill quantities, preview invoices and quotes, ChartMogul integration, scheduled changes. ## Edit subscription phases You can now add, edit, and delete subscription phases for active subscriptions directly from the subscription update page. This makes it easier to customize phases to better align with each customer or contract's future needs. ## Prefill quantity from plan Plans with seat-based products can now include a preconfigured quantity. When the plan is used to create a subscription, the quantity will be automatically prefilled—no manual input required. ## Preview invoices and quotes We improved the PDF preview of invoices and quotes by clearly highlighting the displayed language. You can now easily switch between the account language (legal) and the customer's language with a single click when both are different. ## Product order in subscriptions The order of products in a subscription can now be adjusted during creation. Simply move products up or down to control the display order, which will be reflected in related quotes and invoices. ## ChartMogul integration [ChartMogul](https://www.chartmogul.com?utm_source=hyperline) now natively supports Hyperline. Benefit from all ChartMogul capabilities to analyze your subscription revenue from your Hyperline data. ## Schedule subscription changes It's now possible to schedule subscription changes for a specific date using the API. This allows you to programmatically plan updates in advance and build more advanced subscription flows. ## Support for Stripe Link Hyperline now supports Stripe Link, a Stripe-specific payment method that can be automatically imported and used to process invoice charges in Hyperline. # Product updates September, 2025 Source: https://docs.hyperline.co/changelog/2025-09 Hyperline September 2025 release: subscription templates, credit auto top-up, relative coupon durations, uncollectible invoices, non-recurring subs. ## Subscription templates We are progressively rolling out a subscription templates module, introducing a new way to preconfigure subscriptions with their full set of options and capabilities. Similar to plans, they allow subscriptions to be assigned in a single click and can be used in quote templates. The key difference from plans is that all subscription options available in the subscription assignment flow are included in these templates (phases, contracts, advanced options, etc.), removing existing limitations and moving toward a broader concept of templates. Plans will be gradually discontinued. *Contact our support if you are interested.* ## Auto top-up on credits Customer credit balances can now be automatically topped up, either from an existing catalog price or a custom one. These options are available both in the UI and via the API. ## Relative duration on coupons Coupons within subscriptions can now be configured with a relative duration (e.g., 6 months). You can now set them to apply once, for a fixed duration, or for the entire phase or subscription period. ## Custom quote name Clients can now customize the quote name on the document — for example, renaming “Quote” to “Contract” or removing the quote number displayed. The configuration of this name is available in all supported languages. ## Uncollectible invoice Invoices can now be marked as uncollectible, allowing you to track bad debts that may be written off for accounting purposes. An uncollectible invoice can still be paid by the customer (it remains “to pay”). ## Non-recurring subscriptions Hyperline subscriptions can now contain one-time products only, allowing you to represent customer contracts and terms, or include only credit-based products — all without recurring usage. ## Transition options on quote update When configuring a quote for a subscription update, you now have different options to transition from the current configuration to the new one: * Direct: a new billing cycle starts when the quote is signed, with no transition invoice (no refund from the previous phase and no prorated charge for the new phase). * Pro-rata: the default behavior until now — billing cycles are preserved when possible, and a transition invoice with prorations is issued at quote signature. This remains the default behavior. ## Transaction synchronization with accounting software When using an integration with accounting software, you now have the flexibility to configure the synchronization direction between Hyperline and your accounting system. ## UI updates We've rolled out several UI improvements: * Added a secondary navigation bar for each product category * Moved audit pages to the main navigation * Added filters to the products page * Updated status iconography for quotes, invoices, and transactions # Product updates October, 2025 Source: https://docs.hyperline.co/changelog/2025-10 Hyperline October 2025 release: transactions page, subscription versions, accounting observability, edit current phase, e-invoicing Spain and Belgium. ## Transactions page We added a brand-new page in Hyperline to track transactions at the account level. This page lists all transactions that occurred in your account, including payments and refunds, providing a clear overview of your cash activity. Filters and export options are also available. ## Subscription versions We introduced subscription versions to help you track changes to your subscriptions over time. Each time a subscription is updated, a new version is created, allowing you to view the full history of changes made to that subscription. ## Accounting integrations observability We improved the observability of our accounting integrations by adding detailed logs in case of issues. This helps you clearly monitor syncs and quickly identify and resolve any problems that may arise. ## Edit current subscription phase Just like with future phases, you can now edit the current phase of a subscription. ## E-invoicing Spain and Belgium Automated e-invoicing transmission is now available for Spain and Belgium. We now send your invoices directly to the tax authorities in these countries, ensuring compliance with local regulations. ## Coupons improvements We made several improvements to the coupons feature. Coupons can now be applied with a relative duration (e.g., for 3 months), and you can choose which line items the coupon applies to when creating or editing an invoice in the visual editor. Additionally, you can now create invoices with coupons using the API. ## Bank account error We now send an email to the “Email for technical alerts” address (configured in the email settings) when a connected bank account cannot be refreshed. This proactive notification helps you reconnect your account promptly and ensure invoice reconciliation continues to work seamlessly. ## Update on parent invoices From now on, in the context of organization-based billing, when a parent invoice includes products from a child customer, the child customer's name will be added as a prefix to the corresponding product (e.g., ChildCustomerA - Pro Subscription). # Product updates November, 2025 Source: https://docs.hyperline.co/changelog/2025-11 Hyperline November 2025 release: Insights analytics, Attio integration, bank statement reconciliation, quote countersigners, exports API, custom ARR. ## Insights Hyperline now offers a full Insights module that provides a comprehensive overview of your financial and revenue metrics. The **Financial page** includes cash-flow visibility, MRR and debt evolution, aged balances, and complete breakdowns of your revenue and accounts receivable, as well as detailed MRR analytics including new, expansion, contraction, lost, and net changes. The **Revenue page** provides in-depth insights into your revenue streams, including breakdowns by product, currency, and customer. *This module is in beta. Contact our support if you are interested.* ## Attio integration Hyperline now natively supports [Attio](https://www.attio.com?utm_source=hyperline) CRM. The Hyperline Attio app enables you to create custom quotes or manage subscriptions directly from your Attio deals or companies using pre-built actions. Additionally, the integration can automatically sync your Hyperline quotes, subscriptions, and invoices into Attio as custom objects. [More details in the documentation](../integrations/attio) ## Reconcile from bank statements Automated invoice reconciliation from bank accounts has long been available in Hyperline, including the ability to validate matches from each invoice. Hyperline now also supports reconciliation from bank statements. From a dedicated transactions page listing inbound transactions from your connected bank accounts, you can now reconcile invoices with granular manual control and have an overview of all your connected bank accounts balance. ## Quote countersigner A quote countersigner can now be configured in the settings (first name, last name, and email). When a quote is signed by your customer, if a countersigner is configured, we automatically countersign the quote (i.e. apply an additional signature) before finalising the full quote signature. ## Exports API You can now [trigger and download exports](../api-reference/endpoints/exports/create-export) of pre-built Hyperline reports (including aged balances, revenue per product/line item/country, line-by-line revenue, etc.) directly from the API. This enables you to automate data extraction from Hyperline for use in your own systems or for further analysis. All report exports now support optional date range filtering via `period_start` and `period_end` parameters, allowing you to extract data for specific time periods. In addition, [customers](../api-reference/endpoints/customers/list-customers), [invoices](../api-reference/endpoints/invoices/list-invoices), [subscriptions](../api-reference/endpoints/subscriptions/list-subscriptions), and [quotes](../api-reference/endpoints/quotes/list-quotes) can also be exported via the API using the list endpoints with advanced filtering options. ## Custom subscription ARR and contract value Hyperline provides automatic calculation of Annual Recurring Revenue (ARR) and contract value for subscriptions out of the box, based on their pricing and billing cycles. However, there are scenarios where you may want to override these automatic calculations. Hyperline now allows you to set custom values for both ARR and contract value on a per-subscription basis, in addition to displaying them in the subscription overview. ## Update subscriptions We've begun rolling out new flows for updating existing subscriptions, offering both simpler and more advanced options. You can now update a subscription using an existing template (or plan) or edit subscription details with enhanced versioning support. This change is the first step in a broader revamp of our subscription update flows, aimed at making them more flexible and easier to use — including the ability to schedule changes in advance and preview their impact on upcoming invoices. ## Advanced Exact Online settings In Exact Online, a yearly invoice spanning 13 calendar months (e.g., 2025-11-19 to 2026-11-18) is recognized over 13 months instead of 12, resulting in incorrect monthly revenue recognition. Hyperline now supports an advanced setting to adjust this behavior. When this setting is enabled, the invoice period end date for yearly invoices is adjusted (e.g., to 2026-10-31 instead of 2026-11-18) so that revenue is recognized over 12 months. # Product updates December, 2025 Source: https://docs.hyperline.co/changelog/2025-12 Hyperline December 2025 release: scheduled subscription updates, US bank reconciliation, dark mode, wallet auto-load, Insights export, outstanding pay. ## Scheduled subscription updates You can now schedule subscription updates for a future date, allowing you to prepare changes in advance and have them automatically applied at the right time. When preparing the update, preview the impact on upcoming invoices before confirming the changes. ## US bank account reconciliation Automatic reconciliation of bank transactions with invoices has been available for EU countries for a while—we've now extended this capability to US bank accounts. Hyperline connects to over 5,000 banks in the US, automatically matching received transactions with your invoices. We've also added the ability to hide synced transactions you don't need to see, keeping your view clean and focused. ## Dark mode A new dark mode is now available for the Hyperline interface. Whether you prefer a darker aesthetic or want to reduce eye strain during long sessions, you can switch between light and dark themes from your profile settings. ## Credit wallet from credit note When issuing a credit note, you can now credit the corresponding amount directly to the customer's wallet. This balance will automatically apply to their future invoices. ## Wallet auto-load Wallets can now be automatically topped up when the projected balance falls below a defined threshold. Combined with the existing interval-based auto-load, this gives you more flexibility in managing wallet balances. We've also added a new webhook to notify you when a wallet's projected balance drops below the threshold. ## Insights export You can now export data from the Insights module to CSV files. Whether you need to share metrics with your team, build custom reports, or integrate with external tools, all your analytics data is just a click away. ## Process outstanding invoices on payment method update When updating a customer's default payment method, you can now choose to immediately process any outstanding invoices with the new method. Additionally, you can configure the default behavior at your account level to automatically pay (or not) outstanding invoices when customers update their payment method through their portal. # Product updates January, 2026 Source: https://docs.hyperline.co/changelog/2026-01 Hyperline January 2026 release: customer portal authentication, quote approval workflows, expired quote filters, user merge, payment initiation delay. ## Customer portal authentication You can now require customers to authenticate before accessing the customer portal. When enabled, customers must verify their email address through a secure link sent via email before they can view their billing information. This adds an extra layer of security, ensuring only authorized users can access sensitive billing data. Additionally, the link expiration duration is now configurable, allowing you to automatically expire access links after a specified period (in minutes). This reduces the risk of unauthorized access through outdated links. ## Quote approval workflows The quote approval system now supports **advanced approval workflows**, giving sales and finance teams more control over quote validation before it reaches the customer. You can now build **multi-step approval processes** with sequential steps and triggered automatically based on **custom rules** that you can combine with AND/OR logic. *[Learn more about quote approval](../docs/quotes/approval)* ### Slack integration for approval workflows You can now connect Slack to Hyperline and receive approval notifications directly in your channels. When a quote requires approval, the configured Slack channel receives a notification with all relevant context — quote details, customer name, requester, and a direct link to review the quote. Learn more in the [Slack integration documentation](../integrations/slack). ## Filter for expired quotes A new filter is now available on the quotes list to quickly find **expired quotes**. This makes it easier to identify quotes that need attention — whether to follow up with customers or update expiration dates. ## Merge users You can now **merge duplicate users** in your Hyperline account. This is useful when the same team member has been created multiple times — for example, from different CRM integrations. Merging consolidates their activity and permissions into a single profile. ## Custom payment initiation delay per customer The payment initiation delay (grace period between invoice creation and payment collection) can now be configured **at the customer level**, overriding the global setting. This gives you more flexibility to accommodate specific customer agreements or payment terms. # Product updates February, 2026 Source: https://docs.hyperline.co/changelog/2026-02 Hyperline February 2026 release: MCP server, revamped quote-based subscription updates, custom invoice notes, audit log tracking, Insights improvements. ## MCP server The Hyperline MCP server is now generally available. Connect your AI tools to Hyperline using the Model Context Protocol (MCP), with more than 100 tools to interact with your billing data — whether for reporting, analysis, or automation. Learn more about the [MCP server](../api-reference/docs/ai/mcp). ## Subscription update with quotes revamped As part of our subscription update flow revamp, we integrated quotes as a validation step when transitioning to a new subscription. You can now select when the subscription update will take effect, not only starting on quote signature but on any date in the future. This new flow makes the quote for upsell, renewal or modification process simpler and more intuitive, especially when planning future changes. Read more about the way it works on the [dedicated documentation page](/docs/quotes/subscription-update). ## Custom invoice notes in subscriptions You can now define a custom note when configuring a subscription — including from a quote — that will appear on the generated invoices and credit notes. This allows you to add additional context that is automatically carried over to every document. ## Integration tracking in audit logs Audit logs now show which integration performed each action. For example, when a customer is created via your CRM, the log now displays the actual integration instead of a generic "System" label. ## More filters in list pages We added a range of new filters to the customers and subscriptions list pages. You can now filter customers by **tax ID**, **external ID presence**, and **parent or children relationships**. Both customers and subscriptions can be filtered by custom properties, and subscriptions can additionally be filtered by free trial status or draft invoice generation. ## Insights improvements The Insights module has been enhanced with improved visualizations, including a refined aged balances heatmap with dark-mode support, clearer empty states across charts, and more intuitive navigation in revenue and MRR tables. Chart readability has also been improved with consistent sizing and better axis rendering. # Product updates March, 2026 Source: https://docs.hyperline.co/changelog/2026-03 Hyperline March 2026 release: Slack notifications, Hyperline CLI, French localization, aggregators catalog, multi-aggregator credits, Zoho Books, idempotency. ## Slack notifications You can now configure notification rules in the Slack integration to automatically send messages when specific events occur in Hyperline — such as an approval request, an invoice being paid, a quote being signed, or a dataloader error. Slack Notifications Each rule combines a trigger event, a Slack channel, and a message template, giving you full control over what gets notified and where. [*Learn more about Slack notifications*](../integrations/slack) ## Hyperline CLI Hyperline is now available as a [CLI tool](https://www.npmjs.com/package/@hyperline/cli), designed to work seamlessly with AI coding agents like Claude. The CLI provides a lightweight, token-efficient way for agents to interact with your billing data — listing customers, invoices, events, and more using simple terminal commands. Cli Compared to MCP integrations, the CLI avoids context overload and naming conflicts with other tools, resulting in faster and more reliable agent responses, especially on complex multi-step queries. [*Learn more about the Hyperline CLI*](../api-reference/docs/ai/cli) ## Bonjour 🇫🇷 Hyperline is now fully available in French. User language can be changed from the Profile settings. French This completes the existing support for the 8 supported languages (English, French, German, Italian, Spanish, Polish, Portuguese and Dutch) of the customer public pages. ## Aggregators catalog Aggregators for usage-based billing now have their own dedicated section under Usage > Aggregators, separate from the product creation form. You can create, edit, and manage aggregators independently, see which products reference each one, and reuse the same aggregator across multiple products. Usage Aggregators This makes metering configuration easier to maintain as your catalog grows, with a clearer separation between usage tracking and product setup. [*Learn more about aggregators*](../docs/usage/aggregators) ## Multi-aggregator credits Credit products can now be linked to multiple aggregators, allowing different event types to consume different credit amounts from the same balance. This is especially useful when a single credit pool covers several types of usage. Multi Aggregators We also introduced a new chart-based display for credit balances and an improved transactions table with invoice details and an exploration modal. ## Zoho Books integration Hyperline Zoho Books Zoho Books is now supported as an accounting integration, with the same scope as our existing accounting connectors — automatic invoice and credit note synchronization. [*Learn more about the Zoho Books integration*](/integrations/zoho-books) ## Subscription linking on invoices You can now link or unlink subscriptions directly from the invoice creation and editing form, making it easier to associate invoices with the right subscription for reporting purposes. Linked Subscription The invoice form has also been improved with automatic period computation, smarter defaults, and a cleaner layout for payment methods and line items. [*Learn more about invoice management*](../docs/invoices/manage) ## Renewals report Renewals Report A new **Renewals** report is now available in the Insights module, helping you track upcoming and past subscription renewals at a glance. ## API idempotency keys API requests now support idempotency keys, allowing you to safely retry requests without risk of duplicate operations. This is particularly useful for critical actions like invoice creation, and follows a common API standard for reliable integrations. [*Learn more about idempotent requests*](/api-reference/docs/idempotent-requests) ## Quote price tier display Quote Price Tiers When building a quote, you can now configure which price tiers are displayed for each line item: all tiers, only the matching tiers based on quantity, or none. This gives you more control over the level of pricing detail your customers see. # Product updates April, 2026 Source: https://docs.hyperline.co/changelog/2026-04 Hyperline April 2026 release: customer segments, Adyen integration, file summary, minimum invoice fees, multiple checkout payment methods, valuation APIs. ## Customer segments Customer segments let you slice your customer base into dynamic, rule-based groups — for example "Enterprise customers in France paying by direct debit" or "All customers with a parent company". Segments can then be used to filter the customers list or in the Insights module for granular analysis. Customer Segments [*Learn more about customer segments*](../docs/customers/segments) ## Adyen integration Hyperline now supports Adyen as a payment provider to collect payments from your customers. Card, SEPA Direct Debit and Bacs Direct Debit are all supported. Adyen Integration [*Learn more about the Adyen integration*](../integrations/adyen) ## File summary When uploading files to the customer files module, a summary is now automatically generated and displayed so you can understand the content of each file at a glance. File Summary ## Minimum invoice fee behavior You can now configure how the minimum invoice fee is applied on subscription invoices: either **replace** (the previous behavior) or **adjustment** (new), which keeps the original line item details and adds an extra minimum fee adjustment line. ## Multiple payment methods on checkout Customers can now select which payment method to use on a checkout, or add a new one. Checkouts were previously limited to a single payment method. Checkout Multi Payment Method ## Draft invoices for one-off quotes Draft invoices can now be generated for one-off quotes, giving you full control before finalizing the invoice after quote signature. In addition, quote value with tax can be displayed for this type of quote with a dedicated new option. ## Improvements to filters on custom properties The filtering group for custom properties has been improved to: * Support all custom property types (text, number, date, etc.) with smart logic for each — for example partial match on text-based properties. * Be easily replicated across pages — now available on Customers and Products in addition to the existing pages. Custom Property Filter ## Parent company details on quotes When a customer has a parent company, the parent's address is now displayed on the quote alongside the customer's details. ## Valuation APIs New endpoints have been added to the API to retrieve the valuation of a customer, quote or subscription, with pre-computed revenue metrics (contract value, recurring contract value, ARR, etc.) and period-level breakdown granularity. # Product updates May, 2026 Source: https://docs.hyperline.co/changelog/2026-05 Hyperline May 2026 release: Sentinel monitoring, Rillet and NetSuite integrations, portal self-service, invoice custom properties, Insights GA, payouts. ## Sentinel Sentinel is your Hyperline monitoring system. It surfaces actionable tasks when something needs attention across payments, invoicing, subscriptions, quotes, and integrations of your account. Sentinel Tasks are grouped by priority, so you can focus on the issues that matter most and open the relevant list directly from the Sentinel panel. [*Learn more about Sentinel*](../docs/sentinel/overview) ## Rillet integration Hyperline now supports Rillet as an accounting integration. You can push invoices, credit notes, customers, payments, and optionally subscription contracts to Rillet. Rillet integration Each Hyperline invoicing entity can be mapped to a Rillet subsidiary, so accounting configuration follows the entity issuing the invoice. [*Learn more about the Rillet integration*](../integrations/rillet) ## NetSuite integration Hyperline now supports NetSuite as an accounting integration. You can push invoices, credit notes, customers, and payments to NetSuite as native Invoice, Credit Memo, and Customer Payment records. NetSuite integration Each Hyperline invoicing entity maps to a NetSuite subsidiary, with full OneWorld support. You can map products to NetSuite items, resolve income and payment accounts through your accounting rules, and feed Hyperline customer and invoice fields into NetSuite custom fields. [*Learn more about the NetSuite integration*](../integrations/netsuite) ## Customer portal self-service Customers can now view their credit transaction history directly from the customer portal, including top-ups, usage consumption, and expirations. Credit history in the customer portal You can also let customers cancel a subscription from the portal. When enabled in **Settings > Hosted pages**, the cancellation schedules the subscription to end at the end of the current billing period, without immediate refund or proration. Customers can undo the cancellation while the current period is still active. Subscription cancellation from the customer portal [*Learn more about credits*](../docs/credits/overview) ## Invoice custom properties Custom properties can now be created for invoices. Values can be set from the invoice builder or when editing an invoice. Invoice custom properties When the same custom property applies to both subscriptions and invoices, Hyperline automatically copies the subscription value to invoices generated from that subscription. [*Learn more about custom properties*](../docs/properties/overview) ## Insights generally available The **Insights** module is now generally available. It gives you interactive financial and revenue dashboards with drilldowns, detailed tables, and filters. Insights [*Learn more about Insights*](../docs/analytics/insights) ## Payout reconciliation Payout reconciliation is now available directly within Hyperline, making it easier to match payment provider payouts with the related transactions in Hyperline. Only supported for Stripe for now. Stripe payout reconciliation [*Learn more about reconciliation*](../docs/invoices/reconciliations) ## Transaction refunds You can now refund a transaction directly from Hyperline. Use this when money should be returned through the original payment method without creating a credit note. After the refund settles, the invoice may move back to `to pay`, with the original payment and refund both visible as transactions. Transaction refund [*Learn more about refunds*](../docs/invoices/refunds) ## Automated exports Report data can now be exported directly to a Postgres or Snowflake warehouse on a 12-hour or 24-hour schedule. This helps finance and data teams keep reporting tables refreshed without relying on manual exports. Automated exports [*Learn more about reports*](../docs/analytics/reports) ## Bundle products Bundle products let you package several catalog products into a single offering. Each bundle can allocate revenue across its components and control how the bundle appears on invoices. You can display a bundle as one invoice line, or show each component separately when customers need a detailed breakdown. Bundle products [*Learn more about products and prices*](../docs/products/overview) ## Translation overrides You can now edit product names and descriptions at the subscription level, and override invoice line item translations when editing an invoice manually. This gives you more control over the labels shown to multilingual customers without changing the shared catalog product. Translation overrides [*Learn more about subscription translations*](../docs/subscriptions/translations) ## Stricter VAT validation for reverse charge A new tax setting lets you require a valid VAT number before applying reverse charge in the EU. When **Enforce a valid tax number for reverse charge** is enabled, Hyperline applies reverse charge only after the customer's tax number has been validated. Hyperline also stores the VIES consultation number on the customer and invoice. Stricter VAT validation for reverse charge [*Learn more about tax management*](../docs/invoices/tax-management#enforce-a-valid-tax-number-for-reverse-charge) # Product updates June, 2026 Source: https://docs.hyperline.co/changelog/2026-06 Hyperline June 2026 release: customer intelligence, new customer details page, formula-based aggregators, duplicate quotes, saved views, API logs. ## Customer intelligence Hyperline now features a complete **Customer intelligence** module to help you monitor customer health, usage, payment behavior, ownership, and follow-up needs from one place. Customer intelligence Customer intelligence brings together revenue data, billing activity, usage signals, and customer context so teams can identify risks and opportunities earlier. You can use it to track late payment behavior, monitor customer activity, assign owners and followers, and set up monitoring agents for important accounts. [*Learn more about customer intelligence*](../docs/customer-intelligence/overview) This new module is currently in beta and available through private access. Get early access ## New customer details page The customer details page has been redesigned with a clearer layout and more structured information. The page now gives you a better overview of each customer, including billing status, wallet balance, usage activity, subscriptions, invoices, and customer intelligence signals when enabled. New customer details page The customer wallet experience has also been refreshed as part of this update. You can add funds by initiating a prepayment, recording an offline payment received outside Hyperline, or adding free funds. Wallet transactions can include comments for additional context, and you can choose a custom amount when charging an invoice from the wallet. [*Learn more about customer wallets*](../docs/wallets/balance) ## Formula-based usage aggregators Aggregators now support SQL formulas, so you can create usage metrics beyond simple counts and sums. For example, you can bill from an average over a period, keep the highest value reached, cap a billed amount, remove an included allowance, or combine several event values into one metric. An AI helper is also available to help build formulas. [*Learn more about aggregators*](../docs/usage/aggregators) ## Duplicate quote Quotes can now be duplicated in one click. Duplicate quote The duplicated quote is created as a draft and keeps the original quote content, including subscription configuration, invoice configuration, contract clauses, and attachments. This helps teams reuse existing deal structures without rebuilding them from scratch. ## More flexible quote approvals Approval workflows can now use more quote conditions. You can trigger approval when non-default payment terms are applied, when a specific contract clause is used, or when a reusable clause has been edited before the quote is validated. More flexible quote approvals [*Learn more about quote approvals*](../docs/quotes/approval) ## Tax controls Customer tax handling is now more explicit. You can set a customer as taxable or tax-exempt, require tax IDs for company customers per invoicing entity, and filter the customer list by tax ID status to identify records that need review. [*Learn more about tax management*](../docs/invoices/tax-management) ## Saved views and list filters Saved views are now available for customers, subscriptions, and invoices. You can save a filtered list view, reuse it later, and set it as the default view for that list. Saved views and list filters The quotes list also now supports filtering by customer. [*Learn more about saved views*](../docs/getting-started/saved-views) ## API activity logs You can now review API activity directly in Hyperline. API activity logs Each log gives you more visibility into requests made to your account, including the request status, source, API key used, and related Hyperline entities. This makes it easier to understand integration behavior without leaving the product. # Product updates July, 2026 Source: https://docs.hyperline.co/changelog/2026-07 Hyperline July 2026 release notes: consolidated invoicing, Customer Intelligence integrations, feature entitlements, Slack quote approvals, and PostHog. ## Consolidated invoicing Customers with several subscriptions can now receive one consolidated invoice per billing day instead of a separate invoice for each subscription. Consolidated invoicing Hyperline automatically combines eligible subscription invoices, while giving you more control over when grouped invoices are generated. When an invoice cannot be grouped, a Sentinel task identifies the affected invoices and links directly to the information you need to resolve the issue. You can also force invoices to remain as drafts for selected customers, making it easier to review consolidated or organization-level invoices before issuing them. [*Learn more about consolidated invoicing*](../docs/invoices/consolidated-invoicing) ## More integrations for Customer Intelligence Customer Intelligence can now combine Hyperline revenue data with context from more CRM, support, email, and call recording platforms. 12 integrations for Customer Intelligence The available integrations include Attio (including Attio Call Recorder), HubSpot, Salesforce, Intercom, Front, Plain, Pylon, Zendesk, Gmail, Google Meet with Gemini, Claap, and Grain. These connections give the customer monitoring agent access to CRM activity, support conversations, emails, meeting summaries, and transcripts. Your teams can use this context to assess customer health, prepare for renewals, and identify risks or expansion opportunities from one place. Customer Intelligence is currently in beta and available through private access. [*Learn more about Customer Intelligence*](../docs/customer-intelligence/overview) ## Feature entitlements Hyperline now includes feature entitlement management, giving you a central place to define the features and access levels included with your products. Feature entitlements Feature entitlements can represent availability, limits, or configuration values. They are granted through the products a customer subscribes to, with the option to create customer-specific grants and overrides when needed. [*Learn more about feature entitlements*](../docs/entitlements/overview) ## Quote approvals with Slack and delegations Approvers can now receive quote approval requests directly in Slack. From the notification, they can review the related quote and either approve it or request changes. Quote approvals with Slack and delegations Approvers can also delegate approval responsibilities to another team member for a defined period, helping approval workflows continue when someone is unavailable. Approval rules can now use the customer's invoicing entity or the subscription template as conditions, giving you more control over which quotes require review and who should approve them. [*Learn more about quote approvals*](../docs/quotes/approval) ## Organization-based usage billing Usage generated by child customers can now be included in a parent customer's metered subscription. Organization-based usage billing You can combine usage by adding activity across all child customers or by using the highest-consuming customer. This supports organizations that manage several accounts or business units under one commercial agreement. [*Learn more about organization-based usage billing*](../docs/subscriptions/metering#include-child-customers-usage) ## Concurrent subscription-update quotes You can now keep several update quotes open for the same subscription. Concurrent subscription-update quotes The first quote signed is applied automatically, while the remaining open quotes are voided to prevent conflicting updates. A dedicated **Quotes** tab on the subscription shows active proposals alongside the complete quote history. ## Bank account assignment Bank accounts can now be assigned using rules based on the invoice currency, customer country, or customer segment. Bank account assignment You can keep one account for all invoices or route payments to different accounts based on these criteria. Hyperline then displays the appropriate bank details on each invoice. [*Learn more about invoicing entity payment methods*](../docs/account/invoicing-entities#payment-methods) ## PostHog usage data Hyperline can now use PostHog and HogQL as a usage data source. PostHog usage data This lets you turn product analytics events into billable usage and connect product activity to metered pricing without building a separate data pipeline. [*Learn more about the PostHog integration*](../docs/usage/posthog) ## Customer balance drill-down You can now open a customer's account balance to understand how it was calculated. Customer balance drill-down The detailed view breaks the balance down into outstanding invoices, available credit notes, and wallet credit. This makes it easier to understand whether a customer owes money, has available credit, or has a fully settled account. For parent organizations, you can also review the aggregated balance across the parent and its child customers. [*Learn more about customer balances*](../docs/customers/balance) # Single sign-on and user provisioning Source: https://docs.hyperline.co/docs/account/enterprise-sso Connect Google Workspace for single sign-on, directory synchronization, automatic user provisioning, and group-based role assignment. Connect Google Workspace to let members sign in through your identity provider and keep their access to your Hyperline account aligned with your directory. Single sign-on and user provisioning are enterprise features available on demand. Contact Hyperline through the in-app chat to enable them for your account. Google Workspace is currently the only supported identity provider. The account owner configures a separate connection for each Hyperline account. ## Before you start You need: * Access to the account owner profile in Hyperline * A Google Workspace administrator account * The Google Admin SDK Directory API enabled for users and groups * Pop-ups allowed for Hyperline in your browser ## Understand the connection Single sign-on and directory synchronization are configured separately: | Capability | What it controls | | ----------------------------- | --------------------------------------------------------------------------------------------- | | **Single sign-on** | Members can authenticate to Hyperline through Google Workspace | | **Directory synchronization** | Hyperline can retrieve Google Workspace users and groups for provisioning and role assignment | A connection can show **Connected** for single sign-on while directory synchronization still requires configuration. **Provision users in Hyperline** only controls whether Hyperline applies synchronized directory data to account memberships. ## Connect Google Workspace Configure single sign-on and verify your Google Workspace domain. Hyperline displays the identity provider, domain, and connection status. Click **Configure** next to **Directory synchronization from Google Workspace**, then authorize access with a Google Workspace administrator account. Grant access to both users and groups. Hyperline displays **In progress** while Google Workspace data is being synchronized, then **Connected** when it is ready. Directory synchronization can take a few minutes after administrator authorization. Keep the authorization window open until it confirms completion. ## Reconfigure single sign-on Click **Reconfigure** to reopen the setup assistant for the existing connection. Use it to update single sign-on or finish domain verification without deleting the connection. When you close the setup assistant, Hyperline refreshes the connection details and statuses automatically. To authorize user and group synchronization, use **Configure** in the directory synchronization line instead. ## Manage directory synchronization Once directory synchronization is connected, Hyperline displays: * **Last synchronization**: the date, time, and result of the latest synchronization * **Synchronize now**: fetches the latest users and groups from Google Workspace * **Provision users in Hyperline**: controls whether synchronized users become members of this Hyperline account Click **Synchronize now**, then confirm the action. Synchronization continues in the background and can take a few minutes. If it fails, hover over **Failed** to view the error returned by the identity provider. Google Workspace directory synchronization runs automatically. You can also start it manually, but a new manual synchronization cannot start if the connection was synchronized during the previous 30 minutes. ## Provision users in Hyperline After directory synchronization is connected, enable **Provision users in Hyperline** and click **Save changes**. Hyperline then imports existing directory users and continues to apply user and group changes. Provisioning follows these rules: * A new directory user creates a member in this Hyperline account. * If the email address already belongs to a Hyperline user, Hyperline links that user instead of creating a duplicate. * Profile and group changes update the provisioned member and their assigned role. * Suspending a Google Workspace user removes their provisioned access. Unsuspending them restores the existing membership instead of creating a duplicate. * Deleting a directory user removes every provisioned Hyperline membership linked to that identity, except account owner memberships. * Account owners are never automatically removed or suspended by directory synchronization. You can continue to invite and manage members manually. A user can have a manually managed membership in one Hyperline account and a provisioned membership in another. Directory changes only control memberships marked **Provisioned**; they do not remove manually managed access. Provisioned memberships display a **Provisioned** label in **Settings > Team > Members**. Their role and removal actions are disabled because their access is controlled through Google Workspace. Update the directory or role provisioning rules instead. ## Assign roles from Google groups Configure role provisioning from **Settings > Team > Roles**. Each Google group can be mapped once. Use the actions menu on an existing mapping to edit its Hyperline role or delete the mapping. If a user belongs to several mapped groups, the first matching mapping determines their role. When no group matches, Hyperline assigns the **Default role** configured in **Role provisioning**. If no specific provisioning default is selected when provisioning is enabled, Hyperline uses the account's standard default role. Adding, editing, or deleting a mapping, or changing the default role, reconciles existing provisioned memberships automatically. If a recently created Google group does not appear when you add a mapping, return to **Settings > General** and click **Synchronize now**. Wait for the synchronization to complete, then reopen the group selector. ## Troubleshoot configuration ### Single sign-on is connected, but directory synchronization is not This is expected when only the authentication setup is complete. Click **Configure** in the directory synchronization line and authorize access with a Google Workspace administrator account. ### Google groups are unavailable Confirm that the Google Admin SDK Directory API is enabled and that the administrator granted access to both users and groups. Configure directory synchronization again if authorization is still required, then start a manual synchronization. ### Synchronization failed Hover over **Failed** next to the latest synchronization to view the provider error. Resolve the reported Google Workspace configuration or authorization issue, then click **Synchronize now**. ## Related * [Users & permissions](./users-permissions) * [Account settings](./settings) # Invoicing entities Source: https://docs.hyperline.co/docs/account/invoicing-entities Manage multiple billing profiles under one Hyperline account with invoicing entities — each with its own tax setup, legal info, and payment methods. Invoicing entities let you **manage multiple billing profiles under a single Hyperline account**. Each entity shares the account configuration (products, plans, events, coupons, and integrations) but has its own distinct invoicing settings (business information, invoice legal information and terms, tax setup and default payment methods). This makes it easy to **centralize your global billing configuration** while customizing how each entity invoices its customers, whether you’re operating across countries, business units, or brands. Accounting integrations can be connected to a specific invoicing entity (e.g. Pennylane for an entity based in France, QuickBooks for one based in the United States). You can also use the [API Reference](/api-reference/endpoints/invoicing-entities/) to create and manage invoicing entities. ## Create invoicing entity Invoicing entities can be created from **Settings** by clicking your company name while browsing an invoicing entity subpage. An unlimited number of invoicing entities can be created. An invoicing entity has its own invoicing settings: * **Business information**: it can have its own trade name, logo and brand color, billing address, accounting currency, default timezone and languages. This is useful for companies operating under different business names in different countries. * **Invoicing**: Activate e-invoicing, add different invoicing patterns and legal information, payment terms, initiation delay, grace period for invoices, credit notes and documents. This is helpful if your different entities have their own legal constraints or ways to operate business. * **Taxes**: Select the tax engine (Hyperline, Anrok, manual), activate automatic tax collection, enforce tax ID requirements, and manage tax mappings. * **Payment methods**: Select available payment methods and the default payment provider or bank account for each of them. For bank transfers, you can keep one bank account for all invoices or switch to **Advanced** mode to route invoices to different bank accounts based on invoice currency, customer country, and/or customer segment. If you wish to delete an invoicing entity, please contact support. ## Payment methods Payment methods are configured separately for each invoicing entity. This lets you select the payment methods that the entity can offer and choose the default payment provider or bank account used for each method. To review these settings, go to **Settings** > **Invoicing entities**, select the invoicing entity, then open **Payment methods**. ### Configure bank accounts for bank transfers For bank transfers, the selected bank account determines which account details Hyperline adds to an invoice. In the **Bank transfer** row, you can either pick a single bank account used for every invoice, or switch to **Advanced** mode to route invoices to different accounts based on the invoice and customer. Advanced mode requires at least one bank account to be configured for the invoicing entity and is not compatible with an automated bank transfer provider. Switching to Advanced mode clears any automated bank transfer provider selection. #### Advanced mode In Advanced mode, you define a list of **mappings**. Each mapping combines one or more criteria with the bank account to use when the criteria match: * **Currency**: match invoices issued in a specific currency. * **Country**: match customers based in a specific country. * **Segment**: match customers that belong to a specific segment. Each mapping must specify **at least one criterion** and **a bank account**. Criteria within a mapping are combined with AND. For example, a mapping with `Currency: EUR` and `Country: France` only applies to invoices in EUR issued to customers based in France. You can save the settings only once the mappings table has at least one row. When an invoice is generated, Hyperline picks the bank account of the mapping whose criteria match the invoice and its customer, and adds those account details to the invoice. Mappings that combine more criteria are considered more specific than mappings with fewer criteria. To configure mappings, open the **Bank transfer** row, choose **Advanced**, then **Add mapping** for each rule you need. Click **Save changes** when you are done. See [Payment methods](../payments/payment-methods) for details about supported methods, payment service providers, and customer-level configuration. ## Tax enforcement Tax enforcement settings are scoped to each invoicing entity. In **Settings** > **Taxes**, you can: * Enable **Require customer tax ID** when company customers billed by this entity must have a tax ID before billing details can be completed. * Enable **Require valid tax ID for reverse charge** when reverse charge should apply only after the customer's tax ID has been externally validated. See [Tax management](../invoices/tax-management#tax-enforcement-options) for details on validation statuses, VIES, and reverse charge behavior. ## Customer-level configuration Invoicing entities are assigned at the customer level, and each customer is linked to a single invoicing entity. Updating a customer’s invoicing entity will not impact existing active subscriptions; only new subscriptions created after the update will reflect the change. When customers are created via CRM integrations or other automated flows, Hyperline will automatically assign an invoicing entity based on the customer’s country. If no country-specific match is found, the default invoicing entity will be used instead. ## Reporting You can filter your dashboard by invoicing entity, allowing you to have a global view on the entity's business metrics. The invoicing entity can also be found in most exports, allowing you to do your own data analysis. You can use the API to fetch elements like customers or invoices that match a specific invoicing entity. # Account settings Source: https://docs.hyperline.co/docs/account/settings Configure general Hyperline account settings including account name, supported currencies, email notifications, saved views, and Markdown formatting. Account settings control how your account is configured and how billing documents and emails behave across Hyperline. ## General settings Use **Settings > General** for workspace-level settings such as your account name and security options. Billing details are configured at the invoicing entity level instead of the general account level. See [Invoicing entities](./invoicing-entities) to configure each legal entity's billing profile. ## Currencies Hyperline supports multiple currencies for products, prices, subscriptions, quotes, and invoices. The main currency concepts are: | Currency | Where it applies | | ------------------- | -------------------------------------------------------------------------------------------------------- | | Customer currency | The currency used for the customer, quotes, subscriptions, and invoices created for that customer | | Quote currency | The currency selected when the quote is created. It cannot be changed afterward | | Accounting currency | The currency used by an invoicing entity for accounting and converted invoice footer amounts when needed | | Reporting currency | The currency used for aggregated app views such as dashboards and revenue reporting | Payment currency support also depends on the connected payment provider and enabled payment methods. For payment setup, see [Payment methods](../payments/payment-methods). ## Email settings Use **Settings > Emails** to configure account-level email behavior. The email settings area is organized around: | Area | What it controls | | ----------------- | --------------------------------------------------------------- | | **Automated** | Which customer emails Hyperline sends automatically | | **Recipients** | Additional internal recipients for selected email notifications | | **Configuration** | Sender, reply, and delivery settings available for your account | Customer automated emails can include invoice, checkout, and payment error notifications. For invoice-specific behavior, see [Invoice emails](../invoices/emails). ## Saved views Saved views let you save filtered list views for customers, subscriptions, and invoices. Use saved views when your team repeatedly works with the same operational slices, such as: * Active enterprise customers * Past-due invoices * Subscriptions renewing soon * Customers owned by a specific team Creating, updating, and deleting saved views requires the **Manage saved views** permission. ## Markdown text Hyperline supports Markdown formatting in selected document text areas, such as invoice legal information and invoice additional information. Common formatting includes: | Syntax | Result | | ---------------------------------- | ------------------ | | `**text**` | Bold text | | `*text*` or `_text_` | Italic text | | `---` | Horizontal divider | | `- text` | Bulleted list | | `[text](https://www.hyperline.co)` | Link | You can also use variables such as `{{customer_name}}` or custom property slugs when supported by the selected field. ## Related * [Configure your account](../getting-started/configure-account) * [Users & permissions](./users-permissions) * [Invoicing entities](./invoicing-entities) * [Single sign-on and user provisioning](./enterprise-sso) * [Sandbox and test mode](../getting-started/sandbox) * [Payment orchestration](../payments/orchestration) * [Payment methods](../payments/payment-methods) # Users & permissions Source: https://docs.hyperline.co/docs/account/users-permissions Invite or automatically provision team members, configure single sign-on, and assign roles to control access to your Hyperline account. You can invite an unlimited number of team members to access your Hyperline account. Hyperline offers flexible roles and permissions through access control (ACL), allowing you to configure the appropriate access levels for each member of your account. ## Invite members To invite multiple members at the same time, you can specify multiple emails separated with commas in the **Email** field. Your new members will have to accept the invite sent to their email address to be able to access Hyperline. If the member is already part of another Hyperline account, they will be able to [switch from one to another easily](../getting-started/sandbox#multiple-accounts) using the same login credentials. ## Single sign-on and provisioned members When single sign-on and directory provisioning are enabled, Google Workspace can automatically create, update, suspend, restore, and remove memberships for this Hyperline account. Manually invited members remain supported and are not affected by directory changes. Provisioned memberships display a **Provisioned** label. Their role and removal actions are disabled in the member list because Google Workspace groups and Hyperline role provisioning rules control their access. See [Single sign-on and user provisioning](./enterprise-sso) to configure the connection and map Google groups to Hyperline roles. ## Transfer account ownership The current account owner can transfer account ownership to another member from the team settings. The new owner must already be a member of the account. After the transfer, the selected member becomes the account owner and can perform owner-only actions going forward. ## Manage profile notifications Each user can manage their own notification preferences from **Profile > Notifications**. The page is organized into: | Area | What it controls | | -------------------------- | ------------------------------------------------------------------------ | | **Notification channels** | Which personal channels Hyperline can use to notify you | | **Approval notifications** | Which approval events should trigger notifications for you | | **Customer notifications** | Which customer events should trigger notifications for you | | **Followed segments** | Which segments automatically add you as a follower on matching customers | ### Notification channels Use **Notification channels** to decide where Hyperline can deliver enabled personal notifications. * **Slack DM**: sends direct notifications to you in Slack when Slack is connected in your workspace settings You can use **Send test** to check whether Hyperline can send you a Slack DM. If Slack DM is unavailable, Slack may not be connected in your workspace settings, or Hyperline may not find a Slack user for the email address configured in your profile. ### Approval notifications Use **Approval notifications** to choose which approval events should notify you. For **Approval requested**, Hyperline notifies you when a quote requires approval from you. ### Customer notifications Use **Customer notifications** to choose which customer events should notify you when you are linked to the customer. You can enable or disable: * **Invoice settled** * **Invoice becomes late** * **Payment fails** * **Payment method changes** * **Payment method deleted** * **Monitoring score changes** * **Contract renews soon** Some events only appear when the related feature is enabled. For example, **Monitoring score changes** appears when Customer Intelligence is enabled. To receive a customer notification, you need both: * The event enabled in **Customer notifications** * A recipient link to the customer, either as owner, direct follower, or follower through a segment ### Followed segments Use **Followed segments** to automatically follow every customer that matches a segment. 1. Go to **Profile > Notifications**. 2. In **Followed segments**, select a segment. 3. Click **Add**. Following a segment affects who can receive customer notifications. It does not create a separate notification trigger. For example, if you follow a **Late payment behavior** segment and enable **Invoice becomes late**, Hyperline can notify you when a customer in that segment has a late invoice. ## Manage roles You can create custom roles with specific permissions to provide fine-grained access for members based on your needs. By default, two roles are created for you: * **Admin**: full access to Hyperline, including the ability to manage products, plans, customers, subscriptions, and settings * **Account Manager**: limited permissions and limited view on Hyperline, allowing them to manage customers, subscriptions, and invoices (ideal for account management teams) Additionally, you can for example create roles for external accountants, finance team, product/tech teams, sales representatives, etc. The accounting module has its own three permissions — viewing the section, updating its settings, and making recognition adjustments. See [Accounting permissions](/docs/accounting/getting-started#permissions) for what each one unlocks. ### Default role One of the roles is designated as the default. This role is automatically assigned to members created through a connected integration, such as a CRM. It is also used for provisioned members when none of their identity provider groups matches a role mapping. Account Manager is the default role for each newly created Hyperline account. You can easily set the default role to another existing one. ### Create new role # Chart of accounts Source: https://docs.hyperline.co/docs/accounting/accounts Manage the chart of accounts for each Hyperline ledger: pre-populate GL accounts, customize them, and reference them in accounting rules. Each ledger has a chart of accounts — the list of GL (General Ledger) accounts that Hyperline uses when posting journal entries. Accounts are referenced in your [accounting rules](./rules) to determine which account receives each debit or credit. Two places in the app deal with accounts, and they do different jobs: * **Accounting** > **Settings** > **Chart of accounts** is where you *manage* accounts — add, edit, delete, or sync them from your accounting provider. It lists codes, names, and types only. * The **Ledger** tab is where you *read* them — balances, movements, and the [financial report exports](#export-financial-reports). ## Default account sets When you create a ledger, Hyperline can pre-populate its chart of accounts with a standard set of accounts matching your chosen accounting standard: | Standard | Included accounts | | ---------------- | ------------------------------------------------------------------------ | | IFRS | International template (1000s assets, 4000s revenue, 6000s expenses) | | Local GAAP | International template (same as IFRS) | | US GAAP | ASC 606 revenue accounts with CECL allowance for credit losses (ASC 326) | | UK GAAP | FRS 102 naming (Trade Debtors, Deferred Income, VAT Output) | | FR GAAP | Plan Comptable Général codes (512000, 706100, 706200, etc.) | | Management | M-codes for ARR/MRR bucketing (new, expansion, churn) | | Consolidation | Minimal set for intercompany and adjustment entries | | Audit adjustment | Same as consolidation | You can modify these defaults at any time. Default account sets also come with a matching set of default [accounting rules](./rules) pre-configured for those accounts. ## Account types Hyperline supports the following GL account types: | Type | Description | | ------------------ | --------------------------------------------------------------- | | `Asset` | Cash, accounts receivable, and other resources owned | | `Contra Asset` | Offsets an asset account (e.g. allowance for doubtful accounts) | | `Liability` | Deferred revenue, tax payable, customer credits | | `Contra Liability` | Offsets a liability account | | `Equity` | Retained earnings, share capital | | `Revenue` | Subscription revenue, usage revenue, one-off fees | | `Contra Revenue` | Discounts, refunds, promotional adjustments | | `Expense` | Bad debt, payment processing fees | ## Add an account Go to **Accounting** > **Settings** > **Chart of accounts** and click **Add account**. Each account requires: * **Code** — a unique identifier within the ledger (e.g. `4000`, `706100`) * **Name** — a descriptive label (e.g. "Subscription Revenue") * **Type** — one of the account types listed above ## Edit an account Click the edit icon next to any account in the accounts list. You can update the code, name, and type at any time. ## Delete an account Click the delete icon next to the account and confirm. Accounts with existing journal entry lines cannot be deleted. ## Sync accounts from your accounting provider An existing chart of accounts can be pulled directly from the provider instead of creating accounts manually. The **Sync accounts** button only appears once you have connected an accounting integration. Go to **Settings** > **Integrations** to connect your provider first. Go to **Accounting** > **Settings** > **Chart of accounts** and click **Sync accounts**. Hyperline will fetch the current chart of accounts from the provider and import the accounts into your ledger. [Supported providers](/integrations/overview#accounting-software) for account sync are Xero, QuickBooks, Exact Online, Pennylane, NetSuite, and Rillet. You can then reference these accounts in your rules and map them to Hyperline's standard account roles (accounts receivable, revenue, deferred revenue, etc.). ### Use synced accounts in rules After syncing accounts from your provider: 1. Review the imported **Code**, **Name**, and **Type** values. 2. Open **Accounting** > **Settings** > **Rules**. 3. Select the synced accounts in your rule mappings, such as **Revenue account**, **Deferred revenue**, **Accounts receivable**, **Cash / bank account**, or **Payment clearing account**. 4. Add rule filters when the account should only apply to specific products, currencies, countries, billing intervals, coupons, payment methods, or provider accounts. 5. Save the rule and retry or resync any integration issues that were waiting on account mapping. Syncing accounts from your provider ensures that account codes match exactly — which is required for journal entries to post correctly in your external accounting software. If an account does not appear after syncing, check that the account is active, available for the relevant entity, and visible to the role or user connected to Hyperline. ## Browse account activity Balances and movements live on the **Ledger** tab, the default landing page of the **Accounting** section — not on the chart of accounts settings page, which shows no figures. The tab is an expandable list with one row per account. Collapsed, a row shows the account **code**, its **name**, and its **closing balance** for the selected quarter. Expanding a row reveals: * **Opening balance** — the balance carried into the quarter * The **debit** and **credit** movements posted during the quarter * **Closing balance** — opening balance plus the period's movements * A **View journal entry lines** button, which opens the account's [journal entry lines](./entries#journal-entry-lines-drill-down) for that quarter Above the list you can pick the **quarter**, filter by account **Type**, and search by code or name. Accounts can be ordered by **Code** or by **Name**. ## Export financial reports From the **Ledger** tab, the **Export** dropdown produces three reports based on the currently selected quarter: | Report | Scope | Format | | -------------------- | ------------------------------------------------------------------------------------ | ------ | | **General ledger** | All entries posted between the start and end of the selected quarter | XLSX | | **Income statement** | Revenue and expenses for the selected quarter, in the ledger's functional currency | XLSX | | **Balance sheet** | All asset, liability, and equity balances as of the last day of the selected quarter | XLSX | Exports run asynchronously. You will be notified in-app once the file is ready, and it will be available from **Exports** in the main navigation. # Journal entries Source: https://docs.hyperline.co/docs/accounting/entries Browse every journal entry from the Journal tab, drill into a single account's lines from the Ledger, and audit accounting activity in any Hyperline ledger. Journal entries are posted automatically from your billing activity. To understand *how* they are produced — the debits and credits behind each billing event — see [how entries are computed](./entry-mechanics). This page covers where you read them. There are two surfaces, and they answer different questions: | Surface | Where | Answers | | ---------------------------------- | ------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- | | **Journal** tab | **Accounting** > **Journal** | "Show me every entry in this ledger" — a flat, paginated table with its own filters and export | | **Journal entry lines** drill-down | **Accounting** > **Ledger** > expand an account > **View journal entry lines** | "Show me what hit *this* account in *this* quarter" — a side panel listing the account's lines, with the full entry next to them | The drill-down also opens from an [invoice](/docs/invoices/overview#accounting), via **View in ledger** on any of the invoice's journal entries. ## Journal tab The **Journal** tab lists every journal entry in the ledger, most recent first. | Column | Description | | --------------- | -------------------------------------------------------------- | | **Entry** | Entry number (e.g. `JE-001`) | | **Date** | Date of the journal entry | | **Rule** | Code of the accounting rule that generated the entry | | **Description** | What the entry was posted for | | **Amount** | Total amount of the entry, in the ledger's functional currency | Click any row to open that entry in a side modal, with the [entry detail](#entry-detail) described below. ### Filters * **Status** — `Posted` or `Draft` * **Account** — only entries touching a given GL account * **Entry date** — a start and end date * **Rule** — the accounting rule that generated the entry * **Search** — search by invoice number, customer, or amount ### Export Click **Export** at the top of the **Journal** tab to download a **general ledger** XLSX. The export respects the filters currently applied — status, account, and the entry date range — so you can scope it to a single account, a specific posting state, or any date window. Exports run asynchronously. You will be notified in-app once the file is ready, and it will be available from **Exports** in the main navigation. ## Journal entry lines drill-down This view answers a per-account question, so it always opens with an account and a quarter in context. Open it from the **Ledger** tab (expand an account, then click **View journal entry lines**) or from an invoice's **View in ledger** action. Journal entry lines drill-down It is a side panel split in two: * **Left** — a paginated list of the journal entry **lines** posted to the selected account during the quarter * **Right** — the full [entry detail](#entry-detail) for the line selected on the left The header shows the context: `[Code] - [Account Name] / Journal entry lines / Q[N] YYYY`. Each row on the left represents a single line and shows: | Column | Description | | ----------------- | --------------------------------------------------------------------------- | | **Journal entry** | Entry number (e.g. `JE-001`) | | **Entry date** | Date of the journal entry | | **Status** | `Posted` (green) or `Draft` (gray); posted entries include the posting date | | **Rule** | Code of the accounting rule that generated the line | | **Debit** | Amount if the line is a debit; `—` otherwise | | **Credit** | Amount if the line is a credit; `—` otherwise | Filter the list by **Type** (`Debit` or `Credit`), by **Date range** within the quarter, or search by invoice number, customer, or amount. This view has no export button. To download entries as a spreadsheet, use the [Journal tab export](#export) or the [financial reports](./accounts#export-financial-reports) on the **Ledger** tab. ## Entry detail Both surfaces show the same entry detail — as a side modal from the **Journal** tab, and in the right-hand panel of the drill-down. **Journal entry details** covers the entry itself: * Entry date and status (with the posting date if posted) * Related records — customer, subscription, invoice — when applicable * Original currency, exchange rate, and exchange rate date, shown only when the rate is not 1 **Journal entry lines** lists every debit and credit of the entry: | Column | Description | | ----------- | ------------------------------ | | **Rule** | Accounting rule code | | **Account** | GL account code and name | | **Debit** | Amount if the line is a debit | | **Credit** | Amount if the line is a credit | A bold **Total** row closes the table — debits and credits always match. When an entry has lines across multiple products, lines are grouped by account with each product shown as a sub-row. In the drill-down, the line selected on the left is highlighted here. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # How entries are computed Source: https://docs.hyperline.co/docs/accounting/entry-mechanics Understand the debits and credits Hyperline posts for each billing event: invoice posting, revenue recognition, usage, settlement, refunds, and credit notes. This page explains the **journal entries** Hyperline posts behind the scenes for each billing event — the actual debits and credits, and why. It complements the [accounting rules](./rules) (which decide *which* accounts are used) and the [journal entries view](./entries) (where you browse the posted result). The exact account each line lands on is decided by your [accounting rules](./rules). The tables below use account **names** (Accounts receivable, Revenue, Output tax…); the **codes** depend on the [chart of accounts](./accounts) attached to your ledger. ## Double-entry basics Every Hyperline journal entry follows standard double-entry bookkeeping: * **Each entry balances** — total debits always equal total credits. * **Amounts are net of tax on revenue lines.** Tax is always posted separately to the output tax account when the invoice is issued, regardless of how the revenue itself is recognised. * **Entries are immutable once posted.** Corrections are made with reversing entries (for example a [credit note](#credit-notes)), never by editing or deleting a posted entry. * **One functional currency per ledger.** When an invoice is in a different currency, each line stores both the original-currency amount and the converted ledger amount — see [multi-currency](#multi-currency-and-fx). Throughout this page, each event is shown as a small ledger table: | Account | Debit | Credit | | ----------------- | ----- | ------ | | Example account A | 100 | | | Example account B | | 100 | ## Invoice posted When an invoice is finalised and emitted, Hyperline posts one entry that recognises the receivable and the tax liability, and books the revenue either **immediately** or as **deferred revenue**, depending on the line item's [revenue recognition](./revenue-recognition) method. ### Immediate revenue For a line with no deferral (no recognition rule, or point-in-time recognised on the invoice date), revenue is booked straight away. A €120 invoice line — €100 net + €20 tax — for a product recognised immediately: | Account | Debit | Credit | | ------------------- | ----- | ------ | | Accounts receivable | 120 | | | Revenue | | 100 | | Output tax | | 20 | ### Deferred revenue For a line recognised **over time**, by **usage** (billed in advance), or **point-in-time on a future date**, the revenue is parked in deferred revenue at issue and released later (see [revenue recognition](#revenue-recognition)). | Account | Debit | Credit | | ------------------- | ----- | ------ | | Accounts receivable | 120 | | | Deferred revenue | | 100 | | Output tax | | 20 | ### Discounts How a discount appears depends on the **discount recognition mode**, set on the **Revenue recognition** rule: | Mode | Effect on the entry | | -------------- | --------------------------------------------------------------------------------------- | | Immediate | A contra-revenue (or discount) account is debited for the discount amount at issue | | Deferred | A deferred discount account is debited and released on the same schedule as the revenue | | Use net amount | No separate discount line — revenue is booked net of the discount | ## Revenue recognition Deferred revenue is released to revenue over the service period by a recognition schedule. Each recognition entry — called a **slice** — moves the earned portion out of the liability: | Account | Debit | Credit | | ---------------- | ----- | ------ | | Deferred revenue | 100 | | | Revenue | | 100 | The timing of these slices is driven by the recognition method (over-time granularity, point-in-time basis, or usage). See [revenue recognition](./revenue-recognition) for how each method spreads the amount. Tax is **not** touched at recognition time — it was already posted in full to output tax when the invoice was issued. ## Usage-based revenue Metered products and credit packs are recognised in line with actual consumption. There are two timings, depending on whether the usage is billed **in advance** or **in arrears** — and they post differently. ### Billed in advance The customer is invoiced up front (or buys a credit pack), so the amount sits in **deferred revenue** at issue. Each day, Hyperline releases the share matching that day's consumption: | Account | Debit | Credit | | ---------------- | --------------------- | --------------------- | | Deferred revenue | *(daily usage share)* | | | Revenue | | *(daily usage share)* | Any amount left deferred when a credit pack expires is recognised as **breakage** in a single entry on the expiry date. See [usage-based recognition](./revenue-recognition#usage-based) for the consumption and breakage rules. ### Billed in arrears When usage is billed **after** the period (the invoice is issued at period end for what was already consumed), the revenue is **earned before it is invoiced**. Recognising it only at invoicing would understate revenue during the period, so Hyperline accrues it daily against a **contract asset** — *unbilled revenue* — instead of deferred revenue. **During the period**, each day's consumption is accrued: | Account | Debit | Credit | | ----------------------------------- | --------------------- | --------------------- | | Unbilled revenue *(contract asset)* | *(daily usage share)* | | | Revenue | | *(daily usage share)* | **When the invoice is issued**, the already-earned amount is reclassified from the contract asset to the receivable — it is not re-recognised as revenue: | Account | Debit | Credit | | ------------------- | ------------- | ----------------------- | | Accounts receivable | *(net + tax)* | | | Unbilled revenue | | *(net already accrued)* | | Output tax | | *(tax)* | If the final invoiced amount differs from what was accrued (late usage, corrections), the difference is **trued up** against revenue at issue so the contract asset nets to zero and recognised revenue equals the invoiced net. Accrual runs **per product** and **per ledger**. A customer consumes a metered product through May and is invoiced €300 + €60 tax on 31 May. Across May, Hyperline accrues the €300 day by day (debit Unbilled revenue / credit Revenue). On 31 May the invoice reclassifies it: | Account | Debit | Credit | | ------------------- | ----- | ------ | | Accounts receivable | 360 | | | Unbilled revenue | | 300 | | Output tax | | 60 | Revenue was recognised across May as it was earned — not in a lump on 31 May. See [revenue recognition → usage billed in arrears](./revenue-recognition#usage-billed-in-arrears) for the daily timing, the late-usage grace window, and per-product behaviour. ## Invoice settled When a payment transaction settles, Hyperline clears the receivable against cash. The debit side depends on the payment method: * **Bank transfer / direct cash** → a **cash** account is debited. * **Payment provider (card, etc.)** → a **payment clearing** account is debited (the funds are in transit until the provider pays out). | Account | Debit | Credit | | ---------------------------- | ----- | ------ | | Cash *(or payment clearing)* | 120 | | | Accounts receivable | | 120 | ### Provider fees When the provider deducts a processing fee, the cash received is net of the fee and the fee is booked as an expense: | Account | Debit | Credit | | ---------------------------- | ----- | ------ | | Cash *(or payment clearing)* | 117 | | | Payment processing fees | 3 | | | Accounts receivable | | 120 | ### Paying with customer credits When an invoice is settled using a customer's credit balance rather than cash, the credit liability is drawn down instead of debiting cash: | Account | Debit | Credit | | ------------------- | ----- | ------ | | Customer credits | 120 | | | Accounts receivable | | 120 | ## Refunds A refund reverses a settlement — cash goes back to the customer and the receivable (or a credit) is restored. The legs mirror the settlement entry, debit and credit swapped. | Account | Debit | Credit | | ---------------------------- | ----- | ------ | | Accounts receivable | 120 | | | Cash *(or payment clearing)* | | 120 | ## Credit notes A credit note reverses an invoice, posting to the **same accounts** that were used when the invoice was issued. The revenue (or remaining deferred revenue) and the output tax are reversed; the offsetting side depends on whether the invoice was paid: * **Unpaid invoice** → the receivable is reduced (the customer simply owes less). * **Paid invoice** → a **customer credit** liability is created (the value is owed back to the customer). * **Partially paid** → the receivable is cleared first, any excess goes to customer credits. A €120 credit note (€100 net + €20 tax) against an **unpaid** invoice whose revenue was recognised immediately: | Account | Debit | Credit | | ------------------- | ----- | ------ | | Revenue | 100 | | | Output tax | 20 | | | Accounts receivable | | 120 | Had the invoice been **paid**, the €120 credit would land on **Customer credits** instead of Accounts receivable. If the original line still had **deferred** revenue (not yet fully recognised), the credit note reverses the remaining balance from the deferred revenue account rather than from revenue, so it only claws back what was actually recognised. ## Multi-currency and FX Each ledger keeps its books in a single **functional currency**. When an invoice or payment is in another currency, every journal entry line stores: * the **original-currency** amount (as billed), and * the **ledger-currency** amount (converted), plus the exchange rate and rate date used. The rate is captured **at the time of the event** (invoice emission date, payment date) and frozen on the entry, so historical entries are never re-translated when rates later move. The same rate is used across an event's related entries — for example, accrued usage is accrued, reclassified, and trued up at one consistent per-ledger rate so the contract asset nets cleanly. ## Bad debt The default chart of accounts includes an **allowance for doubtful accounts** (a contra-asset that offsets receivables) and a **bad debt expense** account. These roles can be mapped on your [accounting rules](./rules) so that, when a receivable is deemed uncollectible, the outstanding amount is written off the books instead of remaining in Accounts receivable. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Getting started with accounting Source: https://docs.hyperline.co/docs/accounting/getting-started Set up accounting in Hyperline: create your first ledger and let Hyperline generate journal entries from your billing activity automatically. Hyperline's accounting module turns your billing activity into journal entries automatically. Every invoice, payment, and credit note posts to your books following rules you control, so your books always match what you billed and deferred revenue is recognised on schedule. No spreadsheets, no manual bookkeeping. The accounting module is not enabled by default. [Contact our team](mailto:support@hyperline.co) or reach out via the in-app chat to have it enabled on your workspace. The module is built around five building blocks: | Building block | What it does | | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **[Ledger](./ledgers)** | One set of books attached to an invoicing entity. You can keep several ledgers per entity, for example a statutory ledger (the official books you file with tax authorities and auditors) next to a management ledger for internal reporting. | | **[Chart of accounts](./accounts)** | The list of general ledger accounts used in journal entries: accounts receivable, revenue, deferred revenue, tax payable, and so on. Each ledger has its own. | | **[Accounting rules](./rules)** | Define which accounts to debit and credit for each billing event, with filters to scope them to specific products, customers, currencies, or payment methods. | | **[Journal entries](./entries)** | Generated automatically when billing events occur, based on your rules. Posted entries cannot be edited: corrections are made via reversal entries. | | **[Revenue recognition](./revenue-recognition)** | When revenue has to be spread over time, tied to a future date, or matched to usage, Hyperline defers it and recognises it on schedule automatically. | ## Before you start Make sure you have: * The accounting module enabled on your workspace (see above) * Billing activity to account for (invoices, payments, credit notes), current or upcoming * The accounting standard your books follow (IFRS, US GAAP, UK GAAP, French GAAP, or another local GAAP) * A decision on whether you will sync entries to an external accounting tool, such as Xero, QuickBooks, Pennylane, NetSuite, Exact Online, or Rillet ## Permissions Access to the accounting module is controlled by three permissions, granted to a role in **Settings** > **Team**. See [Users & permissions](/docs/account/users-permissions#manage-roles) for how to create a role. | Permission in the role form | What it unlocks | | ------------------------------- | ------------------------------------------------------------------------------------ | | **View accounting page** | The whole **Accounting** section: ledger, revenue recognition, journal, and settings | | **Update accounting settings** | Creating and editing ledgers, accounts, and rules | | **Make accounting adjustments** | The **Adjust remaining recognition** action on a recognition schedule | **View accounting page** also gates accounting exports: without it, general ledger, income statement, balance sheet, and revenue recognition files are neither visible nor downloadable from **Exports**. ## Setup flow ### 1. Create your ledger A ledger is one self-contained set of books, with its own chart of accounts, rules, and journal entries. Most companies start with a single ledger mirroring the official books they report on. Go to **Accounting** and click **Create ledger**. You will be asked to configure, in this order: * **Name**: a label to identify the ledger (e.g. "Statutory IFRS") * **Ledger type**: the accounting standard, which determines the starting chart of accounts and rules * **Invoicing entity**: the entity this ledger is attached to * **Currency**: the **functional currency**, the single currency this ledger keeps its books in. Invoices in other currencies are converted using the exchange rate at invoice time * **Journal entry pattern**: the numbering format for journal entries (e.g. `JE-{YYYY}-{number}`). The pattern accepts `{number}` (required, the sequential counter), `{YYYY}`, `{MM}`, and `{DD}` Start with **one statutory ledger** (the official books you file with tax authorities and auditors) and pick the type matching your jurisdiction: | Your books follow | Pick | | ------------------------------------ | ---------------------- | | French GAAP (Plan Comptable Général) | `FR GAAP` | | US GAAP (ASC 606) | `US GAAP` | | UK GAAP (FRS 102) | `UK GAAP` | | IFRS or another standard | `IFRS` or `Local GAAP` | If you plan to sync this ledger with an external accounting provider, select the standard that matches your provider's chart of accounts. It simplifies the account mapping later. Leave the `Management`, `Consolidation`, and `Audit adjustment` types for later. They serve advanced setups such as tracking annual and monthly recurring revenue or group-level eliminations, and the consolidation and audit types ship without default rules. See [Ledgers](./ledgers#ledger-types) for the full list. ### 2. Accounts and rules are created for you Setting up a chart of accounts and mapping every billing event to the right accounts is usually the tedious part. Hyperline does it for you, based on the ledger type you picked: * A **chart of accounts** matching the selected standard, such as ASC 606 revenue accounts for US GAAP * A complete set of **accounting rules** mapping each billing event (invoice posted, invoice settled, credit note created) to the right accounts Entries post correctly without any extra configuration. You can review everything in **Accounting** > **Settings**, and customise [accounts](./accounts) and [rules](./rules) at any time, for example to map a specific product to its own revenue account. Syncing to an external accounting tool? Instead of using the default accounts, you can [pull the chart of accounts directly from your provider](./accounts#sync-accounts-from-your-accounting-provider) so account codes match exactly. ### 3. Watch entries post From here on, you never write these entries by hand. Each time an invoice is finalised, a payment settles, a credit note is issued, or usage is consumed on a usage-based product, Hyperline applies your rules and posts the matching debits and credits. You can browse them in three places: * **Accounting** > **Journal**: every entry in the ledger as a flat list, with filters for status, account, entry date, and rule * **Accounting** > **Ledger**: entries seen per account, for a selected quarter * The **Accounting** section on any invoice: the entries and recognition schedules for that specific invoice **Entries are not retroactive.** A new ledger only posts journal entries and recognition schedules for events that happen **after it is created** (new invoices, settlements, credit notes, usage) — nothing is generated for your existing billing history. The same applies to changes you make later: editing a rule or an account changes how **future** entries post, it does not recompute entries that are already posted. To bring past periods into the ledger, or to re-apply a corrected rule to a period already posted, [contact our team](mailto:support@hyperline.co) or reach out via the in-app chat. A replay rebuilds the automated entries for the range you ask for, and leaves any [manual recognition adjustments](./revenue-recognition#adjust-remaining-recognition) untouched. ### 4. Verify a first invoice Once a first invoice has been issued, open the invoice page and scroll down to its **Accounting** section: accounts receivable should equal the total owed, revenue (or deferred revenue) the net amount, and the tax line the tax. If those match, every future invoice will post the same way. To understand exactly which debits and credits Hyperline posts for each event, see [how entries are computed](./entry-mechanics). ## Next steps Scope rules to specific products, customers, or currencies, and understand priorities. Recognition is driven by your accounting rules. Adjust how revenue is deferred and recognised: over time, at a point in time, or based on usage. See the exact debits and credits posted for each billing event. Push invoices to Xero, QuickBooks, Pennylane, NetSuite, and more. Once connected, you can also pull the provider's chart of accounts into your ledger. You can also export financial reports as spreadsheet (XLSX) files. The **Ledger** tab exports the general ledger, income statement, and balance sheet ([details](./accounts#export-financial-reports)); the **Revenue recognition** tab exports the waterfall and the recognized summary ([details](./revenue-recognition#export)). Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Ledgers Source: https://docs.hyperline.co/docs/accounting/ledgers Create and manage Hyperline accounting ledgers per invoicing entity for statutory, management, or consolidation books with isolated entries. A ledger is a set of books attached to one of your [invoicing entities](/docs/account/invoicing-entities). All [journal entries](./entries), [accounts](./accounts), and [accounting rules](./rules) are scoped to a ledger. You can create multiple ledgers per invoicing entity to maintain separate books for different purposes, such as statutory reporting, management accounts, consolidation adjustments, and so on. ## Create a ledger To create a ledger, go to **Accounting** and click **Create ledger**. You will be asked to configure, in this order: * **Name** — a label to identify the ledger (e.g. "Statutory – IFRS", "Management") * **Ledger type** — the starting chart of accounts and configuration to apply (see ledger types below) * **Invoicing entity** — the entity this ledger is attached to * **Currency** — the functional currency for this ledger; amounts in other currencies are converted using the exchange rate at invoice time * **Journal entry pattern** — the numbering format for journal entries (e.g. `JE-{YYYY}-{number}`). The pattern accepts `{number}` (required, the sequential counter), `{YYYY}`, `{MM}`, and `{DD}` If you plan to sync this ledger with an external accounting provider, select the account standard that matches your provider's chart of accounts — this simplifies the account mapping later. A new ledger starts empty: it posts nothing for billing activity that happened before it was created. See [Getting started](./getting-started#3-watch-entries-post) for how to have past periods replayed into it. ## Ledger types Hyperline supports the following ledger types, each pre-configured with a matching chart of accounts: | Type | Purpose | Default account set | | ------------------ | ---------------------------------------- | ------------------------------------------------------------------------ | | `IFRS` | International statutory reporting | International template (1000s assets, 4000s revenue, 6000s expenses) | | `US_GAAP` | US statutory reporting | ASC 606 revenue accounts with CECL allowance for credit losses (ASC 326) | | `UK_GAAP` | UK statutory reporting | FRS 102 naming (Trade Debtors, Deferred Income, VAT Output) | | `FR_GAAP` | French statutory reporting | Plan Comptable Général codes | | `LOCAL_GAAP` | Other local statutory reporting | International template (same as IFRS) | | `MANAGEMENT` | Internal reporting, ARR/MRR tracking | M-codes for ARR/MRR bucketing (new, expansion, churn) | | `CONSOLIDATION` | Group-level eliminations and adjustments | Minimal intercompany and adjustment accounts | | `AUDIT_ADJUSTMENT` | Post-close corrections | Same as consolidation | Each ledger maintains its own chart of accounts, rules, and journal entry sequence independently. ## Edit a ledger **Accounting** > **Settings** opens with a read-only **Configuration** block summarising the current ledger. Click **Edit ledger** there to update its name, type, entity, currency, or journal entry pattern. ## Delete a ledger **Delete ledger** sits alongside **Edit ledger** in the same Configuration block. Deleting a ledger permanently removes its accounts, rules, and journal entries. The primary ledger cannot be deleted. Deleting a ledger is irreversible. Make sure you no longer need the ledger's history before proceeding. # Revenue recognition Source: https://docs.hyperline.co/docs/accounting/revenue-recognition Automate deferred revenue and recognition schedules in Hyperline, with per-line schedules and journal entries posted as revenue is earned. When a customer pays upfront for a service delivered over time, the revenue cannot be recognised immediately — it must be deferred and released as the service is performed. Hyperline manages this automatically by creating recognition schedules on each invoice line item and posting the corresponding journal entries as revenue is earned. Revenue recognition is available on supported plans and may require activation on your account while the feature is being rolled out. If you do not see **Accounting** > **Revenue recognition**, contact support to confirm availability and access. All revenue recognition amounts are **net of tax**. Tax is always posted separately as a liability (output tax account) at the time the invoice is issued, regardless of the recognition method applied to the revenue. ## Recognition methods The recognition method is defined in your **Revenue recognition** accounting rule. It can be set at the rule level and overridden for specific products or customer segments using filters. ### Over time Revenue is spread evenly across the service period using a straight-line allocation. You configure the **granularity** at which Hyperline posts recognition entries: | Granularity | How revenue is spread | | ----------- | -------------------------------------------- | | Daily | Recognised each day over the service period | | Monthly | Recognised at the end of each calendar month | | Quarterly | Recognised at the end of each quarter | | Yearly | Recognised at the end of each year | A customer pays €12,000 upfront for a 12-month SaaS subscription starting 1 January. With monthly granularity, Hyperline defers the full €12,000 at invoice time and recognises €1,000 each month from January to December. ### Point in time All revenue is recognised at a single date. You configure the **recognition date basis**: | Basis | Recognition date | | ------------------ | ----------------------------------- | | Invoice date | The date the invoice was issued | | Service start date | The first day of the service period | | Service end date | The last day of the service period | A one-off implementation fee with "service end date" basis will remain deferred until the end of the project, at which point the full amount is recognised. ### Usage-based Revenue is recognised in line with what your customers actually consume. Use this method for **metered products** and **credit packs** — the amount you recognise each day reflects that day's usage, not a flat allocation. When the invoice is issued, the full amount is parked in deferred revenue. Each day, Hyperline releases the share corresponding to that day's consumption. Days with no usage recognise nothing; busy days recognise more. This covers usage billed **in advance** — the customer prepays (or buys a credit pack) and the amount is deferred at issue. When usage is billed **in arrears** (invoiced at the end of the period for what was already consumed), revenue is accrued against a contract asset instead — see [usage billed in arrears](#usage-billed-in-arrears). #### Recognition timing A daily job sweeps every day's slice and only releases revenue once the day's usage total has been seen unchanged on two consecutive runs — i.e. no late events landed between observations. This stability gate gives a **≥24 hour grace period** for late-arriving usage events. In practice, day **D**'s revenue is recognised at the next-but-one daily run (typically two days after the consumption day). A day with **zero** observed usage gets an extra **7 days** before being closed at zero, so a slow-starting customer or a delayed ingestion pipeline doesn't permanently zero out an early slice. Two carve-outs to that gate: * **Catching up on old periods.** A day whose period closed more than 7 days ago is recognised on the first pass, without waiting for a second observation — the late-event window has already elapsed. * **Credit-pack drawdown has no grace period.** Drawdown is recognised as soon as it is read. If a drawdown lands late, Hyperline trues the schedule up with an additional slice rather than dropping the amount. Once a day's revenue has been recognised, **events landing for that day after recognition are not retroactively allocated**. If your usage pipeline regularly produces late events older than 48 hours, reach out before relying on usage-based recognition for material amounts. | Setting required | Where to set it | | ------------------------------ | ------------------------ | | A revenue account | Revenue recognition rule | | A deferred revenue account | Revenue recognition rule | | Metered or credit-pack product | Catalog | A customer is invoiced €600 upfront for a metered product over a 30-day service period and consumes 1,000 units across that period. Hyperline defers €600 at invoice time, then recognises each day in proportion to that day's consumption — a day with 50 units recognises €30, a day with no usage recognises nothing. #### Credit packs Credit packs follow the same usage-based engine, with the schedule anchored on the **credit topup** rather than a metered aggregator: * The service window is the topup's **validity period** (`createdAt → expiresAt`). Non-expiring topups inherit the line item's billing period. * Each day, Hyperline reads the credits **drawn down** that day and releases the proportional share of the topup's value. * When a customer holds **multiple active topups**, drawdown is attributed **FIFO** — the oldest topup is consumed first, so its schedule recognises ahead of newer ones. A customer buys a €1,000 / 500-credit pack valid for 90 days. Over that window they consume 400 credits. Hyperline recognises €800 across the 90 days in proportion to daily consumption; the remaining €200 stays deferred until expiry. ##### Breakage on expiry When a topup expires with credits unconsumed, the unrecognised remainder is recognised in a single entry on the expiry date as **breakage** (per ASC 606-10-55-46 through 55-49). Any pending future slices on the schedule are cancelled, and the schedule is closed. Continuing the example above: on day 90, the topup expires with 100 credits unused. Hyperline posts a single recognition entry for the remaining €200 on the expiry date and marks the schedule completed. Flat fees and seats use over-time or point-in-time recognition — usage-based doesn't apply to non-metered, non-credit products. ### Usage billed in arrears Some metered products are billed **in arrears** — the invoice is issued at the end of the period for usage that already happened, so the revenue is **earned before it is invoiced**. Deferring it (as for prepaid usage) would understate revenue during the period, so Hyperline recognises it as it is consumed and holds it as a contract asset — **unbilled revenue** — until the invoice is issued. Each day during the period, Hyperline recognises that day's consumption against unbilled revenue (rather than releasing it from deferred revenue). When the invoice is issued at period end, the accrued amount is reclassified from unbilled revenue to accounts receivable — it is **not** recognised again. If the final invoiced amount differs from what was accrued (late usage, corrections), the difference is trued up at issue so unbilled revenue nets to zero and recognised revenue equals the invoiced net. Accrual runs **per product** and **per ledger**, and uses the same daily stability gate as prepaid usage — a day's revenue is released once its usage total has been seen unchanged on two consecutive runs, giving a ≥24 hour grace period for late events. | Setting required | Where to set it | | ------------------------------------- | ------------------------ | | A revenue account | Revenue recognition rule | | An unbilled (accrued) revenue account | Revenue recognition rule | | Metered product billed in arrears | Catalog | A customer consumes a metered product through May and is invoiced €300 (net) on 31 May for that usage. Across May, Hyperline recognises the €300 day by day as it is consumed, holding it in unbilled revenue. On 31 May the invoice moves the €300 from unbilled revenue to accounts receivable — no revenue is recognised a second time. See [how entries are computed → usage billed in arrears](./entry-mechanics#billed-in-arrears) for the exact debits and credits at accrual, invoicing, and settlement. ## Discount recognition When a line item includes a discount, you control how the discount amount is treated at recognition time using the discount recognition mode on the **Revenue recognition** rule: | Mode | Behaviour | | -------------- | ---------------------------------------------------------------------------------------------- | | Immediate | Discount is recognised in full at invoice time (posted as contra-revenue immediately) | | Deferred | Discount follows the same recognition schedule as the revenue (spread over the service period) | | Use net amount | Revenue is recognised net of the discount — no separate discount entry is created | ## Recognition schedule statuses Each invoice line item gets a recognition schedule. The schedule can have the following statuses: | Status | Meaning | | ------------- | ------------------------------------------------------------- | | `pending` | The schedule has been created but recognition has not started | | `in_progress` | Recognition has started; some entries have been posted | | `completed` | The schedule is fully processed and closed | | `cancelled` | The schedule was cancelled before recognition began | ## Revenue waterfall Go to **Accounting** > **Revenue recognition**. The tab is a single matrix — the **revenue waterfall** — showing, for each **booking month** (the month invoices were issued), how the booked revenue unwinds into recognised revenue across the following months, and how much is still deferred. Read it left to right, under three band labels: | Band | What it holds | | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Booked revenue** | One row per booking month; the amount invoiced (net of tax) in that month | | **Recognized revenue** | One column per recognition month. A **past** month shows one `Recognized` column, a **future** month one `Remaining` column, and the **current** month both | | **Total revenue** | The row's **Recognized** total (everything posted so far) and **Remaining** (Booked − Recognized, the deferred balance still on the balance sheet) | Filter the matrix by **year**, **All customers**, **All products**, or free-text search. All waterfall amounts are net of tax and expressed in the ledger's functional currency. ### Drill into a cell To see what makes up a figure, **double-click** any non-zero cell — or select it and click **Explore** in the floating bar that appears. The drill-down lists the line items behind that cell: | Column | Description | | ----------- | ------------------------------------------- | | **Product** | The invoiced product | | **Status** | The recognition schedule's status | | **Period** | The service period covered | | **Amount** | The amount contributed to the selected cell | Select a line item to open its full recognition schedule in a sidebar. ### Recognition schedules The sidebar is where a single line item's schedule lives. It shows: * The **customer**, **subscription**, **invoice**, and **product** the schedule belongs to * An **Overview** with the recognised amount against the booked amount, and a progress bar * The amounts **excluding** and **including** tax * The **recognition method** in plain words (e.g. `Over time - Monthly`) * The **service period** * The **Slices** table — one row per recognition slice, with its `Period` and `Amount`, each tagged `Recognized`, `Pending`, `Reversed`, or `Cancelled` ## Adjust remaining recognition Sometimes the schedule Hyperline computed no longer reflects reality: the obligation was satisfied earlier than planned, delivery was renegotiated, or the service period was set up wrong. Click **Adjust remaining recognition** on a schedule to reshape what is left, without touching what has already been recognised. This action requires the **Make accounting adjustments** permission. See [Permissions](./getting-started#permissions). ### The two moves An adjustment combines two moves in a single operation — you can use either or both: * **Recognize now** — release part or all of the remaining deferred balance immediately. Hyperline posts one entry in the current open period, debiting deferred revenue and crediting revenue. * **Spread the remaining** — re-plan whatever is still deferred over a new **From** → **To** window. If anything has already been recognised on the schedule, **From** is locked to the day after the last recognised slice. Adjustments only ever look forward. Three things never change, whatever you do: * The **booked total** stays the same — an adjustment moves revenue in time, it never creates or destroys any. * **Already-recognised amounts are never touched.** * A **quarterly or yearly** schedule keeps its periodicity when re-spread — it is not silently converted to monthly. ### Preview before applying The editor previews the result before you commit. Each resulting slice is listed with its new amount, and where an amount changed, the old one is struck through next to it. Slices covering the already-recognised span are tagged **Settled**, and any amount you chose to recognise immediately is tagged **Now**. ### Reason A **Reason** is mandatory — it is what makes the adjustment auditable: | Reason | Use it when | | ------------------------------- | -------------------------------------------------------- | | `Obligation satisfied early` | Delivery completed ahead of the planned schedule | | `Renegotiated delivery or ramp` | The commercial terms changed | | `Service-period change` | The period itself moved | | `Correcting a setup error` | The original schedule was wrong | | `Other` | Anything else — a free-text description is then required | ### Audit trail Every adjustment is recorded on the schedule under **Manual adjustments**: who made it, when, how much was recognised early, the new recognition window, the reason, and a link to the journal entry that was posted. Each slice the adjustment produced also carries a **Manual** badge in the **Slices** table, so an automated slice is never mistaken for a hand-made one. The [recognized summary export](#export) carries the same `auto` / `manual` distinction. ### When a schedule can be adjusted The **Adjust remaining recognition** button is available when all of the following hold: * The schedule is `pending` or `in_progress` — a `completed` or `cancelled` schedule has nothing left to move * It still has a remaining deferred balance * It is not a point-in-time schedule — there is no spread to reshape * It does not use deferred discount recognition ## Export The **Export** dropdown on the **Revenue recognition** tab produces two XLSX reports. **Export waterfall** — the matrix as displayed, for the selected year: | Sheet | Contents | | ----------- | ------------------------------------------------------------------------------------------------------------ | | `Summary` | Totals for the selected year | | `Waterfall` | The booking-month × recognition-month matrix | | `Lines` | One row per invoice line item, so you can reconcile recognition entries against the underlying invoice lines | **Export recognized summary** — recognised revenue only, cut three ways: | Sheet | Contents | | ----------------------- | ------------------------------------------------------ | | `Summary` | Total recognised revenue for the period | | `By month` | Recognised revenue per month | | `By customer & product` | Recognised revenue broken down by customer and product | Every amount in the recognized summary carries an **`Origin`** column marking it `auto` (posted by the recognition engine) or `manual` (produced by an [adjustment](#adjust-remaining-recognition)). Exports run asynchronously. You will be notified in-app once the file is ready, and it will be available from **Exports** in the main navigation. # Accounting rules Source: https://docs.hyperline.co/docs/accounting/rules Configure accounting rules that determine which GL accounts Hyperline debits and credits for invoices, payments, credit notes, and refunds. Accounting rules define which General Ledger (GL) accounts Hyperline uses when posting journal entries. Each rule belongs to a type that matches a specific billing event, and can be scoped to a subset of products, currencies, or payment methods using filters. ## Rule types **Accounting** > **Settings** > **Rules** has four tabs, one per rule type: | Type | Trigger | What it controls | | ----------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------- | | **Invoice posted** | An invoice is finalised and emitted | Accounts receivable, revenue (or deferred revenue), output tax, discounts | | **Invoice settled** | A payment transaction is settled | Cash or bank account, payment clearing, any payment processing fees | | **Credit note created** | A credit note is issued | Customer credit liability, contra-revenue entries | | **Revenue recognition** | No independent trigger — applied at invoice posting time alongside the Invoice posted rule | Recognition method, schedule granularity, discount recognition mode | Rules of all types can coexist in the same ledger. Revenue recognition settings are resolved at invoice posting time alongside the **Invoice posted** rule — they are not triggered by a separate event. A fifth type, **accounting software sync**, exists but is not configured here — see [sync rules](#accounting-software-sync-rules) below. ## Account mappings Each rule specifies which GL account to use for each role in the journal entry. The available account roles depend on the rule type: **Invoice posted** * Accounts receivable * Revenue account * Deferred revenue * Output tax / VAT * Discount account * Deferred discount account * Contra-revenue account * Customer credits account * Bad debt / allowance for doubtful accounts **Invoice settled** * Cash / bank account * Payment clearing account * Provider fees expense account * Payment processing fees account * Accounts receivable (cleared on settlement) **Credit note created** * Customer credits account * Contra-revenue account * Deferred discount account * Revenue account (reversed) * Output tax account (reversed) * Accounts receivable (for unpaid invoices) **Revenue recognition** * Revenue account (when recognised) * Deferred revenue (until recognised) Beyond accounts, the **Revenue recognition** rule also carries the recognition behaviour itself: * The **recognition method** — over time, point in time, or usage-based * The **granularity** (for over-time) or the **recognition date basis** (for point-in-time) * The **discount recognition mode** — immediate, deferred, or use net amount See [Revenue recognition](./revenue-recognition#recognition-methods) for what each of these does. ### Accounting software sync rules Accounting software sync rules map Hyperline billing records to the accounts expected by your connected accounting provider. When Hyperline sends a record to an external accounting provider, the resolved account is converted to the provider account code or internal account ID required by that provider. These rules are **not** configured on the accounting **Rules** page. Set them up under **Settings** > **Integrations**, on the connected provider. For invoice sync rules, the main **Revenue account** is used for regular invoice and credit note lines. The optional **Bad Debt Expense** account is used by providers that create a write-off record for uncollectible invoices. For example, NetSuite uses this account on the write-off Credit Memo created and applied to the original invoice when an invoice is marked `uncollectible`. Accounts can be created manually in Hyperline or fetched from your accounting provider by syncing the ledger's chart of accounts. See [Chart of accounts](./accounts#sync-accounts-from-your-accounting-provider). ## View the rule tree Each tab of **Accounting** > **Settings** > **Rules** displays that type's rules as a tree, showing which rules would apply and in what order. This is useful for auditing your rule configuration before going live. ## Filters Rules can be scoped using one or more filters. Available filters depend on the rule type. When a billing event occurs, Hyperline evaluates all matching rules and applies them in priority order. **Invoice posted** | Filter | Description | | ---------------------------- | ----------------------------------------------------------------------------------- | | Products | Match specific products by ID | | Product types | Match by product type (`flat_fee`, `dynamic`, `addon`, `seat`, `one_off`, `credit`) | | Coupons | Match invoices where a specific coupon was applied | | Currencies | Match invoices in a given currency | | Countries | Match customers billed from a given country | | Billing interval | Match by billing period (e.g. monthly, quarterly, annual, one-off) | | Accounting provider accounts | Match a connected accounting provider account | **Invoice settled** | Filter | Description | | ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | Payment providers | Match by payment provider (Stripe, GoCardless, etc.) | | Payment methods | Match by method type (card, SEPA direct debit, ACH, BACS, bank transfer, etc.) | | Bank accounts | Match by the bank account a payment was received on. Useful when you post settlements to different cash GL accounts per bank account. | | Currencies | Match transactions in a given currency | | Accounting provider accounts | Match a connected accounting provider account | **Credit note created** | Filter | Description | | ---------------------------- | ----------------------------------------------------------------------------------- | | Products | Match specific products by ID | | Product types | Match by product type (`flat_fee`, `dynamic`, `addon`, `seat`, `one_off`, `credit`) | | Coupons | Match credit notes where the original invoice used a specific coupon | | Currencies | Match credit notes in a given currency | | Countries | Match customers billed from a given country | | Accounting provider accounts | Match a connected accounting provider account | **Revenue recognition** | Filter | Description | | ---------------------------- | ----------------------------------------------------------------------------------- | | Products | Match specific products by ID | | Product types | Match by product type (`flat_fee`, `dynamic`, `addon`, `seat`, `one_off`, `credit`) | | Coupons | Match invoices where a specific coupon was applied | | Currencies | Match invoices in a given currency | | Countries | Match customers billed from a given country | | Billing interval | Match by billing period (e.g. monthly, quarterly, annual, one-off) | | Accounting provider accounts | Match a connected accounting provider account | An empty filter matches everything — rules with no filters act as catch-all defaults. Rules can also be scoped to specific **customers**, but only through the API — customer scoping is not offered in the rule form. ### Criteria reference The rule form can use the following criteria, depending on the selected rule type: | Criterion | Use it when | | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | | **Products** | A product needs its own revenue, deferred revenue, or provider account mapping. | | **Product types** | A whole product category should share the same mapping, such as all usage products. | | **Coupons** | Discounts or revenue should be mapped differently when a coupon is used. | | **Currencies** | Transactions in one currency should post to a different account. | | **Countries** | Billing from a country or jurisdiction needs a specific mapping. | | **Billing interval** | Monthly, quarterly, annual, or one-off charges need different account treatment. | | **Accounting provider accounts** | A rule should apply only to a specific connected accounting integration account. | | **Payment providers** | Settlements need different accounts depending on the payment provider. | | **Payment methods** | Settlements need different accounts depending on the method, such as card, SEPA direct debit, ACH, BACS, or bank transfer. | | **Bank accounts** | Payments received on different bank accounts should post to different cash accounts. | ## Priority and fallback Priority is **not something you set**. Hyperline derives it from how narrowly the rule is scoped — the more filters a rule carries, the higher its priority — and displays the resulting value read-only under **Advanced** in the rule form. When multiple rules match the same billing event, they are applied as a **priority overlay**: 1. All matching rules are collected and sorted by priority (ascending) 2. Rules are applied in order — each rule overrides only the account roles it explicitly defines 3. For any given account role, the highest-priority rule that defines it wins In practice this means a broad catch-all rule acts as your default, and narrower rules override it for the specific cases they name — you get that behaviour by scoping the rules, not by numbering them. You have a default invoice posted rule with no filters, mapping all revenue to account `4000 – Revenue`. You then add a second rule scoped to a specific product, mapping its revenue to `4100 – Usage Revenue`. The second rule is narrower, so it gets the higher priority: when an invoice is issued for that product, Hyperline uses `4100` for that product's line items and `4000` for everything else. ### Overlapping rules Specificity is scored against the **line actually being posted**, not against the rule in the abstract. A customer-scoped rule only outranks a product-scoped one when the line's customer is one of those the rule names — if it isn't, that rule doesn't match at all. When two rules end up equally specific for the same line, which one wins is **not** guaranteed. Distinguish overlapping rules by scoping them differently rather than relying on a tie-break. ## Add a rule Go to **Accounting** > **Settings** > **Rules**, open the tab for the event you want to cover, and click **Add rule**. 1. Pick the **Rule type**. Note that **Invoice posted** appears as **Invoice issued** in this dropdown — same thing. 2. Under **Applied on**, optionally add filters to scope the rule. 3. Under **Configuration**, map an account to each role. 4. **Advanced** shows the priority Hyperline derived from your filters. It is read-only. ## Edit and delete rules Click the edit or delete icon next to any rule in the rule list. Deleting a rule does not affect already-posted journal entries. # AI monetization Source: https://docs.hyperline.co/docs/ai-monetization/overview Use Hyperline to monetize AI products with usage-based billing, prepaid credits, wallets, subscriptions, and customer-facing balance workflows. AI products often combine predictable subscriptions with variable consumption. Customers may pay for seats, token usage, model calls, generated images, agent runs, data processing, or prepaid credit packs. Hyperline helps you turn those signals into billable products without building a separate billing system for AI usage. Use this page as an entry point when you are designing how to price, package, and bill AI consumption. ## Common AI monetization use cases | Use case | Example | Hyperline capabilities to use | | -------------------------------------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | Token or model usage | Charge based on tokens consumed by each model tier | [Usage events](../usage/send-usage-data), [aggregators](../usage/aggregators), and [usage-based products](../products/overview#usage) | | Prepaid AI credits | Sell 10,000 credits that customers can spend across models, agents, or generations | [Credit products](../credits/overview) with weighted aggregators | | Included allowance and overages | Include 1M tokens in a monthly plan, then bill additional usage | [Usage-based billing](../usage/getting-started) and [subscriptions](../subscriptions/manage) | | Enterprise budget control | Let customers prepay a balance, consume it over time, and top up when needed | [Credits](../credits/overview), [wallets](../wallets/balance), and [customer portal](../customers/portal) | | AI add-ons | Add premium models, extra automation runs, or advanced features on top of a base subscription | [Products and prices](../products/overview), subscriptions, and usage-based products | | Customer-facing consumption visibility | Show customers how usage or credit balances evolve over time | [Customer usage](../usage/customer-usage), [credits](../credits/overview), and [customer portal](../customers/portal) | ## Choose a billing model ### Usage-based billing Usage-based billing works well when customers should pay for exactly what they consume during a billing period. Hyperline receives usage events, converts them into billable metrics with aggregators, and applies the price configured in your product catalog. Use it for token volume, API calls, workflow runs, image generations, storage, compute time, or any metric that should appear on the next invoice. Start with: * [Getting started with usage-based billing](../usage/getting-started) * [Send usage data](../usage/send-usage-data) * [Aggregators](../usage/aggregators) * [Usage-based products](../products/overview#usage) ### Prepaid credits Credits work well when customers should buy a package upfront and spend it flexibly across multiple AI actions. One credit balance can be consumed by several aggregators, each with its own weight. For example, one lightweight model call can consume `1` credit, a premium model call can consume `5` credits, and an image generation can consume `10` credits from the same balance. This lets customers understand a single balance while your pricing still reflects different underlying costs. Start with: * [Credits overview](../credits/overview) * [Credit products](../products/overview#credit) * [Set up credit-based billing for an AI platform](/guides/credit-based-billing-ai) ### Subscriptions with allowances and overages Many AI products use a hybrid model: a recurring subscription gives access to the product and includes a usage allowance, while overages are billed separately. This is useful when customers want predictable pricing, but your costs still depend on consumption. Use this model when you want to package AI usage into tiers such as **Starter**, **Scale**, and **Enterprise**, while still charging for heavy usage beyond the included allowance. Start with: * [Configure usage-based billing](/guides/configure-usage-based-billing) * [Products and prices](../products/overview) * [Manage subscriptions](../subscriptions/manage) ### Wallets and customer balances Wallets are useful when you want to manage a monetary balance for a customer. Credits are usually better for productized AI consumption units, while wallets are useful for prepaid cash balances, manual adjustments, or commercial credits that should offset future invoices. Start with: * [Wallet balance](../wallets/balance) * [Customer portal](../customers/portal) * [Coupons and credits](../coupons/overview) ## Suggested setup path 1. Define the unit you want to monetize: tokens, requests, agent runs, documents processed, generated assets, or another AI-specific metric. 2. Send usage events to Hyperline, or use a data connector if your usage data already lives in another system. 3. Create aggregators that transform raw events into the billable metrics you want to price. 4. Choose the commercial model: usage-based billing, prepaid credits, subscription allowances, wallet balance, or a mix of those models. 5. Add the products to subscriptions, quotes, or self-serve flows so customers can buy and renew them. 6. Use customer usage, credit balances, invoices, and the customer portal to make consumption visible to your team and your customers. For most AI platforms, start with usage events and aggregators. They are the foundation for both usage-based billing and credit consumption. ## Related documentation Connect usage data and configure billable usage metrics. Sell prepaid credit packs and deduct usage from customer balances. Follow a complete example for credit-based billing on an AI platform. Let customers view balances, invoices, and payment information. # Automated exports Source: https://docs.hyperline.co/docs/analytics/automated-exports Set up automated data syncs that push Hyperline datasets — invoices, customers, subscriptions — to your PostgreSQL database on a recurring schedule. Automated exports let you keep selected Hyperline datasets available in your own database for analysis, reporting, and finance operations. Instead of downloading CSV files manually, you can create a **Data sync** that writes Hyperline data to a destination database on a recurring schedule. Each selected dataset is written to its own table. In-app setup currently supports PostgreSQL destinations. Use a dedicated database, schema, or write user for Hyperline exports whenever possible. ## Before you start To create a data sync, make sure that: * You have access to **Settings** in Hyperline * Your destination PostgreSQL database can receive connections from Hyperline * The database user can create tables and write rows * The connection URL is available If your database requires IP allowlisting, allow traffic from: * `15.188.105.163` * `15.188.215.105` * `35.181.129.14` You can also connect through an SSH tunnel when creating the PostgreSQL connection. ## Create a data sync 1. Go to **Settings** > **Data syncs** 2. Click **New sync** 3. Select an existing PostgreSQL connection, or choose **Create new connection** 4. Enter the connection name and database connection details 5. Select the sync status: * **Active**: run automatically on the configured schedule * **Paused**: keep the configuration without scheduled runs 6. Select the sync frequency: * **Every 12 hours** * **Every 24 hours** 7. Select the data to sync 8. Click **Save changes** Hyperline validates the database connection before saving it. After the sync is created, it appears in the **Data syncs** list with its status, selected table count, frequency, and last sync date. ## Available data You can sync invoice exports and Hyperline reports. | Data | Destination table | | -------------------------- | --------------------------------------------- | | Invoices | `hyperline_invoices` | | Invoice line items | `hyperline_invoice_line_items` | | Aged balances | `hyperline_report_aged_balances` | | All customers | `hyperline_report_all_customers` | | All subscriptions | `hyperline_report_all_subscriptions` | | Detailed revenue | `hyperline_report_detailed_revenue` | | Draft invoices | `hyperline_report_draft_invoices` | | Line by line revenue | `hyperline_report_line_by_line_revenue` | | Live subscriptions | `hyperline_report_live_subscriptions` | | Open invoices | `hyperline_report_open_invoices` | | Outstanding invoices | `hyperline_report_outstanding_invoices` | | Renewals | `hyperline_report_renewals` | | Revenue per country | `hyperline_report_revenue_per_country` | | Revenue per line item name | `hyperline_report_revenue_per_line_item_name` | | Revenue per plan | `hyperline_report_revenue_per_plan` | | Revenue per product | `hyperline_report_revenue_per_product` | For more context on the report definitions, see [Reports](./reports). ## How syncs write data Each selected dataset is refreshed as a snapshot. Hyperline creates the destination table if it does not exist, then replaces the table content during each successful sync. If the table already exists, its schema must be compatible with the expected Hyperline columns. Extra columns can exist, but required columns must be present with compatible types. Every exported table includes Hyperline metadata columns, such as: | Column | Description | | -------------------------------- | ------------------------------------------------ | | `_hyperline_source_id` | Stable row identifier used by the sync | | `_hyperline_synced_at` | Time when the row was written to the destination | | `_hyperline_sync_run_id` | Identifier of the sync run that wrote the row | | `_hyperline_report_generated_at` | Time when the report snapshot was generated | | `_hyperline_report_template` | Source report template | | `_hyperline_row_index` | Row position in the generated report | | `_hyperline_row_hash` | Hash of the source row content | Keep Hyperline-managed tables separate from your own transformed tables. Build downstream models or BI views from the `hyperline_*` tables instead of editing the synced tables directly. ## Run and monitor syncs Scheduled syncs run only when the sync is **Active**. You can also click **Run now** from the sync list or sync detail page to start a manual run. Open a sync to review **Run history**. Each run shows: * Whether it was manual or scheduled * Status: `pending`, `processing`, `done`, `partial`, or `error` * Start time * Number of selected tables * Rows written * Error message, when available If a run fails, check that the destination database is reachable and that the user still has permission to create tables and write rows. ## Delete a data sync Deleting a data sync stops future runs. Run history is kept for auditability, but Hyperline no longer updates the destination tables for that sync. ## Related pages * [Reports](./reports) * [Invoice exports](../invoices/exports) * [Pull usage data with connectors](../usage/usage-data-with-connectors) # Dashboard Source: https://docs.hyperline.co/docs/analytics/dashboard Explore the Hyperline dashboard: track collected revenue, outstanding invoices, and weekly performance with daily refreshed billing metrics. The dashboard is the first interface you see when logging in to your Hyperline account. It gives you a quick, effective overview of your business and hints on actions you can take to recover money faster. It displays the amount collected this week along with the number of invoices involved. The data displayed on the dashboard is updated every day at midnight UTC. You need to have the proper permission to access the dashboard. ## Business metrics This section provides key financial insights at a glance, helping you monitor revenue performance, debt, and cash flow. This information can be filtered by currency, invoicing entity, and date range. ### ARR Annual Recurring Revenue (ARR) represents the total annualized revenue a SaaS company expects to generate from active subscriptions over a year. It provides a long-term view of predictable revenue and helps track revenue growth trends. In Hyperline, ARR is a live metric based on the **current subscriptions' configurations and their consumption**. Past or future phases and subscriptions are not taken into account — it reflects a snapshot of the current value as of today, which means it can fluctuate over time. Calculation details: * Coupons with a `once` application are excluded. * Coupons with a `forever` application are included. * Coupons with a duration shorter than the subscription period are excluded. * Taxes (e.g., VAT) are excluded. The number of customers reflects the total active subscribers contributing to ARR, while ARPA (Average Revenue Per Account) represents the average revenue per customer, calculated as ARR ÷ number of customers. ### Outstanding debt Outstanding debt represents the total amount of unpaid invoices, helping businesses track overdue and pending revenue. It is categorized into three components: * Pending: Invoices that are issued but still within the payment term. * Late: Invoices that are past their due date. * Error: Invoices where payment methods could not be charged after retries. Monitoring outstanding debt allows businesses to stay on top of collections, reduce late payments, and address potential billing issues. ### Cash flow This metric tracks the total revenue collected month over month, providing visibility into financial inflows. It helps assess liquidity, revenue trends, and payment patterns. * Recurring revenue: Revenue collected from subscriptions, representing predictable, ongoing revenue. * One-off revenue: Revenue collected from one-time payments and manual invoices. ### Additional metrics These metrics provide insights into upcoming renewals, pending deals, tax collections, and billing issues. For each of these metrics, you can explore the detailed elements by clicking on the `eye` button. * **Contracts renewing soon** represent the contracts attached to subscriptions automatically renewing in the next 30 days. * **Quotes pending signature** indicate potential revenue that has yet to be confirmed. * **Taxes collected** represent the total amount of tax collected from invoices, providing visibility into tax obligations. * **Errored invoices** highlight invoices that failed due to payment errors, indicating potential revenue at risk that may require action. ## Billing insights Tracking unpaid balances helps businesses prioritize revenue collection, while renewal monitoring ensures revenue continuity. Together, these insights improve cash flow stability and financial management. ### Top 5 balances due This section highlights the five customers with the highest outstanding debt, allowing you to quickly identify and follow up on overdue payments. For each customer, it displays the total unpaid balance and the number of invoices involved. ### Contracts renewing soon This section highlights upcoming subscription renewals, helping businesses anticipate revenue retention and manage customer relationships proactively. For each contract, it displays the customer name, the contract value, whether it renews automatically, and the renewal date. # Insights Source: https://docs.hyperline.co/docs/analytics/insights Track MRR, ARR, churn, and revenue metrics in Hyperline Insights with interactive charts, drill-down tables, and custom filters for finance teams. The Insights module provides a comprehensive overview of your financial and revenue metrics through interactive charts, detailed tables, and customizable filters. ### Interactive features The Insights module includes several interactive capabilities: * **Clickable charts and tables**: Double-click on any chart bar or table cell to view the underlying data (invoices, transactions, subscriptions) * **Drag to filter date ranges**: Click and drag across chart bars to filter data to a specific time period * **Table cell selection**: Select multiple cells in financial tables to view aggregated statistics (sum, average, min, max) * **Copy data**: Select cells and copy formatted data to your clipboard for use in spreadsheets or reports This feature is in beta and may incur additional charges. Please contact our support team if you're interested. ## Financial page The Financial page gives you a clear view of your financial health. It displays your cash flow, MRR and debt evolution, aged balances, and revenue breakdown. You can filter the data by invoicing entity, currency, and date range. Use the date range picker to select preset periods (**This month**, **Last month**, **This year**, **Last year**, **Last 3 months**, **Last 6 months**, **Last 12 months**, or **All time**), or choose a custom date range. ### Aged balances The **Aged balances** section shows how long invoices have been outstanding, organized by age buckets (1-30 days, 31-60 days, 61-90 days, and 90+ days). The heatmap visualization provides a day-by-day view of outstanding balances, making it easy to identify payment patterns and potential collection issues. Click on any day in the heatmap or any age bucket in the breakdown to view the specific invoices that make up that balance. ### Accounts receivable The **Accounts receivable** section provides a complete breakdown of your outstanding balances. Accounts receivable figures are based on when invoices are sent and their current status, while cash figures reflect when payments are actually received. ### Aged balances The **Aged balances** section includes a heatmap visualization that shows overdue invoices by the number of days past due. Each cell in the heatmap represents a specific day and displays the total outstanding amount for invoices overdue by that many days. Click on any cell to drill down into the invoice-level details for that specific day range. The heatmap supports filtering by: * **As of date**: Calculate balances as of a historical date to see how your aged balances looked at any point in time * **Invoicing entity**: Filter by specific invoicing entities * **Currency**: View amounts in original currency or reporting currency * **Invoice status**: Filter by invoice status (to pay, paid, etc.) Aged balances show what's outstanding at a specific moment in time, so the only time input that affects the heatmap and its drilldown is **As of date**. The `1-30 days` bucket excludes invoices that are still within their payment terms: a recent unpaid invoice whose due date has not yet passed is not counted in that bucket. ### MRR financials The **MRR financials** section offers a detailed breakdown of your Monthly Recurring Revenue. Billed MRR is derived from invoice line items based on the service period start date and billing interval, normalized to monthly amounts. Expansion and contraction reflect contract changes, while new and lost represent contracts that started or ended. Variable revenue includes usage-based charges or credits, as well as committed revenue. #### How MRR is computed * **Proration and partial cycles**: charges that cover only part of a billing cycle (mid-cycle upgrades, cancellations, partial first months) contribute a prorated share of MRR based on how much of the cycle they cover. An 8-day charge on a monthly plan adds roughly 8/30 of a month's MRR, not a full month. * **Credits and refunds**: credit notes and negative lines within an invoice (for example, a prorata refund issued alongside an upgrade) are subtracted from MRR. #### FX rate methodology For customers billed in a currency different from your reporting currency, MRR is normalized using the customer's **most recent invoice's conversion rate**, applied uniformly across their entire MRR history. This approach is aligned with market practices for SaaS analytics. **Why a single rate per customer?** Each invoice captures the FX rate that applied when it was issued. For accounting, that is the correct rate to use — it reflects what was booked at the time. For recurring revenue analysis, using a different rate each month introduces noise: the same £10,000/month customer can appear to expand or contract as GBP/EUR moves, even though nothing about their subscription changed. Anchoring each customer's MRR history to a single conversion rate removes that noise. **Things to keep in mind:** * Historical MRR values are recomputed each time the dashboard is loaded. As conversion rates move, the same past month can show slightly different values between views. Each view is internally consistent, just anchored to a different current rate. * For foreign-currency customers, MRR figures in Insights will not match the amounts in your accounting export line-for-line. This is intentional: the accounting export reflects historical bookings in your accounting currency, while Insights normalizes FX to give a stable business-trend signal. ## Revenue page The Revenue page provides in-depth insights into your revenue streams, including revenue by geography, recurring revenue evolution, and the breakdown between committed and variable components. You can filter the data by invoicing entity, currency, date range, customers, and products. Use the date range picker to select preset periods (**This month**, **Last month**, **This year**, **Last year**, **Last 3 months**, **Last 6 months**, **Last 12 months**, or **All time**), or choose a custom date range. Use the **Clear filters** button to reset customer and product filters. ### Product & customer breakdown The **Revenue per product** section provides a detailed breakdown of your revenue by product and customer. Use this section to track the performance of each product and monitor revenue evolution over time per customer. The revenue table supports infinite scrolling for large datasets and includes: * **Interactive selection**: Select multiple cells to view aggregated statistics * **Sparkline charts**: Each row displays a mini chart showing revenue trends over time * **Invoice drilldown**: Double-click any cell to view the invoices that contributed to that revenue # Reports Source: https://docs.hyperline.co/docs/analytics/reports Browse Hyperline's pre-built finance reports — accounts receivable, MRR movements, cohorts, exports — and download them for deeper analysis. Hyperline provides a comprehensive suite of pre-built reports that give you a clear view of your company's performance. Explore a wide range of analytics designed to empower finance teams in making informed decisions, or export the data for deeper analysis in your preferred external tools. Reports are accessible from the dedicated **Reports** page within the Hyperline platform. ## Available reports Hyperline offers a curated selection of reports essential for assessing various aspects of your company's financial health. Many reports can be viewed directly in the platform with interactive filtering, and all reports are downloadable as CSV files, giving you convenient access to the data you need at any time. These reports can also be exported using the [exports API](../../api-reference/endpoints/exports/create-export). ## Preview reports Many reports can be viewed directly in Hyperline with interactive filtering and pagination. Click the **View** button next to a report to explore the data in a table format with infinite scroll for large datasets. ### Available viewable reports The following reports support in-app viewing: * **Aged Balances**: View outstanding invoices grouped by age * **Revenue per Product**: Analyze revenue breakdown by product * **Revenue per Country**: View revenue distribution by country * **Outstanding Invoices**: See all unpaid invoices * **All Customers**: Browse your complete customer list * **All Subscriptions**: View all active and past subscriptions * **Detailed Revenue**: Explore granular revenue data * **Revenue per Line Item**: Analyze revenue by line item * **Revenue per Plan**: View revenue breakdown by subscription plan * **Line by Line Revenue**: Detailed line-level revenue analysis * **Draft Invoices**: Review invoices in draft status * **Open Invoices**: View all open invoices * **Live Subscriptions**: See currently active subscriptions * **Credit balances**: Monthly roll-forward of prepaid credit balances per customer and credit type ### Filtering reports When viewing a report, you can apply filters to narrow down the data: * **Date range**: Select a specific time period to analyze (with quick presets for this month, last month, last 3/6/12 months, this year, last year, or all time) * **Invoicing entity**: Filter by specific invoicing entities (for aged balances) * **Currency**: Filter by specific currencies * **Age bucket**: Filter aged balances by age ranges (1-30, 31-60, 61-90, 90+ days) * **Customers**: Filter by specific customers (for revenue reports) * **Products**: Filter by specific products (for revenue reports) Applied filters are automatically included when you download the report as a CSV file. ## Downloading reports To download a report as a CSV file: 1. Navigate to the **Reports** page or open a report in view mode 2. Click the **Download** or **Download CSV** button 3. Review the export confirmation modal showing: * Report name * Date range (period) * Total row count 4. Click **Download** to generate the CSV file When downloading from the report view page, any active filters (customers, products, currencies, age buckets, invoicing entities, etc.) are automatically applied to the export. Reports with more than 10,000 rows cannot be exported as CSV. Please narrow your date range or apply filters to reduce the number of rows. ## Exports history The **Exports** tab on the **Reports** page lists every export previously generated from your account, most recent first. Use it to find and re-download a file without re-running the export. Each row shows: * **Name**: the report or dataset the export was generated from * **Format**: the file format (`CSV`, `XLSX`, or `JSON`) * **Status**: the current state of the export * **Created**: the date and time the export was requested * **Download**: available once the export is ready An export moves through the following statuses: | Status | Meaning | | ------------ | ----------------------------------------------------- | | `Pending` | The export has been requested and is queued | | `Processing` | The file is being generated | | `Done` | The file is ready to download | | `Failed` | The export could not be generated — request a new one | The list refreshes automatically while an export is `Pending` or `Processing`, so the **Download** button appears as soon as the file is ready. Click **Download** to retrieve the file. Large exports are processed in the background. You can leave the page and come back to the **Exports** tab later to download the file once its status is `Done`. # Coupons Source: https://docs.hyperline.co/docs/coupons/overview Create reusable coupons in Hyperline that apply fixed-amount or percentage discounts to subscriptions, invoices, and checkout flows. Coupons define the discount that can be applied to a customer. In Hyperline, a coupon can reduce a charge by a fixed amount or by a percentage, and can be reused across subscriptions when the same commercial offer applies to several customers. A coupon is the discount rule. A [promotion code](./promotion-codes) is a customer-facing code that lets customers redeem that coupon on a checkout page. ## When to use coupons Use coupons when you need to apply a recurring or one-time discount to a subscription, quote, or invoice. Common examples include onboarding discounts, partner discounts, contract-specific concessions, and limited-time commercial offers. Coupons are managed from the catalog so they can be created once, tracked centrally, and applied consistently by your team. To offer free or discounted prepaid credits instead of a subscription discount, use [credits](../credits/overview) or [wallet top-ups](../wallets/balance). ## Coupon configuration Each coupon contains three types of settings: | Setting | Description | | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ | | **Information** | Name and internal description. The name can appear on customer-facing documents, while the description is for internal context. | | **Discount** | Fixed amount or percentage discount. Fixed amount coupons use one currency. Percentage coupons apply a percentage discount to eligible products. | | **Settings** | Optional redemption deadline, redemption limit, and eligible products. These settings control where and how often the coupon can be used. | The discount type and value cannot be edited after the coupon is created. Create a new coupon when the commercial discount changes. ## Create a coupon 1. Go to **Catalog** > **Coupons**. 2. Click **New coupon**. 3. Enter the coupon **Name** and, if needed, an **Internal description**. 4. Choose the discount type: * **Fixed amount**: select the currency and discount amount. * **Percentage**: enter the percentage discount. 5. Configure optional settings: * **Redemption deadline**: date after which the coupon can no longer be redeemed. * **Redemption limit**: maximum number of times the coupon can be redeemed. * **Eligible products**: products the coupon can apply to. Leave empty to allow all products. 6. Click **Create new coupon**. The coupon appears in the **Coupons** list after creation. ## Apply coupons Coupons can be applied when creating or updating subscriptions, preparing quotes, and editing invoices before they are finalized. When applying a coupon, Hyperline asks how long the discount should apply and which eligible products should receive it. Choose **All products** to apply it to every product on the subscription, quote, or invoice, or **Specific products** to select individual products. Product eligibility comes from the coupon settings, so you can only select products eligible for that coupon. ### Coupon duration When applying a coupon to a subscription, choose how long it should apply: | Duration | Behavior | | ------------------------- | ------------------------------------------------------------------------------------------------------------------ | | **Once** | Applies to a single invoice. Once that invoice is finalized, the coupon expires for the subscription. | | **Relative duration** | Applies for a specific period, such as 3 months or 6 months, from the subscription phase start or transition date. | | **Phase duration** | Applies for the full duration of the current subscription phase. | | **Subscription duration** | Applies for the lifetime of the subscription. | ## Promotion codes Promotion codes are created from a coupon. They let customers enter a code on a checkout page and redeem the coupon themselves. Use promotion codes when you want a self-serve checkout experience, public campaign code, partner code, or customer-specific code. Use coupons directly when your team should apply the discount internally during subscription, quote, or invoice setup. A single coupon can have multiple promotion codes. For example, a **20% annual discount** coupon can power `SPRING20`, `PARTNER20`, and customer-specific codes with different limits. Learn how to configure customer-facing codes in [Promotion codes](./promotion-codes). ## Manage coupons Open a coupon to review its configuration, see its promotion codes, or delete it. Deleting a coupon archives it and prevents future use. It does not remove the coupon from active subscriptions where it has already been applied. ## Next steps * Create customer-facing codes with [Promotion codes](./promotion-codes). * Apply coupons while [assigning a subscription](../subscriptions/create). * Manage coupons during a [subscription update](../subscriptions/update). # Promotion codes Source: https://docs.hyperline.co/docs/coupons/promotion-codes Let customers redeem coupon discounts using promotion codes during Hyperline checkout, with code-level redemption rules and product targeting. Promotion codes are customer-facing codes attached to a coupon. They let customers enter a code during checkout and receive the discount defined by the underlying coupon. A coupon controls the discount itself: fixed amount or percentage, eligible products, and global redemption rules. A promotion code controls how customers can redeem that coupon from checkout: the code value, customer or product eligibility, expiration date, redemption limit, and duration. ## When to use promotion codes Use promotion codes when customers should redeem a discount without your team applying it manually. Common examples include public acquisition campaigns, partner discounts, customer-specific offers, and first-order incentives. Use the coupon directly when the discount should be applied by your team while creating a subscription, preparing a quote, or editing an invoice. Create a **20% annual discount** coupon, then add one promotion code for a public campaign (`SPRING20`) and another for a partner (`PARTNER20`). Both codes apply the same discount, but each code can have its own expiration date, redemption limit, and eligibility rules. ## Create a promotion code Promotion codes are managed from the coupon they redeem. 1. Go to **Catalog** > **Coupons**. 2. Open the coupon you want customers to redeem. 3. In **Promotion codes**, click **Add promotion code**. 4. Enter the **Code** customers will type at checkout. 5. Configure the eligibility and limits. 6. Click **Save changes**. ## Promotion code settings | Setting | Description | | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Code** | The value customers enter at checkout, such as `SPRING20` or `PARTNER20`. | | **Customer** | Optional restriction to one customer. Leave empty to make the code available to all customers. | | **Product** | Optional restriction to subscriptions containing a specific product. Leave empty to use the coupon's product eligibility only. | | **Expiration date** | Optional date after which the code can no longer be redeemed. | | **Maximum redemptions** | Optional limit for this promotion code. This is tracked separately from the coupon redemption limit. | | **Duration** | How long the redeemed discount applies after checkout. Leave empty to use the coupon's default duration, or choose a specific duration such as once, days, weeks, months, or years. | | **First order only** | Restricts the code to customers placing their first order. | Promotion code limits do not replace coupon limits. A checkout redemption must satisfy both the promotion code settings and the underlying coupon settings. ## Redeem a promotion code at checkout When at least one promotion code exists on your account, the checkout page displays an **Add promo code** option. Customers can enter a code, apply it, and see the discount reflected in the checkout summary before completing payment. If the code is expired, over its redemption limit, restricted to another customer or product, or otherwise not eligible for the checkout, Hyperline shows an invalid code message and does not apply the discount. ## Manage promotion codes Open the coupon to review all related promotion codes. The list shows each code, redemption count, expiration, duration, and whether it is restricted to first orders. You can edit a promotion code while it is active, or delete it when it should no longer be available at checkout. Deleting a promotion code prevents future redemptions but does not remove discounts already applied to subscriptions. ## Coupons and promotion codes Coupons and promotion codes work together: | Concept | Purpose | Managed by | | ------------------ | ----------------------------------------------------------------- | ---------------------------------------------------------------------- | | **Coupon** | Defines the discount amount, discount type, and base eligibility. | Internal teams applying discounts manually or creating codes. | | **Promotion code** | Defines how a customer can redeem a coupon during checkout. | Teams running campaigns, partner offers, or self-serve checkout flows. | Use one coupon with several promotion codes when the commercial discount is the same but each audience needs different redemption rules. Create separate coupons when the discount value, currency, or product eligibility is different. ## Next steps * Review the underlying [Coupons](./overview) setup. * Learn how checkout pages work in [Checkout page](../subscriptions/checkout-page). # Credits overview Source: https://docs.hyperline.co/docs/credits/overview Set up customer credit balances in Hyperline: configure credit products, expiration, auto top-up, and apply them across plans and subscriptions. This page covers the full credit product lifecycle: catalog setup, customer balances, plan and subscription integration, expiration, and auto-topup. For an introduction to credits as a product type and where they sit in the catalog, see [Products and prices](/docs/products/overview#credit). **Prerequisite** To configure credits, you will need to have connected events first so usage data can be detected. ## Create a credit product To get started with credits, you should create a credit product first in your catalog, where you will specify the events that rule the consumption. Usage of credits will be deducted automatically accordingly. Add one or more [aggregators](/docs/usage/aggregators) to define which events consume credits on the customer's balance. Each aggregator has a **weight** that determines how many credits are consumed per unit of usage. You can add aggregators directly from this form — if you need a new one, click **Create aggregator** to set it up without leaving the page. You can also configure display settings (public description) and set a low balance threshold to trigger warnings on the customer portal. The unit name shown to customers is inherited from the linked aggregator. **Credit grant mode** controls how many credits are granted on a **partial period** (e.g. mid-cycle start, upgrade, or automated top-up at the end of a period): | Mode | Behavior | | ------------------ | -------------------------------------------------------------- | | **Prorated** | Scale credits to the period, like billing (may be fractional). | | **Full allowance** | Always grant the full credits, even on a partial period. | This setting only affects the **credits granted**, not the invoiced amount. The invoice is always prorated for partial periods — so with **Full allowance**, the customer pays a fractional price but receives the full credit allowance. Choose how the granted credit quantity determines the price: * **Volume pricing** applies progressive prices across quantity tiers. * **Bulk pricing** uses the tier reached by the total quantity to price all credits. * **Bundle pricing** offers predefined quantities at fixed prices. You can also choose which bundles customers can purchase from the customer portal. When you assign the credit product to a plan or subscription, enter the quantity of credits to grant and select a catalog price. Hyperline calculates the resulting amount and stores it as a fixed fee on the subscription while retaining the selected pricing configuration as context. ## Multiple aggregators with weights A credit product can be linked to multiple aggregators, each with its own weight. All aggregators consume from a **single shared balance**, but at different rates. The weight defines how many credits are deducted per unit of usage for that aggregator. For example, a weight of `3` means each unit of usage consumes 3 credits. An AI platform sells credits that can be used across different models: | Aggregator | Operation | Weight | | ------------------ | --------- | ------ | | `gpt4_requests` | count | 5 | | `gpt3_requests` | count | 1 | | `image_generation` | count | 10 | A customer with 1,000 credits could use them for 200 GPT-4 requests, 1,000 GPT-3 requests, 100 image generations, or any combination. If you only need a single aggregator, simply add one row with a weight of `1`. This works exactly like a standard credit product. ## Set up credits on a customer Once your credit product is set up, you can enable a credit balance on your customer and link their credit usage immediately. Note that this can also be done via the API. Here, you can also change the name, choose the starting balance, and set the credit warning limit. This won't override the values previously set in your product catalog, but will be specific to the customer. Once the balance is created, a **credits chart** shows balance evolution over time. You can adjust the date range and granularity (daily, weekly, monthly) to analyze consumption patterns. Below the chart, the **transactions table** lists all credit movements (top-ups, usage, expirations). For products with multiple aggregators, an **Aggregator** column indicates which aggregator triggered each usage transaction. You can click a usage transaction to inspect and export the underlying consumption events. You can also manually top up or remove credits via the **Actions** menu. ## Add credit products in plan and subscription Credit products created in the product catalog can be added to predefined billing plans and subscriptions like any other product. Options for this product can also be changed at the customer/subscription level, allowing full customization without altering your catalog configuration. ## Consumption order A customer's credit balance is a single shared pool. When usage is reported (via events or via `POST /v1/customers/{id}/credits/{productId}/usage`), it is deducted from that pool. For accounting and expiration purposes, the deducted amount is attributed to individual top-ups in **FIFO order by top-up creation date** — the oldest top-up is drained first, the most recent one last. This applies regardless of whether a top-up has an expiration date or is permanent. Consumption order is based on **when each top-up was created**, not on its expiration date. A permanent top-up created before a time-limited top-up will be drained first. If you want a "free" allowance (e.g. a plan-included monthly allowance) to be consumed before paid top-ups, make sure the allowance top-up is credited to the balance **before** any paid top-up on the same credit product. For recurring allowances tied to a subscription, the allowance is credited at the start of each billing period, so as long as paid top-ups happen after that point, the allowance will be consumed first. ## Real-time consumption and limits Credit balances are updated asynchronously when usage is reported through events. In production, balances can take about 60 seconds to reflect new consumption, because Hyperline intentionally buffers and processes usage in the background. Use the credit usage API endpoint (`POST /v1/customers/{id}/credits/{productId}/usage`) when you need to debit credits immediately from your own system. This synchronous debit flow is the right choice when you must enforce real-time limits, stop overconsumption, or block an action before confirming that the customer still has credits. Test and production environments can feel different for credit timing. Always validate real-time enforcement against the same environment your application will use. ## Credit expiration Credits can be configured to expire automatically, ensuring that unused credits don't remain on customer balances indefinitely. There are two ways to set up credit expiration: ### Expiration after a fixed number of days Set a specific number of days after which credits will expire. This is useful for promotional credits or time-limited offers. When configuring a credit product on a subscription, you can specify how many days after the topup the credits will expire. ### Expiration at the end of the billing period Credits can be configured to expire at the end of each billing period. This is useful for monthly or annual credit allowances that should not roll over. When configuring a credit product on a subscription, you can enable this option. Credits will automatically expire when the billing period ends, and new credits will be added at the start of the next period. When credits expire, an expiration transaction is automatically created in the credit ledger, and the customer's balance is reduced accordingly. The oldest credits expire first. ## Auto-topup Auto-topup allows you to automatically replenish a customer's credit balance when it falls below a specified threshold. This ensures uninterrupted service for your customers and reduces manual intervention. ### How auto-topup works When a customer's credit balance drops below the configured low balance threshold, Hyperline can automatically: 1. Create an invoice for the topup amount 2. Charge the customer's payment method 3. Add the credits to their balance ### Configuration options Auto-topup can be configured in two ways: **Custom amount**: Specify a fixed amount to charge and the number of credits to add when the threshold is reached. **Bundle pricing**: Use an existing bundle price from your product catalog. The system will automatically calculate the correct amount based on the bundle pricing. If you want to add 200 credits and your bundle is 50 credits for €400, the system will charge €1,600 for 4 bundles. ### Setting up auto-topup When creating or updating a credit balance for a customer, you can configure: * The balance threshold that triggers auto-topup * The number of credits to add when triggered * Either a custom amount to charge, or select a bundle price from your catalog Auto-topup requires the customer to have a valid payment method on file. If the payment fails, the topup will not be processed and the balance will remain unchanged. ## Credit balances report The **Credit balances** report gives you a month-by-month roll-forward of every prepaid credit balance, so finance teams can audit how credits were granted, consumed, and expired over time. You can view it on the [Reports](/docs/analytics/reports) page or export it through the [exports API](/api-reference/endpoints/exports/create-export) with `name` set to `credit_balances`. Each row covers one customer's balance for a single credit type and month. A customer can hold several balances in different units, and amounts are never combined across units. The report is dense: quiet months still appear, carrying the previous closing balance forward. A balance appears once it has had activity on or before the end of the selected period. Values are expressed in raw credit units (always positive), not in currency. | Column | Description | | ------------------- | -------------------------------------------------- | | `Month` | Month covered by the row, in `YYYY-MM` format | | `Customer ID` | Identifier of the customer | | `Customer name` | Name of the customer | | `Credit balance ID` | Identifier of the credit balance | | `Credit type` | Credit product the balance belongs to | | `Unit` | Unit the credits are counted in | | `Opening` | Balance carried over from the previous month | | `Granted` | Credits added manually or as a complimentary grant | | `Purchased` | Credits bought as a one-off paid top-up | | `Subscription` | Credits granted by a subscription | | `Consumed` | Credits used through reported usage | | `Expired` | Credits removed when they reached their expiration | | `Adjustments` | Reconciling entry that makes the row balance | | `Closing` | Balance at the end of the month | Every row balances out: `Opening + Granted + Purchased + Subscription − Consumed − Expired + Adjustments = Closing` Months are bucketed in the customer's timezone, while the date-range filter bounds are interpreted in UTC. # Custom usage tracking Source: https://docs.hyperline.co/docs/customer-intelligence/custom-usage-tracking Assign usage aggregators directly to customers for monitoring and threshold alerts without creating a subscription or billing them. Custom usage tracking lets you assign usage aggregators directly to one customer, a set of customers or segments, or all customers. The metrics appear on customer pages without requiring a product or subscription and without affecting billing. Use it for metrics your team wants to watch at the account level, such as monthly active users, API calls, storage growth, seats provisioned, data processed, feature adoption, or plan-limit consumption. Directly assigning an aggregator to customers without a subscription is available with the [Customer Intelligence module](./overview). Standard usage-based billing does not include this direct assignment workflow. ## Direct assignment compared with subscription usage | | Aggregator used in a subscription | Aggregator assigned directly to customers | | ------------ | ------------------------------------------------------------------------ | ------------------------------------------------------------------------ | | Setup | Link the aggregator to a product, then add the product to a subscription | Select customers or segments in the aggregator's **Visibility** settings | | Main purpose | Calculate billable usage or credit consumption | Monitor adoption, engagement, limits, or other customer signals | | Billing | Can affect invoices or credit balances | Never creates charges or invoice lines | | Period | Subscription metering period | Aggregator's default aggregation interval | | Module | Relevant billing feature | Customer Intelligence | ## How it works 1. You send usage events to Hyperline or load them through a connector. 2. An [aggregator](../usage/aggregators) turns those events into a metric. 3. The aggregator's **Visibility** setting assigns the metric to all customers or to selected customers and segments. 4. Assigned metrics appear on those customer records, on the customer overview and in the **Usage** tab. 5. Thresholds can alert your team when a customer's value crosses a configured limit. Custom usage tracking uses the same aggregator system as usage-based billing. If you need to create the underlying usage events first, start with [Send usage data](../usage/send-usage-data) or [Usage data with connectors](../usage/usage-data-with-connectors). ## Assign an aggregator to customers 1. Go to **Usage > Aggregators**. 2. Create a new aggregator or open an existing one. 3. Configure the metric: * **Name** * **Event type** * **Operation**: **Count**, **Sum**, or **SQL formula** * **Unit name** * Optional filters 4. In **Visibility**, choose where the metric should appear: * **All customers** * **Specific segments and customers** * **No customers** 5. Set the default aggregation interval used to calculate the metric when no subscription provides a metering period. 6. Choose the **Displayed value**: * **Total**: shows the total over the selected period. * **Last complete period**: shows the value from the last fully completed aggregation interval. 7. Add thresholds if you want to trigger alerts. 8. Click **Save changes**. ## Customer assignment options | **Visibility** option | Assignment behavior | | ----------------------------------- | ----------------------------------------------------------------------------------- | | **All customers** | The metric applies broadly, such as API calls for every account | | **Specific segments and customers** | The metric is only relevant for a cohort or handpicked accounts | | **No customers** | The aggregator is only used for billing, internal calculations, or another workflow | When using **Specific segments and customers**, add one or more customer or segment conditions. The metric appears on every customer record that matches at least one configured assignment. Choosing a visibility option only controls where the metric is monitored. It does not add the aggregator to a subscription or make the usage billable. ## Where usage appears Directly assigned aggregators appear in two places: * **Customer overview**: top usage metric cards summarize the most relevant customer-visible metrics. * **Usage tab**: the full list of visible usage cards includes charts, filters, thresholds, and event drill-downs. For the full customer usage workflow, see [Customer usage](../usage/customer-usage). In the **Usage** tab, you can change the period and grouping: | Grouping | Best for | | ----------- | --------------------------------- | | **Monthly** | Long-term customer trends | | **Daily** | Weekly or monthly activity review | | **Hourly** | Intraday monitoring | Click **Explore** on a usage card to inspect the underlying events for that customer and metric. ## Use cases | Use case | Metric examples | What to watch for | | -------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------- | | Upsell opportunity | Seats provisioned, API calls, storage used, projects created | Customers approaching limits or growing steadily | | Add-on adoption | Premium feature events, advanced workflow usage, extra modules used | Customers getting value from features that map to paid add-ons | | Onboarding progress | First import, first integration sync, active users, key setup events | Customers that have not reached expected milestones | | Engagement risk | Active users, weekly activity, successful syncs, feature usage | Declining activity or no usage after purchase | | Usage overage review | Events above included allowance, credits consumed, peak usage | Customers likely to exceed contracted usage | | Capacity planning | Data processed, records stored, transactions created | Customers whose usage may require a plan or infrastructure review | ## Thresholds Thresholds let you alert on customer-level usage changes. A threshold can trigger when a value is greater than or equal to a limit, or less than or equal to a limit. Hyperline evaluates the threshold separately for each assigned customer, using the aggregator's default aggregation interval when there is no subscription. Crossing a threshold sends the configured alert; it does not create a charge, change a subscription, or update an invoice. Thresholds are useful for: * Usage spikes that may indicate overages * Usage drops that may indicate churn risk * Low adoption after onboarding * Customers approaching contractual limits * Customers reaching usage levels that may justify an upsell or add-on discussion You track monthly active users with an aggregator assigned to all customers. You set the displayed value to **Last complete period** and add a threshold for fewer than `20` active users. When a customer's active user count drops below that limit, your team can review the account before renewal. You track storage usage in GB and set a threshold at `800`. When the threshold is crossed, the customer owner can review whether the account is ready for a higher tier or an additional storage package. ## Related * [Aggregators](../usage/aggregators) * [Customer usage](../usage/customer-usage) * [Explore usage events and consumption](../usage/explore-usage-consumption) * [Customer monitoring agent](./customer-monitoring-agent) # Customer monitoring agent Source: https://docs.hyperline.co/docs/customer-intelligence/customer-monitoring-agent Configure the Hyperline customer monitoring agent to analyze account health, surface risk signals, and notify the right teammates automatically. The customer monitoring agent analyzes selected customers and produces a health score with supporting context. It helps you spot accounts that need attention because of payment issues, usage changes, support signals, contract risk, weak communication, or expansion potential. The agent benefits from Hyperline's revenue management context, including contracts, subscriptions, invoices, payments, and usage. This gives the health score a revenue-aware foundation before it is enriched with connected tools such as Gmail, support platforms, meeting tools, and CRM systems, or built-in sources such as public company data. You can use one monitoring agent for your full customer base, or focus it on a specific [customer segment](../customers/segments) such as enterprise customers, customers near renewal, or customers with late payment behavior. ## Where to find it Go to **Customers > Monitoring** to create and manage monitoring agents. After an agent has analyzed a customer, the customer page can show: * A health score card on the customer overview * The last monitoring date * A link to the latest analysis * The monitoring agent assigned to that customer ## What the agent analyzes The agent combines billing and customer signals across several dimensions: | Dimension | What it considers | | ---------------------- | -------------------------------------------------------------------------------------------------------------- | | Payment health | Payment consistency, failed payments, disputes, and overdue invoices | | Usage and engagement | Product usage trends and declining activity | | Support signals | Recent ticket volume, sentiment, and frustration patterns | | Contract and valuation | Contract terms, renewal risk, and revenue at stake | | Communication | Meeting activity, email engagement, and relationship quality | | Public company data | Legal status, collective proceedings, establishment changes, and financial information for supported companies | For **Contract and valuation**, the agent can review the terms and attachments included with signed subscription quotes. It looks for conditions that could increase early churn risk, such as proof-of-concept, pilot, or trial periods; conditional exit or break clauses; termination for convenience; acceptance conditions; and exceptions to minimum commitments. When a signed quote or one of its attachments changes, the agent reviews the latest contract document again during its next analysis. Relevant conditions can appear in the health score reasoning and risk factors. Connected tools can add more context. For example, Gmail can add recent customer email threads, support tools can add ticket history, meeting tools can add summaries and transcripts, and CRM tools can add account records, deals, contacts, and notes. These dimensions are analysis angles, not a rigid checklist. Depending on the customer context, the agent can emphasize the most relevant angle, such as payment risk, billing issues, expansion readiness, renewal risk, weak communication, or unresolved support issues. ## How context is used in analysis During each run, Hyperline pulls the relevant context for each monitored customer from Hyperline and connected tools. The agent uses that context to explain the health score, not just to list recent activity. This helps the analysis connect signals that are often reviewed separately: * A late invoice can be interpreted with payment history, recent emails, open support threads, and renewal context. * A usage increase can be checked against CRM deal context and support sentiment to surface possible expansion readiness. * A usage drop can be compared with recent meetings, email silence, or unresolved support issues to identify churn risk. * A high-value customer can be prioritized differently when contract size, payment behavior, and relationship activity point in different directions. A customer has growing usage and an upcoming renewal, but recent Intercom conversations show unresolved implementation blockers. The agent can surface both the expansion signal and the risk, so the owner can prepare the right follow-up before starting a commercial conversation. ## Use cases | Use case | How the agent helps | | --------------------------- | -------------------------------------------------------------------------------------------- | | Upsell and expansion review | Surfaces customers with strong usage, positive signals, and meaningful contract value | | Churn risk review | Highlights declining usage, weak engagement, negative support signals, or payment issues | | Renewal preparation | Summarizes health, risks, positive signals, and recent activity before renewal conversations | | Collections follow-up | Adds payment health and late invoice context to account-level monitoring | | Onboarding monitoring | Helps identify customers that have not reached expected usage or engagement milestones | | Executive account review | Gives account owners a concise health summary with supporting reasoning | ## Choose a setup mode When you create a monitoring agent, choose how much control you want over the analysis. | Mode | Best for | How it works | | ------------- | ---------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- | | **Autopilot** | Quick setup or broad customer monitoring | Hyperline chooses the schedule and signal weighting based on billing data and connected tools | | **Advanced** | Specific monitoring playbooks, such as collections, renewals, or expansion reviews | Customer scope, schedule, fine tuning, context, connectors, and notifications | Use **Autopilot** when you want the agent to start monitoring with minimal setup. Use **Advanced** when you want to adapt the agent to a specific team workflow or customer segment. ## Create a monitoring agent 1. Go to **Customers > Monitoring**. 2. Click **Create agent**. 3. Open the agent and go to the **Configuration** tab. 4. Choose **Autopilot** or **Advanced**. 5. Choose which customers the agent monitors: * **All customers** * A specific customer segment 6. Click **Save changes**. When you change the monitored customer scope, Hyperline asks you to confirm the assignment changes. This helps prevent accidental changes when a segment includes a large number of customers. Use segments to keep an agent focused. For example, monitor "Enterprise customers renewing in the next 90 days" separately from lower-touch accounts. ## Fine tune the agent In **Advanced** mode, use the configuration tabs to customize how the agent works: | Setting | What it controls | | ------------------ | ------------------------------------------------------------------------------ | | **Customer scope** | Whether the agent monitors all customers or a selected customer segment | | **Schedule** | Whether the agent runs automatically or on a fixed schedule | | **Fine tuning** | How strongly each signal dimension contributes to the health score | | **Context** | Instructions the agent should use when interpreting customer signals | | **Connectors** | Connected tools the agent can use for CRM, support, meeting, or custom context | | **Notifications** | Who the agent can ping and which findings should trigger a notification | ### Configure schedule and scoring In **Advanced** mode, use **Schedule** to decide when the agent runs: * **Automatic**: Hyperline monitors customers when relevant events happen, such as new emails, late invoices, or usage changes. * **Fixed schedule**: the agent runs at a regular interval that you define. Use **Fine tuning** to adjust how strongly each dimension contributes to the health score. For example, you can give more importance to **Payment health** for collections-focused monitoring, to **Usage and engagement** for churn-risk monitoring, or to **Contract and valuation** for expansion and renewal reviews. ### Add context Use the **Context** tab to give the agent additional instructions: * **General context**: company or customer-base context the agent should know. * **Scoring instructions**: guidance for interpreting signals, such as industry-specific thresholds or risk rules. * **Include organisation hierarchy context**: include descendant customer context when the agent analyzes a parent customer. This is disabled by default. * **Hierarchy depth**: choose whether to include descendants one, two, or three levels below the parent. This setting is available when organisation hierarchy context is enabled. Keep context concise and operational. The best instructions explain how your team interprets customer risk, not generic business goals. ### Analyze a parent with descendant context When **Include organisation hierarchy context** is enabled, the parent analysis can consider billing, usage, communications, risks, and value from descendant customers alongside the parent's own context. The agent keeps signals attributed to the relevant descendant and its path in the hierarchy. This option changes the context used for customer analysis only. It does not move subscriptions or invoices, combine billing data, or change the invoicing configuration defined through [organisation-based billing](../customers/organisation-based). An analysis can include up to three hierarchy levels and 50 descendants. If some descendant context is unavailable or the analysis reaches its context limit, the agent continues with the available information and does not treat missing data as a negative signal. ## Enable connectors Use the **Connectors** tab to choose which data sources the agent can use. The tab can include CRM, support, meeting, built-in, and custom MCP data sources. Each available data source has a toggle. Third-party connectors appear disabled with **Connect to enable** until the underlying integration is connected. Built-in sources are available directly in Hyperline. Gmail email context is handled separately. When **Gmail** is connected for users in your workspace, the agent can use recent customer email threads for matching customer domains. Gmail can appear in **Data sources** on an analysis result even though it is not toggled from the agent **Connectors** tab. | Data source | Examples | What it adds | | ------------------- | ---------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | | Email | Gmail | Recent customer email threads, including subjects, participants, dates, and thread details when the agent needs communication context | | Support | Plain, Intercom, Zendesk | Support threads, statuses, priorities, labels, recent messages, and unresolved customer issues | | Call recording | Attio Call Recorder, Claap, Google Meet with Gemini, Grain | Meeting records, participants, summaries, and transcripts when available | | CRM | Attio, HubSpot, Salesforce | Company records, contacts, deals, CRM meetings, and CRM notes | | Public company data | Pappers | French company identity, legal status, collective proceedings, establishment changes, financial information, and recent registry events | | Custom sources | MCP connections | Additional customer context from internal tools or custom data sources connected to the agent | ### Use Pappers company data Pappers is a built-in source for French public company data. When you enable **Pappers** from the agent's **Connectors** tab, Hyperline uses the company data available through Pappers to enrich monitoring runs. Hyperline identifies the company from the customer's **Registration number**. It accepts a SIREN or SIRET and falls back to a French **Tax ID** when the registration number is missing or invalid. If these identifiers are missing from a customer linked to an organisation, Hyperline can use the organisation's details instead. When a company is found, Pappers can add: * Whether the company is active or has ceased trading * Active or past collective proceedings, such as safeguard, receivership, or liquidation * Recently opened or closed establishments * Recent financial information, including revenue, results, and headcount when available * Recent public registry events This context can help the agent detect risks such as a new collective proceeding or opportunities such as a recently opened establishment. If no valid French company identifier is available, the company is not found, or Pappers is temporarily unavailable, the monitoring run continues with the other available sources. Keep customer **Domain** and **Billing email** values up to date. They help Hyperline match Gmail messages, support threads, and meetings to the right customer. Before a renewal review, the agent can combine Hyperline billing data with Gmail threads, Intercom support conversations, Claap meeting summaries, and HubSpot deal context. The result helps the owner see payment risk, open support issues, recent engagement, and expansion signals in one customer health analysis. ## Configure notifications Use the **Notifications** tab to decide when and where the agent can ping your team. You can configure: * **Customer owner**: ping the user responsible for the monitored customer. * **Customer followers**: ping users following the customer. * **Specific people**: always ping selected users. * **Noise control**: only notify for findings at or above a selected severity. * **Slack threads**: post into a Slack channel when Slack is connected. For more about customer ownership and followers, see [Owner and followers](./owner-followers). Agent notification settings decide which recipients the agent may ping. Each recipient can also control their own channels and customer event subscriptions in **Profile > Notifications**. ## Run the agent manually You can trigger a manual run from the agent page, or from a customer health score card when a customer has not been monitored yet. When triggering a run, you can: 1. Select one or more customers. 2. Adjust scoring weights for that run. 3. Add one-time context for the analysis. 4. Start the run and open the run detail page. Manual runs are useful before a customer meeting, upsell review, renewal review, collections follow-up, or board reporting cycle. ## Read analysis results Each completed analysis can include: * Overall health score * Score tier * Short description * Reasoning * Dimension scores * Positive signals * Risk factors * Summary * Data sources and tools used | Score range | Tier | | ----------- | --------------- | | `0-25` | Critical | | `26-50` | At risk | | `51-75` | Needs attention | | `76-100` | Healthy | A health score is a prioritization signal. Use the reasoning, risk factors, and source data to decide what action to take. ## Related * [Customer intelligence overview](./overview) * [Owner and followers](./owner-followers) * [Custom usage tracking](./custom-usage-tracking) * [Late payment behavior](./late-payment-behavior) # Late payment behavior Source: https://docs.hyperline.co/docs/customer-intelligence/late-payment-behavior Use Hyperline's late payment behavior smart segment and payment metrics to identify at-risk customers and prioritize collections outreach. Late payment behavior helps you identify customers whose paid invoice history shows payment risk. It is available as a smart segment field in [customer segments](../customers/segments). Use it to prioritize collections, review payment terms, route manual follow-up, or focus a monitoring agent on customers with payment-risk patterns. ## How Hyperline evaluates late payments Hyperline computes payment behavior from settled invoices. For each paid invoice, Hyperline compares the settlement date with the expected payment date. The expected payment date is based on the invoice due date and the customer's payment terms. This avoids treating an invoice as late before the customer's configured payment delay has elapsed. The payment behavior metrics include: | Metric | Meaning | | ---------------------------- | --------------------------------------------------------------- | | Paid invoices | Number of paid invoices considered for the customer | | Invoices paid after due date | Number of paid invoices settled after the expected payment date | | Late payment rate | Share of paid invoices that were paid late | | Average late payment delay | Average delay across invoices that were paid late | Late payment behavior is based on invoices that have been settled. Unpaid overdue invoices are still visible through invoice status, reminders, and other collection workflows. ## Smart segment: Late payment behavior The **Late payment behavior** smart segment is computed and maintained by Hyperline. You do not need to set a threshold yourself. Hyperline evaluates three signals together: * Whether the customer has paid invoices late * How often paid invoices are late * How long late invoices are delayed on average This keeps the segment focused on customers with meaningful late payment patterns instead of every customer with a single small delay. ## Create a late payment behavior segment 1. Go to **Customers > Segments**. 2. Click **New Segment**. 3. Enter a segment name, such as `Late payment behavior`. 4. Add a rule. 5. In the field picker, open **Payment behavior**. 6. Select **Late payment behavior**. 7. Preview the matching customers. 8. Click **Save**. Because this is a smart segment, selecting the field is enough. You do not need to choose an operator or value. ## Build custom payment behavior rules If you want more control, use the numeric payment behavior fields instead of the smart segment. For example, you can combine: * **Late payment rate** is greater than or equal to `50` * **Average late payment delay** is greater than `10` * **Invoices paid after due date** is greater than or equal to `2` Use custom rules when you want to tune risk definitions for a specific collections process or customer cohort. You create a **High-risk payers** segment where **Late payment rate** is at least `50` and **Average late payment delay** is greater than `10` days. Your finance team follows the segment, and the monitoring agent watches it for new payment issues. ## What to do with the segment After saving the segment, you can: * Filter the customer list by the segment * Follow the segment to receive customer follower notifications * Use it as the customer scope for a monitoring agent * Review payment methods and invoice reminders for matching customers * Export matching customers for collections review ## Related * [Customer segments](../customers/segments) * [Customer monitoring agent](./customer-monitoring-agent) * [Owner and followers](./owner-followers) * [Invoice reminders](../invoices/reminders) # Customer intelligence Source: https://docs.hyperline.co/docs/customer-intelligence/overview Use Hyperline customer intelligence to monitor account health, usage trends, ownership, followers, and payment behavior signals in one place. Customer intelligence brings several customer-facing signals into one workflow. It helps you understand which customers need attention, who is responsible for them, how their usage is evolving, and where there may be risk or expansion potential. Customer Intelligence is a paid add-on. Contact the Hyperline team through the in-app chat to learn more or enable it for your account. Customer intelligence benefits from the same revenue management foundation that powers Hyperline contracts, subscriptions, invoicing, payments, and usage. This gives each analysis a revenue-aware starting point before external signals such as emails, support conversations, meetings, and CRM activity are added. Customer Intelligence can use context from the following sources: * **Hyperline**: Contracts, subscriptions, invoices, payments, and usage * **Public company data**: Pappers * **CRM**: Attio, HubSpot, and Salesforce * **Support**: Front, Intercom, Plain, Pylon, and Zendesk * **Email**: Gmail * **Call recording**: Attio Call Recorder, Claap, Google Meet with Gemini, and Grain We are continually adding new data sources. If a tool your team uses is not supported yet, contact us through the in-app chat and tell us what you would like to connect. Use it when your customer base is large enough that manual follow-up becomes hard to prioritize. Instead of checking customer records one by one, you can combine health monitoring, usage metrics, owner and follower assignments, and smart payment behavior segments. ## Buy vs build You can build customer intelligence internally, but the first obstacle is usually data access. Useful analysis needs the contract, subscription, invoice, payment, billing, usage, CRM, support, and communication context behind each customer. Recreating that context often means building data pipelines, matching customer records across tools, normalizing events, and maintaining the logic as your billing setup changes. Hyperline already manages the revenue foundation behind your customers. Customer intelligence can therefore start from the account's commercial reality, then add external signals from connected tools such as email, support, meetings, and CRM activity. This makes the analysis more practical: the agent can evaluate risk, expansion potential, renewal readiness, payment behavior, and usage adoption from the same place where your revenue operations already happen. | Common objection | What happens when you build | Why use Hyperline | | ---------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | "The data is already in a warehouse." | The warehouse can centralize data, but your team still needs customer matching, signal definitions, scoring, permissions, alerts, and account workflows. | Hyperline combines revenue context, monitoring, owners, followers, and notifications directly in the customer workflow. | | "A custom model would be more flexible." | Flexibility becomes maintenance when every new product, billing rule, segment, or renewal motion needs updates. | Monitoring agents can run on Autopilot or be fine-tuned with customer scopes, schedules, signal weights, connected data sources, and custom instructions. | | "CRM and support tools already show activity." | Activity signals are useful, but they often miss the commercial context: contract value, payment behavior, subscription state, invoice history, and usage trends. | Hyperline analyzes external activity alongside the billing and revenue data that explains the business impact of each signal. | | "Internal alerts are easy to add." | Alerts become noisy when they are detached from ownership, followers, customer segments, and the workflow for acting on them. | Hyperline routes customer intelligence to owners and followers so signals reach the people responsible for follow-up. | | "Building gives full control." | Full control also means owning integration drift, edge cases, permissions, auditability, and ongoing improvements. | Hyperline gives you a maintained system close to the source of revenue data, while still letting you customize how the agent monitors customers. | Build internally only when customer intelligence is a dedicated product your team wants to own end to end. For account prioritization, renewal preparation, expansion review, churn prevention, collections follow-up, and customer health monitoring, start with Hyperline. ## Multi-angle monitoring The customer monitoring agent reviews each customer from multiple angles, then emphasizes the signals that matter most for that customer context. It can look across payment, billing, usage, contract and renewal, communication, and support signals in the same analysis. This makes the health score more useful than a single rule or static checklist. For one customer, the main signal may be growing usage and expansion readiness. For another, it may be a late invoice combined with weak communication. For another, it may be an upcoming renewal with unresolved support issues. ## Setup and customization Create monitoring agents from **Customers > Monitoring**. You can start with **Autopilot** when you want Hyperline to choose the schedule and signal weighting, or use **Advanced** mode when your team has a more specific monitoring playbook. In **Advanced** mode, you can choose the monitored customer scope, schedule, fine-tune signal weights, add scoring instructions, enable connected data sources, and configure who should be notified. ## Capabilities Monitor customer health from multiple angles with Autopilot or fine-tuned agent settings. Display custom usage metrics on customer pages and alert on threshold crossings. Assign a responsible owner and let teammates follow customers or customer segments. Identify customers with late payment patterns using smart customer segments. ## How the signals work together | Signal | Where it appears | How you can use it | | ----------------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------------------- | | Monitoring health score | Customer overview and monitoring analysis pages | Prioritize churn risk, payment anomalies, expansion signals, and accounts that need review | | Custom usage metrics | Customer overview and **Usage** tab | Track engagement, adoption, capacity growth, or product consumption outside standard billing views | | Owner | Customer overview | Route accountability and monitoring agent pings to the responsible user | | Followers | Customer overview and segment follow actions | Keep interested teammates subscribed to customer updates | | Late payment behavior | Customer segments | Build payment-risk cohorts for collections, stricter terms, or manual outreach | ## Common workflows * **Monitor strategic accounts**: create a segment for key customers, assign owners, then configure a monitoring agent to watch that segment. * **Identify upsell opportunities**: expose usage metrics such as seats, API volume, storage, or feature adoption, then create segments for customers approaching plan limits or showing sustained growth. * **Prepare renewals**: review customer health, payment behavior, usage trends, and recent positive signals before renewal conversations. * **Improve onboarding**: track early usage milestones and follow customers that have not adopted key features after contract signature. * **Detect product expansion**: monitor customers using a feature heavily, consuming multiple add-ons, or growing usage across teams. * **Track engagement risk**: expose usage aggregators on customer pages, add thresholds, and use monitoring analysis to interpret declining usage. * **Improve collections follow-up**: create a segment using **Late payment behavior**, follow the segment, and notify owners or followers when the monitoring agent detects new payment issues. * **Coordinate account work**: use followers for teammates who should stay informed even when they are not the primary customer owner. ## Use case examples | Use case | Signals to combine | Typical action | | -------------------------- | --------------------------------------------------------------------------- | -------------------------------------------------------------- | | Upsell readiness | High or growing usage, healthy monitoring score, active communication | Ask the owner to review plan limits, add-ons, or a higher tier | | Churn prevention | Declining usage, low health score, support frustration, weak communication | Create a follow-up task or prepare an account review | | Renewal preparation | Contract timing, usage history, payment behavior, positive and risk signals | Review the account before commercial discussions | | Onboarding follow-up | Low usage after subscription start, missing milestone events | Notify the owner or customer success team | | Collections prioritization | Late payment behavior, overdue invoices, owner and followers | Route follow-up to finance and the account owner | | Customer segmentation | Usage, billing, payment behavior, custom properties | Build dynamic customer cohorts for reporting or team workflows | Some customer intelligence capabilities may depend on your account configuration and user permissions. If you do not see a page or setting described here, contact the Hyperline team via the in-app chat. ## Related * [Customers](../customers/overview) * [Customer segments](../customers/segments) * [Customer usage](../usage/customer-usage) * [Aggregators](../usage/aggregators) # Owner and followers Source: https://docs.hyperline.co/docs/customer-intelligence/owner-followers Assign a customer owner, follow customers or segments, and route Hyperline monitoring notifications using owner and follower signals. Customer owners and followers help you route accountability and notifications to the right people. * **Owner**: the user responsible for the customer. * **Followers**: users who want to stay informed about a customer, even if they are not the owner. The customer monitoring agent can use both fields when deciding who to ping about a customer. ## Where owners and followers appear Open a customer page and view the customer information panel. When customer intelligence is enabled, you can see: * **Owner**: an inline user selector. * **Followers**: follower avatars and a **Follow** or **Unfollow** action. * **Monitoring agent**: the agent currently monitoring the customer, if one is assigned. ## Set or change the customer owner 1. Open the customer page. 2. Find the **Owner** row in the customer information panel. 3. Select a user from the dropdown. 4. Hyperline saves the owner and shows a confirmation message. You can clear the owner if no user should be responsible for that customer yet. Use one owner per customer for accountability. Use followers for teammates who need updates but should not be treated as the primary owner. ## Follow or unfollow a customer 1. Open the customer page. 2. Find the **Followers** row. 3. Click **Follow** to follow the customer. 4. Click **Unfollow** to stop following the customer. The owner can also follow the customer. Ownership and following are separate signals. ## Follow a customer segment You can follow a segment to automatically follow every customer that belongs to it. 1. Go to **Customers > Segments**. 2. Open a segment. 3. Click **Follow segment**. When a customer matches a followed segment, Hyperline adds you as a follower through that segment. If the customer later stops matching the segment, the segment-based follow is removed automatically. If you follow a customer through a segment, you cannot unfollow that customer individually while the segment still applies. To stop those follows, unfollow the segment or update the segment rules. ## Use owners and followers for notifications In a monitoring agent's **Notifications** tab, you can choose whether the agent may ping: * The **Customer owner** * **Customer followers** * Specific selected users * A Slack channel Hyperline deduplicates recipients when the same user is both an owner and a follower. ## Configure your profile notifications Each user controls their personal notification preferences from **Profile > Notifications**. These settings apply when you are selected as a customer owner or follower for a customer notification. The profile notification page has three main areas: | Area | What you can configure | | -------------------------- | ------------------------------------------------------------------------ | | **Notification channels** | Which personal channels Hyperline can use to notify you | | **Customer notifications** | Which customer events should trigger notifications for you | | **Followed segments** | Which segments automatically add you as a follower on matching customers | ### Notification channels Use **Notification channels** to decide where you can receive agent pings: * **Hyperline chat**: creates an in-product conversation when an agent pings you. * **Slack DM**: sends agent pings to you directly in Slack when Slack is connected. * **Email**: sends agent pings by email when email delivery is available for your account. Slack DM and email options may appear unavailable until the related provider is connected. ### Customer notifications Use **Customer notifications** to choose which customer events should notify you when you are the owner or a follower of the customer. You can enable or disable: * **Invoice settled** * **Invoice becomes late** * **Payment fails** * **Payment method changes** * **Payment method deleted** * **Monitoring score changes** * **Contract renews soon** For **Monitoring score changes**, set the minimum score change required before Hyperline notifies you. For **Contract renews soon**, set how many days before renewal you want the notification to trigger. ### Followed segments Use **Followed segments** to manage segment-based follows from your profile. 1. Go to **Profile > Notifications**. 2. In **Followed segments**, select a segment. 3. Click **Add**. Customers matching that segment are followed automatically. You can also remove a segment from this list to stop following customers through that segment. Combine segment follows with customer notification settings to build personal work queues. For example, follow a **Late payment behavior** segment and enable **Invoice becomes late** to stay informed about customers that match your collections scope. Your finance lead follows a **Late payment behavior** segment, while account managers are assigned as owners on their customers. When the monitoring agent detects a payment issue, it can notify the owner for accountability and the finance lead for collections context. ## Related * [Customer monitoring agent](./customer-monitoring-agent) * [Customer segments](../customers/segments) * [Late payment behavior](./late-payment-behavior) # How the customer balance is calculated Source: https://docs.hyperline.co/docs/customers/balance Learn how Hyperline calculates a customer account balance from outstanding invoices, credit notes, and wallet credit, and how to read it. Every customer has an **account balance** that summarises their financial position with you at a glance. It appears on the customer overview page and answers a single question: does this customer owe you money, or are they in credit? ## Reading the balance card The balance is shown as a card at the top of the customer overview page. Its **colour** is an at-a-glance signal of whether the customer needs attention, and the **tag** underneath spells out why. Customer overview page with the balance card at the top left ### What the colours mean | Card colour | Tag | What it means | | ------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------- | | 🔴 **Red** | `{n} late` | At least one outstanding invoice is **overdue** (past its due date). Payment is late and likely needs chasing. | | 🟡 **Yellow** | `{n} outstanding invoices` | The customer has unpaid invoices, but **none are overdue yet**; they are still within their payment terms. | | ⚪ **Neutral** | `In credit` | No outstanding invoices, and the balance is positive: credit notes and wallet credit exceed what the customer owes. | | ⚪ **Neutral** | `All clear` | No outstanding invoices and a settled, zero balance. | The difference between **red and yellow** is purely about timing: as soon as a single open invoice passes its due date the card turns red, and it stays yellow while every open invoice is still within terms. A customer can move from yellow to red without any new invoices, simply because a due date has passed. The colour and tag are driven only by the customer's open invoices, independently of the headline amount. So the card can stay yellow or red even when the amount itself shows a dash (see [the currency shown on the card](#the-currency-shown-on-the-card)). Red balance card with a late invoices tag Yellow balance card with an outstanding invoices tag Neutral balance card with an in credit tag Neutral balance card with an all clear tag ## The formula The balance combines three components: ``` Balance = unpaid credit notes + wallet credit − outstanding invoices ``` The sign tells you the direction: * **Negative**: the customer **owes** you money (their outstanding invoices exceed their credit). * **Positive**: the customer is **in credit** (their credit notes and wallet exceed what they owe). * **Zero**: the account is fully settled. ## The three components ### Outstanding invoices The total still due on the customer's **finalized** invoices that are not yet fully paid, including partially paid and failed ones. This is the only component that pushes the balance towards "owing". Draft, voided, fully paid, and refunded invoices are not counted, and an invoice with a payment in progress is excluded until that payment settles or fails. ### Credit notes The total of [credit notes](../invoices/refunds) issued to the customer that have not yet been refunded or applied to an invoice. Once a credit note is applied to an invoice, it reduces that invoice's amount due, so it is never counted twice. ### Wallet credit The customer's available [prepaid wallet balance](../wallets/balance). A wallet balance only ever increases credit; it is never treated as negative. ## A worked example | Component | Amount | | -------------------- | ---------- | | Outstanding invoices | 10,000 | | Credit notes | 3,000 | | Wallet credit | 1,500 | | **Balance** | **−5,500** | `3,000 + 1,500 − 10,000 = −5,500` → the customer **owes 5,500**. If the same customer instead had no outstanding invoices, the balance would be `3,000 + 1,500 = +4,500`, meaning they are **4,500 in credit**. ## The currency shown on the card The balance card always shows the figure in the **customer's own currency** (the currency set on the customer record), with no conversion. A customer can still have invoices, credit notes, or wallets in other currencies; Hyperline tracks each currency separately. The card reflects only the customer-currency balance, so activity in other currencies is not folded into the headline figure. If a customer has no balance activity in their own currency (for example, all of their invoices are in a different currency), the amount shows as a dash (such as `- €`). The card colour and invoice-count tag still reflect their open invoices. ## Organisations and child customers For a parent customer in an [organisation](../customers/organisation-based), you can switch to the **aggregated view** to see the combined balance of the parent and all of its child customers, shown in the parent's currency. Invoices that have already been consolidated onto the parent are counted once, so a charge is never double-counted across the parent and its children. # Customer exports Source: https://docs.hyperline.co/docs/customers/exports Export Hyperline customer data to CSV — including subscriptions, estimated ARR, payment status, and contact details — for external analysis. If you wish to export your customer data for external analysis, Hyperline provides you with built-in file export within the Customers section. ## Export flow After clicking the export button, your customer data will be compiled into a CSV file. Download the file to access a complete export, including customer details, their number of active subscriptions, estimated ARR, and more. ## Large exports Customer exports are generated asynchronously. On large workspaces, the file can take longer to prepare before it is available to download. CSV exports are limited to 10,000 rows. If your workspace has more customers than the export can include, narrow the data before exporting, use the public API for paginated extraction, or contact support for help with a bulk export. For recurring reporting needs, consider [automated exports](../analytics/automated-exports) instead of manual CSV downloads. # Organisation-based billing Source: https://docs.hyperline.co/docs/customers/organisation-based Bill multiple Hyperline customers under a single parent account with organisation-based billing, while keeping each child's subscriptions distinct. Sometimes you need to bill a group of customers on a single entity without sacrificing the details of each independent account and subscription. The organisation-based billing feature is available directly from the customer page, where you can attach a customer to another. For usage-based subscriptions owned by the parent, you can also include direct child customers' usage in a metered product. See [Include child customers' usage](../subscriptions/metering#include-child-customers-usage). If you use Customer Intelligence, a monitoring agent can optionally include descendant customer context when analyzing a parent customer. This affects the health analysis only and does not change invoice routing or organisation-based billing settings. See [Analyze a parent with descendant context](../customer-intelligence/customer-monitoring-agent#analyze-a-parent-with-descendant-context). ## Activate organisation-based billing Here, you can see the parent/children relationship and the invoicing configuration for this customer. By clicking "Set parent organisation", you'll be able to choose a parent organisation for this customer. You'll be prompted to choose a parent organisation and then to select an invoicing configuration. 3 options are available at this stage. * `Individual invoices` will move every invoice for the current customer to the parent and invoice it under the parent configuration while keeping the content identical. * `Grouped` will set the current customer's invoices as pending and concatenate them regularly with other children from the parent. Concatenated invoices will display one line item per child invoice with the original line items listed in the description. * `No change` will attach the child to the parent but will not change any invoicing parameter. If you have chosen `Grouped` for the child invoicing configuration, you'll need to set the grouping schedule on the parent. To do this, go to the parent customer page, click the dots next to "Org. based billing" and select "Children settings". You'll be able to select a schedule (monthly, quarterly or yearly) and the next invoicing date. From there everything will be automated, but you can adjust the next invoicing date at any time. When going to the parent, you will see all the children and the related settings. A callout will appear on the invoicing section of the children to inform you that the invoices are being billed to the parent. ## Precisions on organisation-based billing **Payment methods** If a customer is billed through a parent, Hyperline will use the parent payment method configuration to process the payment. So for instance if the child customer is connected to Stripe and has a credit card on file, we won't use it. **Draft invoices** When creating parent invoices in organisation-based billing, Hyperline respects the draft invoice setting from child subscriptions: * For `Individual invoices` configuration: if the child subscription has draft invoices enabled, the parent invoice will be created as a draft. * For `Grouped` configuration: if any child subscription has draft invoices enabled, the merged parent invoice will be created as a draft. This applies to all invoices, including zero-amount invoices. **See child invoices** When an invoice from a child is reported to a parent, Hyperline keeps a document specific to the children to make tracking and audits easier. These documents have the status `Charged on parent` and are kept in the child "Invoices" tab. If a child invoice is pending a parent grouped invoicing, it will have the status `Pending parent concat`. **Track line item origins** For `Grouped` configuration, parent invoices include an `original_line_item_id` field on each line item, allowing you to trace which child invoice each line item originated from via the API. **Consumption exports** When child invoices are charged to the parent, exports can include the child usage and machine-level consumption data, but they do not expose a per-line euro amount for each child consumption line. Use the parent invoice lines for the billed amounts and the consumption export for the underlying usage detail. **Invoices that can't be grouped** For `Grouped` configuration, a child invoice can only be rolled up onto the parent if its invoicing entity matches the parent's. When it doesn't, Hyperline blocks the regroup for that invoice and surfaces a red callout on both the parent and the child customer overview. The callout links to a Sentinel task listing the affected invoices, so you can review them and align both the invoice's invoicing entity and the customer's invoicing entity with the parent's. Once aligned, the invoice becomes eligible for regrouping again. **Remove a child company from its parent** In the modal where you linked the child company to its parent, a red button has appeared. If you click this button, the child company will be removed from the parent and any future invoice will stay on the child. Invoices with the status `Pending parent concat` will move back to the child to get processed. # Customers Source: https://docs.hyperline.co/docs/customers/overview Manage the individuals and companies you bill in Hyperline: create customers manually or via API, track subscriptions, and update billing info. Customers are the individuals or companies that purchase your products or subscribe to your services. We recommend creating a customer in Hyperline as soon as they register for your product. Customer intelligence is available from customer records to monitor health, usage trends, ownership, followers, and payment behavior. See [Customer intelligence](../customer-intelligence/overview). ## Create a customer ### Manual creation Click **New Customer**. Enter the customer details, then click **Save customer**. If you do not have all the information at this time, you can still create the customer and update the details later. Only a name is required; currency and country can be inferred from your billing settings. The customer will appear immediately in your customer list (under the `All` filter). Click the customer's name to access their detailed information. On this page, you will see an overview of the customer's information on the left side of the screen. On the right, you can navigate through their [subscriptions](../subscriptions/manage), [wallet](../wallets/overview), [invoices](../invoices/overview), and events. ### Automatic creation Customers can be created programmatically [using the API](../../api-reference/endpoints/customers/create-customer). Additionally, when a CRM is connected and configured to automatically sync customers to Hyperline, customers will be created automatically. If CRM records are duplicated, linked to the wrong customer, or not updated as expected, see [Understand CRM sync matching](../../guides/crm-sync-matching). ### Default language, country, and currency When creating a customer, the language is determined through a cascade: if explicitly provided, that value is used; otherwise, if a country is provided, the language is inferred from that country; if neither is provided, the language defaults to the invoicing entity's language. The country follows a simpler fallback: the provided country is used if available; otherwise, it defaults to the invoicing entity's country. The currency also follows a fallback cascade: if explicitly provided, that currency is used; otherwise, if a customer country is provided, the currency is inferred from that country; if neither is provided, the currency defaults to the invoicing entity's currency. This ensures that every customer has valid language, country, and currency settings, even when not explicitly specified. ## Edit a customer Customer information can be updated at any time by clicking **Edit** in the actions dropdown. The **currency** cannot be changed in the following cases: * Once a customer has a wallet with funds or an active payment method (you must remove the payment method and delete the wallet first) * When using an external billing engine (the currency must be managed in the external tool) If you need to change the currency and cannot do so, please contact support. ### Force draft invoices The **Force draft invoices** setting on the customer forces every invoice generated for that customer to be created as a `draft`, so it can be reviewed and validated manually before being sent. Enable it from the customer's edit page by toggling **Force draft invoices** on. It applies to all invoices generated for the customer — subscriptions, one-off invoices, and parent invoices in [organisation-based billing](/docs/customers/organisation-based) or [consolidated invoicing](/docs/invoices/consolidated-invoicing). This customer-level setting overrides the subscription-level **Generate draft invoices** option. When it is enabled, invoices land in `draft` even if their subscription is not configured to draft invoices, and even after a [grace period](/docs/invoices/term) ends. ### Taxability Customer taxability controls whether Hyperline should apply taxes to that customer. * **Taxable** is the default behavior. Hyperline calculates taxes from your tax settings, the customer's billing country, tax ID, and the products being billed. * **Tax exempt** prevents tax from being charged to the customer. Use it only when the customer is exempt from tax for your billing context. If **Require customer tax ID** is enabled in the invoicing entity's tax settings, company customers must have a tax ID before their billing details can be completed. ### Tax ID validation Customer tax IDs show a validation status on the customer page. For EU VAT numbers, Hyperline validates the number through the EU VAT Information Exchange System (VIES) and stores the consultation number when available. The main statuses are `valid`, `invalid`, `mismatch`, `unverified`, and `unsupported`. See [Tax ID validation](../invoices/tax-management#tax-id-validation) for the full status reference and the related invoicing entity enforcement settings. ### French tax IDs and registration numbers For French customers, Hyperline can use the **Registration number** field, which may be a SIREN or SIRET, to prefill the customer's **Tax ID**. If the tax ID is empty and you enter a valid French registration number, Hyperline derives the French VAT number automatically. If you provide both values, Hyperline keeps the tax ID and registration number as entered, even if they do not match. This lets you save the customer details first and review the values later from the tax ID validation status. When a tax ID was previously inferred from a French registration number, updating the registration number refreshes the inferred tax ID. Tax IDs that were explicitly entered are preserved. ## Addresses A customer has a billing address that appears on quotes, invoices, and other documents. ### Shipping address By default, the billing address is used as the shipping address. To use a different shipping address, click the **Edit** button on the customer details page. When this option is enabled, customers can edit their shipping address directly from the customer portal. Shipping details can also be displayed on quotes and invoices. Shipping address is subject to activation on our side. Please contact support if you are interested. # Public customer portal Source: https://docs.hyperline.co/docs/customers/portal Give customers a hosted Hyperline portal to manage subscriptions, payment methods, invoices, and billing information across multiple languages. ## Overview Hyperline offers a customer portal where your customers can get access to their live subscription, payment methods, billing information and invoices. Our objective is to ensure a transparent and well-organized billing summary to offer to your own customers. As well as displaying information correctly, this portal offers a number of action options for your customers: #### Portal language The language will be displayed following these rules: * If the customer's browser language is part of our 8 supported languages (English, French, German, Italian, Spanish, Polish, Portuguese and Dutch), it will be displayed in the language. * If it is not part of the supported languages, we will default to the customer language selected on Hyperline customer information. By default, this language is inferred based on the customer's country. #### View subscription details Customers can access the full details of their subscription by clicking on 'Subscription details' on the portal. This sub-page will display the content of the next invoice that will be billed, as well as the detailed price structure of every product. #### Change payment method To do that, they just have to click the trash button next to their payment and add the new payment method they want to use. #### Top-up wallet You can make your customers autonomous by offering them to top-up their wallet in the portal. For this, make sure you enable the option on the wallet settings first. Clicking on Top-up wallet on this screen will trigger an immediate payment from the registered credit card and credit the wallets instantly. #### Edit billing information To make changes, they simply need to click the **Edit** button. This grants them the ability to update and modify their billing details as needed, ensuring accuracy and up-to-date information for a seamless payment process. This capability can be controlled in **Settings > Hosted pages**. See the [Billing details update](#billing-details-update) section below for more details. #### Download invoices All invoices are listed and can be opened to their dedicated [invoice page](../invoices/invoice-page). Customers can download their invoice PDF using the 'Download' button on the top-right corner. ## How to access the customer portal To view the portal for a specific customer: go to the customer page, select the customer you want to view then click the 'Portal' button. You can easily provide your customers with this unique portal link. Each customer portal link is individually generated and secured through a unique ID. ## Customize the portal ### Colors & brand identity The portal adopts the primary brand color and icon that have been configured in the 'Settings' section under the 'General' tab of Hyperline. This uses the same codes as those displayed on the invoice sent to your customers. This feature enables you to personalize your customer portal with the distinct colors and branding of your company. ### Set a custom domain In order to personalize further the experience for your customers, you can configure a custom domain for the hosted portal and checkout pages. You can set it in [your settings](https://app.hyperline.co/app/settings/hosted-pages), and to enable it you need to add a `CNAME` record pointing to `cname.hyperline.co` on your DNS provider. For example: you want to set your custom domain to `billing.alpeak.com` in Hyperline, and add the related `CNAME` record on your DNS provider, we will provide you portal and checkout URLs with the form: ``` https://billing.alpeak.com/portal/:customerId https://billing.alpeak.com/checkout/:sessionId ``` We will automatically manage the related HTTPS SSL certificate. ### Customer actions You can control what actions customers can perform on hosted pages through **Settings > Hosted pages** under the **Customer actions** section: #### Billing details update You can control whether customers can update their billing details (billing address, billing email, tax ID, and invoice emails) on hosted pages through **Settings > Hosted pages** under the **Customer actions** section. Toggle **Allow billing details update** to enable or disable this capability. When enabled, customers will be able to edit their billing information through the customer portal, checkout, and quote pages. #### Customer typology selection By default, hosted pages (customer portal, checkout, and quote pages) allow customers to select between B2C (person) and B2B (corporate) typologies when updating their billing information. You can disable this typology selection in **Settings > Hosted pages** under the **Customer actions** section. When disabled, customers will not be able to change their typology on hosted pages, and the form will use their existing typology setting. #### Payment method deletion You can control whether customers can delete their **default** payment method on hosted pages through **Settings > Hosted pages** under the **Customer actions** section. Toggle **Allow payment method deletion** to enable or disable this capability. Non-default payment methods can always be deleted regardless of this setting. When deletion is disabled, customers can still delete a default payment method if it is **irreversibly errored** — meaning the card or mandate is permanently dead and cannot be recovered. This covers the following error reasons: * `Expired` — the card or mandate has expired. * `MandateInvalid` — the mandate is no longer valid. Default payment methods in a **recoverable** error state (for example `InsufficientFunds`, `AuthenticationRequired`, `Declined`, `Fraud`, `Invalid`, `NotSupported`, `AuthorizationError`, or `Unknown`) remain locked, as the customer is expected to retry or re-authenticate rather than delete the payment method. ### Display options You can control what subscription information is displayed on hosted pages through **Settings > Hosted pages** under the **Display** section. #### Hide contract duration By default, subscription pages show contract details such as the contract start, commitment duration, and renewal terms. Toggle **Hide contract duration** in **Settings > Hosted pages** under the **Display** section to hide these details from the customer portal. Enable it when contract terms are managed outside Hyperline or could confuse customers. ### Generate a portal link You can generate a portal link for a specific customer in two ways: * **API**: call `GET /v1/customers/{id}/portal` to retrieve the portal URL. See the [endpoint reference](/api-reference/endpoints/customers/get-customer-portal). * **App**: click the **Portal** button on the customer page (see [How to access the customer portal](#how-to-access-the-customer-portal)). The returned link embeds an authentication token. It is valid for the duration set in **Link expiration delay**, or indefinitely if the delay is empty. After expiry, behavior depends on whether **Require customer authentication** is enabled — see [Authentication vs. link expiration](#authentication-vs-link-expiration). ### Portal authentication You can require customers to authenticate before accessing the customer portal through **Settings > Hosted pages > Security**. When enabled, customers without a valid token must verify their identity via a magic link sent to their email address before they can view their portal. #### How it works Portal links contain an authentication token. **Link expiration delay** controls how long that token is valid; **Require customer authentication** controls what happens when no valid token is present. When authentication is required and a customer opens the portal without a valid token (first visit, expired token, or direct URL): 1. The portal shows a login screen. 2. The customer enters an email matching their billing email or invoice emails. 3. A magic link is sent to that email. 4. Clicking the magic link grants access — indefinitely if no link expiration is set, otherwise for the configured window. Portal authentication adds an extra layer of security by ensuring only authorized users can access customer billing information. Useful for B2B customers where multiple people might share portal links. #### Authentication vs. link expiration Portal authentication and **Link expiration delay** combine to control access: * **Auth off, no expiration**: portal links work indefinitely (default). * **Auth off, expiration set**: tokens expire after the configured delay; revisiting the URL automatically issues a new token, no login required. * **Auth on, no expiration**: customers without a valid token are sent to the login screen. After authenticating via magic link, the issued token never expires (one-time auth, permanent access). * **Auth on, expiration set**: links work for the configured window. After expiry, customers must re-authenticate via magic link to obtain a new token. When authentication is required, every visit without a valid token redirects to the login screen. Communicate this to your customers if you change the setting. ### Link expiration delay By default, hosted page URLs (customer portal, checkout, and quote pages) contain authentication tokens that never expire. You can configure an expiration in **Settings > Hosted pages > Domain > Link expiration delay** (in minutes). When set: * Tokens are included in all hosted page URLs (both Hyperline-hosted and custom domain URLs). * After the delay, customers need a new link or must re-authenticate to access the page. * Applies to portal links, checkout session links, and quote links. Link expiration enhances security by limiting how long a shared link remains valid. Useful when links are sent via email or other channels where they might be forwarded. ### Set a redirect button You can configure a back button in the hosted pages settings. And it will look like this in the portal. ### Display personalization You can add this query parameter to your portal URL to hide the sidebar `&hideSidebar=true`. It will look like this: It works both for custom domain and Hyperline hosted pages. ### Embed the customer portal in an iframe You can embed the Hyperline customer portal inside your application using an ` ``` Browsers block payment features (Apple Pay, Google Pay) inside third-party iframes unless the embedding page explicitly delegates the `payment` permission. Without this attribute, wallet payment buttons will not appear for your customers — card payments still work. This also applies if you embed Hyperline checkout, quote, or payment pages in an iframe. If you use the [React SDK](/api-reference/docs/react-components), the permission is set automatically — make sure you run a recent version of `@hyperline/react-components`. If your site uses a strict Content Security Policy (CSP), you must explicitly allow our domains: ```html theme={null} ``` Add the following origins to your CSP so the iframe can load and downloads work: Production * [https://app.hyperline.co](https://app.hyperline.co) (Portal UI) * [https://internal.hyperline.co](https://internal.hyperline.co) (API calls within the iframe) * [https://api.hyperline.co](https://api.hyperline.co) (Public API calls) Sandbox * [https://sandbox.app.hyperline.co](https://sandbox.app.hyperline.co) * [https://sandbox.api.hyperline.co](https://sandbox.api.hyperline.co) * [https://sandbox.internal.hyperline.co](https://sandbox.internal.hyperline.co) If you’re using a custom domain for hosted pages, also include that domain wherever you allow app.hyperline.co. # Customer segments Source: https://docs.hyperline.co/docs/customers/segments Group Hyperline customers into dynamic segments using rule-based filters on country, currency, subscription status, custom properties, and more. Customer segments let you slice your customer base into dynamic, rule-based groups — for example "Enterprise customers in France paying by direct debit" or "All customers with a parent company". As your billing operations scale, treating every customer the same becomes impractical. Segments give your finance and revenue teams a way to define cohorts based on billing attributes (country, currency, payment method, invoicing entity, custom properties, etc.) and instantly see which customers fall into each group. Unlike static tags or manual lists, segments are **evaluated continuously**: when a customer's data changes, their segment membership updates automatically. Common use cases include: * **Regional billing analysis** — group customers by country or currency to review revenue distribution across markets. * **Payment method monitoring** — identify customers without a payment method on file or those using a specific gateway. * **Payment risk and collections** — surface customers who pay late often, have a high average delay, or whose payment method is errored or expired. * **Entity-level reporting** — filter customers by invoicing entity for compliance or accounting purposes. * **Custom cohorts** — combine custom properties with standard fields to build segments that match your business logic, such as plan tier, industry vertical, or contract type. * **Handpicked lists** — add a condition on specific customer IDs to build a segment from an explicit list of customers, useful when no shared attribute can define the group. ## Manage segments ### Create a segment Navigate to the **Segments** tab and click **New Segment**. Enter a **name** and an optional **description** for the segment. A segment is made of one or more **rules**, each containing one or more **conditions**. * Conditions within a rule are combined with **AND** logic — a customer must match all conditions in the rule. * Multiple rules are combined with **OR** logic — a customer belongs to the segment if they match any rule. Each condition is defined by a **field**, an **operator**, and one or more **values**. The field picker is organized into four sections to help you find the right attribute: * **Customer** — identity and account attributes (country, currency, language, invoicing entity, tax ID, etc.). * **Payment behavior** — payment method and collection metrics, including the **Late payment behavior** smart segment (see below). * **Billing** — subscription, product, and invoice attributes. * **Custom fields** — any text, number, select, or boolean custom property defined on customers. As you build your rules, a **live preview** table shows matching customers in real time. The table is paginated and searchable, and its columns dynamically adapt to display the fields used in your conditions. Click **Save** to create the segment. It will immediately appear in the segment list with its customer count. ### Edit a segment You can edit any segment by clicking on it in the list. The same form is displayed inline — update rules, conditions, or details, and save directly without a modal. The live preview updates as you modify the rules, so you can see the impact of your changes before saving. ### Delete a segment To delete a segment, open the actions menu and click **Delete**. A confirmation modal will appear — deletion is permanent and cannot be undone. ## Available filter fields | Section | Field | Value type | | ---------------- | ---------------------------- | ------------------------------------------------------------ | | Customer | Customer | Multi-select (search and pick specific customers) | | Customer | Country | Multi-select (country list) | | Customer | Currency | Multi-select (currency list) | | Customer | Language | Multi-select (language list) | | Customer | Invoicing entity | Multi-select (your invoicing entities) | | Customer | Relationship | Has parent / Has child | | Customer | Tax ID | Presence only | | Customer | External ID | Presence only | | Payment behavior | Late payment behavior | Smart segment (Hyperline-managed, see below) | | Payment behavior | Payment method type | Multi-select (card, direct debit, etc.) | | Payment behavior | Payment method status | Multi-select (Active, Pending, Errored, Expired) | | Payment behavior | Paid invoices | Number (count of paid invoices) | | Payment behavior | Invoices paid after due date | Number (count of invoices paid late) | | Payment behavior | Late payment rate | Number (share of invoices paid late, as a percentage) | | Payment behavior | Average late payment delay | Number (average days past due across late payments) | | Billing | Subscription status | Multi-select | | Billing | Subscribed product | Multi-select | | Billing | Invoice status | Multi-select | | Custom fields | Custom properties | Depends on the property type (text, number, select, boolean) | ### Smart segments Smart segments are cohorts **computed and maintained by Hyperline** from your billing data — you don't have to define their criteria yourself. They appear in the **Payment behavior** section of the field picker, marked with a lightning icon. * **Late payment behavior** — customers Hyperline identifies as showing late payment patterns, based on their paid and overdue invoice history. Add this field to a rule to target at-risk customers for dunning campaigns, manual outreach, or stricter payment terms, without having to tune the underlying thresholds yourself. Smart segments don't take an operator or a value — selecting the field is enough. ### Operators The operators available on a condition depend on the field type: * **Text and multi-select fields** (country, currency, payment method type, payment method status, subscription status, etc.) — `is in`, `is not in`. * **Presence-only fields** (Tax ID, External ID) — `is set`, `is not set`. * **Date fields** (created at, contract end date, etc.) — `is after`, `is before`, `is between`. * **Numeric payment behavior metrics** (paid invoices, invoices paid after due date, late payment rate, average late payment delay) — `equals`, `is greater than`, `is greater than or equal to`, `is less than`, `is less than or equal to`, `is between`. For example, to build a "high-risk payers" segment you could combine `Late payment rate is greater than or equal to 50` with `Average late payment delay is greater than 10` in a single rule. ## Segment stats The segment list displays stats for each segment: * **Customer count** — the number of customers matching the segment's rules * **Percentage** — the share of your total customer base that belongs to the segment These stats are kept up to date as your customer data evolves. ## Filter the customer list by segment Once you have created segments, they become available as filters in the main **Customers** list. Select a segment from the filter dropdown to narrow the list to only the customers that belong to that segment. This makes it easy to quickly navigate to a specific cohort without leaving the customer list — for example, to review all customers in a given country or all customers using a particular payment method. # Feature entitlements Source: https://docs.hyperline.co/docs/entitlements/overview Manage product capabilities, feature flags, and usage limits in Hyperline with catalog features, product grants, and per-customer overrides. Features represent the product capabilities, access rights, or usage limits that customers receive outside of billing. They help your team track what each customer is entitled to use, based on the products they have and any customer-specific override. Use features when you need to manage access such as SSO, premium integrations, included seats, API limits, or support tiers. Products still define what you sell and bill. Features define what access or limit that product grants. ## How entitlements are resolved An entitlement is the resolved value of a feature for a customer. Hyperline calculates it from three possible sources: | Source | Description | | --------------------- | ---------------------------------------------------------------------------------------------------------------- | | **Default value** | The fallback value configured on the feature in the catalog. Optional — features can be created with no default. | | **Product grant** | A value granted by a product included in the customer's eligible subscription. | | **Customer override** | A value set directly on the customer. Overrides product grants and the default value. | Customer overrides always take priority. If no customer override exists, Hyperline uses product grants. If no product grant changes the value, Hyperline uses the default value from the feature catalog. Product grants contribute to entitlements when the subscription that includes the product is `active` or `paused`. Paused subscriptions keep product-granted access, while other subscription statuses do not contribute product grants. ### Features without a default value Specifying a default is optional. A feature can be created with **no default value** for both boolean and number types. When a feature has no default: * Customers receive no resolved entitlement unless a product grant or a customer override provides one. * No source is displayed for the feature on the customer **Features** tab until a grant or override is set. * Use this when access should be explicitly granted per product or per customer rather than assumed by default — for example, a beta capability that only certain plans or customers should ever see. A **HubSpot integration** feature has a default value of disabled. The **Growth plan** product grants the feature as enabled. Customers subscribed to Growth receive the integration automatically, while a customer override can still enable or disable it for a specific customer. ## Feature value types Features can use two value types: | Type | Use for | Example | | ----------- | ---------------------------------------- | ---------------------------------------------------------- | | **Boolean** | Access that is enabled or disabled. | SSO, premium support, white-labeling, HubSpot integration. | | **Number** | Limits, quotas, or numeric entitlements. | Included seats, API calls, projects, storage in GB. | Boolean features do not require a resolution strategy. If a product grant enables the feature, the customer receives access unless a customer override changes the value. Number features use a resolution strategy to combine the default value and product grants. | Resolution | Behavior | Use when | | ----------- | ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- | | **Maximum** | Uses the highest value across the default value and product grants. Customer overrides win. | Multiple products can increase a limit, but the customer should receive only the largest grant. | | **Sum** | Adds the default value and product grant values. Customer overrides win. | Multiple products should stack together, such as included seats or usage quotas. | | **Replace** | Uses a product grant value instead of the default value. Customer overrides win. | A product should define the entitlement value directly. | When a number feature has **no default value**, resolution falls back to the product grants and customer overrides only. Maximum and Sum ignore the missing default and compute across product grants alone, and Replace uses the product grant value directly. ### Unlimited number entitlements A number entitlement can be set to **Unlimited** to grant uncapped access instead of a finite limit. Turn on the **Unlimited** toggle next to the value when you set a product grant, a customer override, or a direct customer grant. Unlimited applies to the **entitlement value** only. The feature's catalog **default value** always stays a plain number (or empty) — it cannot be set to Unlimited. Unlimited interacts with the resolution strategy as follows: | Resolution | Behavior with Unlimited | | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Maximum** | Unlimited always wins. A finite grant can never out-rank an Unlimited grant. | | **Sum** | If any contributing value is Unlimited, the resolved value is Unlimited. | | **Replace** | The applied product grant is used as-is, so the value is Unlimited only when that grant is Unlimited. Unlike Maximum and Sum, an Unlimited grant does not automatically win — a later finite grant replaces it. | As with any number feature, a customer override takes priority over product grants and the default value, so an Unlimited override grants uncapped access regardless of the product grants. An **API calls** feature has a default limit of `10000`. The **Enterprise plan** product grants the feature as Unlimited. Customers on Enterprise receive uncapped API calls, and a customer override can still set a specific number for a single customer. ## Create a feature 1. Go to **Catalog** > **Features**. 2. Click **New feature**. 3. Enter the feature **Name** and, if needed, an **Internal description**. 4. Enter a stable **Code**. Use an API-safe key such as `sso`, `hubspot_integration`, or `included_seats`. 5. Choose the value **Type**: * **Boolean** for enabled or disabled access. * **Number** for quotas or limits. 6. For number features, choose the **Resolution** strategy. 7. Optionally toggle **Default value** on and set the value. Leave the toggle off to create the feature with no default — customers will only receive an entitlement when a product grant or override provides one. 8. Click **Save feature**. Use codes that match how your product team refers to access internally. Stable codes make reporting and integrations easier to maintain. ## Archive, recover, or delete a feature Features have a lifecycle in the catalog. Archive a feature when you no longer want it granted to new products or customers, and delete it when it is no longer needed at all. Open a feature from **Catalog** > **Features** and use the **Actions** menu: | Action | When to use it | Effect | | ------------------- | ------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Archive feature** | You want to stop granting the feature going forward but keep it available for products and customers that already use it. | The feature is hidden from the default features list and cannot be selected when adding a new feature to a product or granting one to a customer. Existing product entitlements and customer overrides keep working. | | **Recover feature** | You archived a feature by mistake or want to grant it again. | The feature returns to the active list and becomes selectable again. | | **Delete feature** | The feature is no longer needed anywhere. | The feature is permanently removed. Only archived features that are not assigned to any product or customer can be deleted — remove those assignments first. | The archive state can only be changed through these actions. It is not editable from the feature edit form. ### Filter features by status The **Features** list has a **Status** filter with three values: * **Active** — the default view. Shows features that are not archived. * **Archived** — shows only archived features. Use this view to find and recover a feature. * **All** — shows every feature regardless of status. ### Archived features on products and customers Archived features remain visible where they are already in use: * Product **Entitlements** panels continue to show archived features that are granted by the product, so you can still see and adjust their values. * Customer **Features** tabs continue to show archived features that contribute to the customer's resolved entitlements. You cannot add an archived feature to a new product or grant it as a new customer override — recover it first, or add a different feature. ### Manage feature lifecycle from the API The same actions are available on the REST API. Use them from your own tooling or automation when you manage the feature catalog outside the app. | Endpoint | Purpose | | ----------------------------------- | ----------------------------------------------------------------------------------- | | `PUT /v1/features/{code}/archive` | Archive an active feature. | | `PUT /v1/features/{code}/unarchive` | Recover an archived feature. | | `DELETE /v1/features/{code}` | Permanently delete an archived feature that has no product or customer assignments. | See the [Archive a feature](/api-reference/endpoints/features/archive-feature) and [Unarchive a feature](/api-reference/endpoints/features/unarchive-feature) reference for request and response details. ## Grant features from products After a feature is created, add it to the products that include that capability or limit. 1. Go to **Catalog** > **Products**. 2. Open the product that should grant the feature. 3. In **Entitlements**, click **Add feature**. 4. Select the feature from the catalog. 5. Keep the default value or open the row to set a product-specific value. If the feature has no catalog default, you must provide an explicit value for the product grant to save. For number features, turn on **Unlimited** to grant uncapped access instead of a finite value. 6. Click **Save**. When the product is included in a customer's eligible subscription, its feature grants contribute to that customer's resolved entitlements. Entitlements do not create invoice lines or change the product price. They describe access granted by products that are already billed through subscriptions, quotes, or invoices. ## Review customer entitlements Open a customer page and select the **Features** tab to see the resolved entitlements for that customer. Each row shows the feature name, resolved value, and a tag indicating where the value comes from: | Tag | Meaning | | ------------ | ------------------------------------------------------------------------------------------------------------------------------- | | **Default** | The value comes from the feature catalog. | | **Product** | The value is granted by one or more of the customer's subscribed products. Hover the tag to see which subscriptions contribute. | | **Override** | A customer-specific value is applied on top of product grants and the default. | The **Features** tab is available to members with the `entitlements_update` permission on workspaces that have entitlements enabled. ## Override a customer entitlement Use customer overrides for exceptions that should apply only to one customer, such as a negotiated limit, an early access grant, or a support-approved exception. 1. Open the customer page and select the **Features** tab. 2. Find the feature in the table and open the row's action menu. 3. Click **Edit** to open the override modal. 4. Update the **Value** and, optionally, add a **Reason** to record why the override exists. For number features, turn on **Unlimited** to grant uncapped access. 5. Click **Save**. To remove an override and let Hyperline recalculate the value from product grants and the feature default, open the row's action menu and click **Reset**. ## Grant a feature to a customer You can also grant a feature directly to a customer, even if no subscribed product includes it. 1. Open the customer page and select the **Features** tab. 2. Click **Grant feature** and pick a feature from the picker. 3. Set the **Value** and, optionally, a **Reason**. For number features, turn on **Unlimited** to grant uncapped access. 4. Click **Grant feature**. The granted feature appears in the table with the **Override** tag and behaves like any other customer override. Customer overrides are customer-specific exceptions. Use them when the customer should intentionally differ from the product configuration. ## Next steps * Create billable catalog items in [Products and prices](../products/overview). * Add products to customers when you [create a subscription](../subscriptions/create). * Use [customer segments](../customers/segments) to group customers with similar access or commercial rules. # Configure your account Source: https://docs.hyperline.co/docs/getting-started/configure-account Configure your Hyperline account: business information, brand identity, logo, favicon, payment providers, and billing settings during onboarding. ## Business ### Information Fill in your company's **trade name** (the name used to conduct your business). It will be displayed on public pages and transactional emails. ### Brand identity Personalize the billing experience for your customers by adding your brand assets. 1. Add the **logo** you want to display on public pages, emails and documents (invoices, credit notes, quotes). 2. Add the **favicon** you will be using on public pages. 3. Select your **main brand color** by adding its HEX code. It will be displayed as an accent color on documents and emails. A real-time preview shows how your changes affect invoice design. ### Billing information The billing information will be displayed on documents (invoices, credit notes, quotes). It contains: 1. The company's **legal name**, which can be different from the trade name 2. The company's **billing address**, including all details required by your country's laws. 3. Your company's **tax ID** (validated for EU-based companies) The company's country cannot be changed as it determines your accounting currency. ## Payment methods Configure how you collect payments for each invoicing entity from **Settings > Payment**. The methods available to you depend on the entity's country and the payment providers you connect. From this page, you can: * Connect a payment provider for automated payment methods such as cards and direct debit. * Enable the payment methods you want to offer. * Select the default payment provider or bank account for each method. You can then control which of the enabled methods are available to each customer. See [Payment methods](../payments/payment-methods) for supported methods and customer-level configuration, and [Payment orchestration](../payments/orchestration) for payment provider setup. ### Bank accounts and bank transfers To let customers pay by manual bank transfer, enable bank transfers and configure the bank account that should receive the funds. Make sure its details are complete before issuing invoices: Hyperline uses the configured account to provide customers with the information they need to make the transfer. Manual bank transfers are not charged automatically. After receiving a transfer, you must reconcile it with the corresponding invoice. See [Invoice reconciliation](../invoices/reconciliations) for the available reconciliation options. ## Next steps * [Configure invoicing entities](../account/invoicing-entities) * [Review account settings](../account/settings) * [Set up sandbox and test mode](./sandbox) * [Create products and prices](../products/overview) # Quick start Source: https://docs.hyperline.co/docs/getting-started/quick-start Follow the shortest path to configure your Hyperline account, test safely in sandbox, create your first billing objects, and issue your first invoice. Use this guide when you are setting up Hyperline for the first time and want a clear path from an empty account to your first billing workflow. ## Setup path 1. [Configure your account](./configure-account) with your business information, brand assets, billing details, and default account settings. 2. [Configure your invoicing entities](../account/invoicing-entities), then review [account settings](../account/settings) for currencies, email settings, saved views, and formatting options. 3. Set up payment collection in the **Payments** section: * [Payment orchestration](../payments/orchestration) * [Payment methods](../payments/payment-methods) 4. Use [Sandbox and test mode](./sandbox) to test products, subscriptions, invoices, payments, and usage data without affecting production. 5. Create your catalog: * [Products and prices](../products/overview) * [Price books](../price-books/overview) 6. Create or import customers from [Customers](../customers/overview). 7. Create your first recurring billing flow with [Subscriptions](../subscriptions/overview), or prepare a commercial proposal with [Quotes](../quotes/overview). 8. Review generated invoices from [Invoices](../invoices/overview), then configure payment collection and reconciliation from [Payments](../payments/orchestration). ## Recommended first checks * Your business and billing details are correct. * Your invoicing entity settings match the legal entity issuing invoices. * Your account has at least one payment collection path, such as a connected provider, bank transfer details, or an outside-of-Hyperline process. * Your users have the right permissions before they create customer, subscription, invoice, or settings changes. * Your sandbox flow has been tested before production billing starts. Keep the first setup narrow. Start with one product, one customer, and one subscription or quote. Once the first flow works end to end, add more pricing, payment, and automation rules. ## Related * [Configure your account](./configure-account) * [Invoicing entities](../account/invoicing-entities) * [Account settings](../account/settings) * [Sandbox and test mode](./sandbox) * [Payment methods](../payments/payment-methods) # Sandbox and test mode Source: https://docs.hyperline.co/docs/getting-started/sandbox Use Hyperline's sandbox and test mode to safely experiment with subscriptions, invoices, and payment flows before switching to production. ## Hyperline test mode Setting up billing often requires experimentation. Use **test mode**, also called **sandbox**, to test Hyperline without affecting your production account. When you switch to test mode, Hyperline creates a separate test account. You can create test customers, subscriptions, invoices, usage events, and payments before configuring production billing. Test mode has the same product capabilities as your production account. Use the product documentation to configure your [product catalog](../products/overview), manage [templates](../subscriptions/templates), [send invoices](../invoices/overview), [use credits and wallets](../wallets/balance), and more. Test mode does not block outbound emails. If an action normally sends an email in production, Hyperline also sends it from your test account to the configured recipient, such as a customer email, invoice email, checkout recipient, quote recipient, or additional email recipient. Use internal or dedicated test email addresses for sandbox customers and recipients unless you intentionally want a real recipient to receive the message. ## Testing payments Test payment provider and gateway flows in sandbox before connecting production bank accounts or production payment provider accounts. Sandbox payments use sandbox payment provider accounts, so no real money is charged or debited. If your sandbox account was populated from production data or from another billing system, existing production payment methods cannot be used in sandbox. Production cards, mandates, and bank authorizations are not compatible with sandbox payment provider accounts. ### Add a test payment method To test automatic payments, add a test payment method to the sandbox customer from a hosted page: 1. Open a sandbox hosted page for the customer, such as a quote signature page, checkout page, invoice page, or customer portal. 2. Go to the **Add payment method** section. 3. Enter test payment details from your payment provider. Use the provider's test credentials: * [Stripe test cards](https://docs.stripe.com/testing#cards) * [Stripe SEPA Direct Debit test details](https://docs.stripe.com/testing?payment-method=sepa-direct-debit#non-card-payments) * [Adyen test cards](https://docs.adyen.com/development-resources/test-cards-and-credentials/test-card-numbers) * Adyen SEPA Direct Debit: enter a test IBAN with a valid format. No money will be debited. * [Mollie test cards](https://docs.mollie.com/overview/testing#testing-different-types-of-cards) Once a test payment method has been added, future invoices can be charged automatically with that payment method. To test payment collection on an existing invoice, open the invoice and click **Actions** > **Charge invoice**. ## Simulate usage data without code This applies if you want to **configure your first usage-based plan** and **assign a subscription to a customer** in order to test Hyperline. In the test account, you can simulate usage data by generating fake events for a specific customer. This is done in two steps: Then click the **Events** tab, and click **Simulate new events**. Fill in: * **The event type** (API calls, email sent, document retrieved or created, etc.) * **The date** (leave blank if you prefer) * **The number of events to create** * You can optionally add extra parameters to your event with the **JSON Payload field.** Click **Create new events** when you are ready. The events can take a few seconds to be ingested. They will appear in your customer's **Events page**. You can easily delete them in the **Events page** afterward. You are done. You can now create your first usage-based plan based on these events. ## Multiple accounts If you belong to several Hyperline accounts, use the account switcher to move between them without signing out. Each account has its own settings, members, permissions, customers, catalog, billing data, and integrations. You can therefore use separate accounts for different companies or legal entities that require fully independent configurations. Members and roles are managed separately for each account. See [Users & permissions](../account/users-permissions) for details. # Documentation Source: https://docs.hyperline.co/docs/index Hyperline documentation: manage customer intelligence, CPQ, subscriptions, AI monetization, invoicing, payments, accounting, and developer integrations.
Decorative background image Decorative background image

Documentation

Hyperline helps B2B software companies manage complex revenue workflows, from customer intelligence and CPQ to subscriptions, AI monetization, invoicing, payments, accounting, and developer integrations.
Manage customers, segments, usage, health signals, and customer intelligence workflows. Create quotes, structure contracts, manage subscriptions, and support hybrid pricing. Track usage, sell prepaid credits, manage balances, and apply these patterns to AI monetization. Generate invoices, manage taxes, documents, reminders, e-invoicing, and exports. Connect payment providers, collect payments, retry failures, and reconcile transactions. Track revenue, manage ledgers, automate journal entries, and handle revenue recognition.
# Glossary Source: https://docs.hyperline.co/docs/introduction/glossary Look up Hyperline billing terminology — customers, products, subscriptions, invoices, aggregators, ledgers — with clear definitions for each concept. Is something still unclear? Don't hesitate to [reach out to our team](mailto:support@hyperline.co) if you need additional support. ## Core entities | Term | Definition | | ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | | **Bundle product** | A product that groups several existing products as components and sells them as a single unit. Distinct from the "bundle" pricing model. | | **Customer** | An individual or company that purchases your products/services. Has billing information, payment methods, and can have multiple subscriptions. | | **Invoice** | A document requesting payment from a customer. | | **Product** | A billable item in your catalog. | | **Quote** | A sales proposal sent to customers before creating a subscription. Can be signed electronically or manually. | | **Subscription** | A recurring billing agreement between you and a customer, defining which products are included, pricing, and billing schedule. | ## Subscription | Term | Definition | | ------------------------- | -------------------------------------------------------------------------------------------------------------------------- | | **Activation strategy** | How a subscription becomes active. | | **Cancellation** | Ending a subscription. | | **Contract terms** | Terms governing the subscription contract including start/end dates, duration, and renewal settings. | | **Proration** | Calculating partial charges when changes occur mid-billing period. | | **Renewal** | When a subscription automatically continues for another term. | | **Subscription phase** | A distinct period within a subscription with its own products and terms (e.g., trial, standard). | | **Subscription template** | A pre-configured subscription setup that can be reused for multiple customers or contexts (currency/country combinations). | | **Subscription update** | A pending change to a subscription (add/remove products, change prices, apply coupons). | | **Trial period** | A free or discounted phase before regular billing begins. | ## Pricing and billing | Term | Definition | | -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Billing interval** | How often a customer is charged (e.g., monthly, yearly, weekly). | | **Commitment period** | Minimum contract duration for a subscription (e.g., 1-year commitment). | | **Price book** | A collection of custom price configurations that can be assigned to specific customers for special pricing. | | **Price configuration** | Defines how a product is priced. Includes currency, billing interval, and pricing model. | | **Pricing model - BPS (Basis Points)** | Percentage-based pricing typically used for payment processing fees. | | **Pricing model - Bulk** | A single price per unit is applied based on the total usage tier (e.g., 150 units all priced at the 101-200 tier rate). | | **Pricing model - Bundle** | Predefined quantity/price packages on a seat or credit product (e.g., 1000 credits for $50, or 10 seats for $180). Distinct from a Bundle product, which is a product type. | | **Pricing model - Fee** | A fixed amount charged per billing period (e.g., \$99/month). | | **Pricing model - Packaged** | Units are sold in packages/bundles (e.g., \$100 per 1000 API calls). | | **Pricing model - Volume** | Price per unit decreases as usage increases through tiers (e.g., first 100 units at $0.10, next 100 units at $0.08). | ## Usage and metering | Term | Definition | | -------------------------- | ------------------------------------------------------------------------------------------------------------------------- | | **Billable event** | A usage record sent via API that represents a customer action to be metered (e.g., API call, message sent, storage used). | | **Committed count** | A guaranteed minimum usage amount that will be charged regardless of actual usage. | | **Metering configuration** | Defines how billable events are counted or summed for billing. | | **Metering filter** | Conditions applied to narrow down which events count toward billing (e.g., only count events where `region = 'us'`). | | **Usage interval** | The period over which usage is measured before billing (can differ from billing interval). | ## Credits and wallet | Term | Definition | | ------------------------- | ------------------------------------------------------------------------------------------------ | | **Credit transaction** | A record of credits being added, consumed, or expired. | | **Credits** | Pre-purchased units that can be consumed against usage-based products. Can expire. | | **Low balance threshold** | A configurable threshold that triggers notifications when credits or wallet balance falls below. | | **Top-up** | Adding credits or wallet balance to a customer's account. | | **Wallet** | A prepaid balance account for a customer that can be used to pay invoices. | | **Wallet transaction** | A record of funds being credited or debited from a customer's wallet. | ## Discounts and promotions | Term | Definition | | ------------------- | ------------------------------------------------------------------------------------------------- | | **Coupon** | A discount that can be applied to subscriptions. Can be a fixed amount or percentage off. | | **Coupon duration** | How long a coupon applies. | | **Coupon repeat** | Controls coupon application frequency. | | **Promotion code** | A shareable code that customers can use to redeem a coupon. Can have usage limits and expiration. | ## Documents | Term | Definition | | --------------------- | ------------------------------------------------------------------------------------------------------------- | | **Checkout page** | A hosted payment page where customers can enter payment details and complete a purchase. | | **Checkout session** | A hosted page experience for customers to complete payment and subscription activation. | | **Contract clause** | Reusable text blocks that can be included in contracts. | | **Contract template** | Legal document templates that can be attached to quotes. | | **Credit note** | A document issued to reverse or reduce a previously issued invoice. | | **Customer portal** | A self-service interface where customers can view invoices, manage subscriptions, and update payment methods. | | **Invoice line item** | An individual charge on an invoice representing a product or adjustment. | | **Purchase order** | A customer's reference number for their internal tracking. | | **Quote template** | Reusable configuration for quotes including terms, display options, and attached documents. | ## Approvals | Term | Definition | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ | | **Approval request** | A request for approval created when a quote matches an approval workflow. Tracks the approval status and history. | | **Approval step** | A stage in an approval workflow where designated approvers must approve or reject before proceeding. | | **Approval workflow** | A configurable set of rules and steps that determine when and how quotes require approval based on conditions like amount or products. | | **Approver requirement** | Whether any single approver or all designated approvers must approve a step (`any` or `all`). | | **Workflow condition** | A rule that determines if a workflow applies to a quote (e.g., total amount greater than €10,000, specific products, discount percentage). | | **Workflow priority** | A number used to select between multiple matching workflows. Higher priority workflows are selected first. | ## Payments | Term | Definition | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------- | | **Bank account** | Customer's bank account details used for manual bank transfer payments. | | **Chargeback** | When a customer disputes a charge with their bank, resulting in reversed payment. | | **Dunning** | The process of automatically retrying failed payments and communicating with customers to collect overdue invoices. | | **Grace period** | A delay between invoice creation and payment collection, allowing review or manual adjustment. | | **Payment method** | How a customer pays (card, direct debit, bank transfer, etc.). | | **Payment method state** | Current status of a payment method. | | **Payment service provider (PSP)** | A third-party service that processes payments (e.g., Stripe, GoCardless, Mollie). | | **Transaction** | A payment attempt or successful charge against an invoice. | ## Organization | Term | Definition | | -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | | **Client** | Your account/organization in Hyperline (the seller). | | **Custom field** | User-defined properties that can be added to customers, subscriptions, products, plans, or quotes. | | **Invoicing entity** | A legal entity that issues invoices (your company or subsidiaries). Has its own branding, address, tax ID, and numbering sequences. | | **Tax ID** | A tax identification number (e.g., VAT number) for a customer or invoicing entity, used for tax compliance and validation. | | **Tax rate** | VAT/sales tax rates applied to invoices. | | **Tax scheme** | How tax is applied to an invoice. | ## Analytics and reporting | Term | Definition | | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **ARPA (Average Revenue Per Account)** | ARR divided by the number of active customers. | | **ARR (Annual Recurring Revenue)** | The recurring revenue normalized to a yearly amount, based on the subscription's currently active phase. Future phases are reflected when they become active. | | **Churn** | When customers cancel their subscriptions or reduce spending. | | **Contract value** | Total value of a subscription over its full contract term. | | **Estimated ARR** | Projected annual revenue from a subscription including variable/usage components. | | **MRR (Monthly Recurring Revenue)** | The value of recurring revenue normalized to a monthly amount. | | **TCV (Total Contract Value)** | The total value of all committed phases across the full contract term. Unlike ARR, it includes future phases before they become active. | A subscription has an active phase at $150 per month, followed by a later committed phase that brings the total contract value to $3,290. While the first phase is active, ARR is $1,800 ($150 x 12). TCV is \$3,290 because it includes the full committed contract. ## Integrations | Term | Definition | | --------------- | ------------------------------------------------------------------ | | **External ID** | Your system's identifier for a customer, used for mapping records. | # Why building billing in-house is risky Source: https://docs.hyperline.co/docs/introduction/why-billing-is-complex Understand why building a billing system in-house is risky for growing software companies, and how a dedicated platform supports pricing changes. Is your company growing? Congratulations! It is now time to charge your first customers—but how? Let's be frank; billing may not be the most glamorous aspect of your business, but it is a pivotal factor that can define your success. From day one, successful software companies have known how crucial it is for their billing solution to match their pricing strategy perfectly. For instance, Zoom swiftly adopted usage-based billing to accommodate a 30x surge in demand during the pandemic. If you're a founder, finance operator, or engineering leader, you're likely wondering whether it's best to build your billing system in-house or opt for a ready-made solution. Today, we're diving into the **'Build vs. Buy' dilemma**. Initially, as you embark on this journey, billing might seem straightforward. Your pricing structure is simple, making subscription management look easy. This also allows you to protect your profit margins by avoiding third-party billing services like Stripe Billing or Chargebee, which take a share of your earnings. However, as your business scales, you'll discover that billing is more complex than initially anticipated. Still wondering if building your own billing system is a good idea? Let's talk about it - we are here to answer all your questions. ## Subscription and usage-based models Launching a billing system typically begins with subscription-based billing. In this approach, each customer is assigned to a specific plan to ensure accurate charges at the right interval. **The fact is that complex pricing models are at the core of modern business operations**. As your company grows, you will likely implement various pricing strategies to optimize revenue and cater to client needs. This growth may entail the adoption of usage-based pricing, transactions, credits, custom subscriptions, coupons, or a mix of these items. Managing a large number of subscriptions is already challenging, and dealing with complex subscriptions adds another layer of billing complexity. For instance, adopting usage-based billing will require advanced metering and tracking systems. ## Taxation complexity As your business expands globally, dealing with taxes becomes a major factor that increases billing complexity. Taxes can be influenced by several factors: what you're selling, your location, and where your customers are. Each location has its own tax regulations, so it's crucial to comply with them everywhere you do business. For instance, consider a European company trying to figure out how to apply VAT (courtesy of Chargebee). It's a complex process with many possibilities, and ensuring the correct tax rate is applied based on where you and your customer are located is challenging if done manually. Maintaining these tax rules over time can be especially tough if you're building your own in-house billing system. ## Payment intervals management The challenge of billing complexity becomes particularly evident when you delve into date management. Imagine a scenario in which a company offers: * a platform access fee charged annually * a metered product charged every month * an onboarding fee charged once * a 3-month free trial for each pricing plan, etc. *Does it sound familiar?* This scenario demands the management of various payment intervals, alongside the coexistence of free and paid options, resulting in the need for intricate date management. Coordinating the timing of customer transitions from free to paid services, all while managing the billing cycles, due dates, and renewals for these different models, requires meticulous attention to detail. Considering these complexities, it becomes obvious that you need a solution that can effectively handle all of these challenges for you. ## Custom pricing Companies of all sizes often need to go beyond standard pricing. Custom pricing is vital in particular situations, allowing them to adjust their pricing plans to match the unique needs of each customer. This goes from special contracts for Enterprise deals to tailored packages for specific needs. However, managing these custom pricing arrangements with an in-house billing system can be challenging in the long run. This is where a flexible billing system becomes crucial. It should adapt to the diverse pricing needs of each client or situation, making it easier to manage custom pricing, maintain good customer relationships, and increase revenue over time. ## Multi-currency transactions Operating in a global market means dealing with multiple currencies. Converting and reconciling transactions in different currencies requires meticulous attention to detail and when you're building your billing solution it's very hard to follow up manually. For instance, consider a software company based in the U.S. that sells licenses to customers in Europe. The billing system must convert the sale amount from euros to dollars, accounting for any fluctuations in the exchange rate. On that same subject, it's also imperative to have aggregated metrics that take into account operations in various countries and currencies and gain a comprehensive understanding of the financial health of your business. These aggregated metrics, such as ARR (Annual Recurring Revenue) on a global dashboard, provide a holistic view of the company's performance. This not only ensures accurate financial reporting but also supports the generation of globally aggregated metrics that help in strategic decision-making. These dashboards may well be built in-house, but they're hard to keep afloat over time when your billing system is evolving and has been built from scratch. ## The challenge of dunning Dunning is the process of dealing with payments that didn't go through from customers. It makes billing more complicated for a couple of reasons: * **Automatic retries without manual intervention**: When a payment fails, you need to give it another shot without needing to remember to do so yourself. Having an automated system that can detect these payment issues and try again is crucial; otherwise, it can become a real headache. * **Effective customer communication**: When a customer's payment fails, you have to let them know in the right way. It's a delicate balance between informing them about the problem and ensuring they still have a positive experience. That's why having an emailing system built into your billing process is helpful; trying to manage it manually can be quite challenging. * **Entitlements for service access**: Additionally, there's a need for app logic that handles entitlements, which determine access to the service. Managing these entitlements to restrict access when payments fail adds another layer of complexity to the dunning process. ## Conclusion The path to billing success often leads to the realization that building an in-house billing system might not be the most practical choice. Instead, opting for a flexible billing solution can offer the adaptability and efficiency needed to navigate these complexities. By choosing the right tools, businesses can streamline their billing processes, maintain strong customer relationships, and continue on the path to growth and success. You want to learn more about this topic? [Read our blog article](https://www.hyperline.co/resources/blog/billing-simplified). # Invoice configuration Source: https://docs.hyperline.co/docs/invoices/configuration Configure Hyperline invoices from settings: brand assets, trade and legal names, tax IDs, footers, numbering format, and default behaviors. If you did not already configure your invoices during the initial onboarding process, you can do it anytime from Hyperline's interface, from the **Settings** pages. ## Business In the **Business** section, you can customize your brand's logo and color that will appear on your invoices. You are also required to fill in the trade and legal names of your company, your tax ID (if applicable), and the postal address that will appear on the invoices. These details are required to make your invoices legally compliant. We provide you with a real time preview on the right of the screen so you can see how your changes are affecting your invoice design. Click on `Save changes` once you are done. ## Invoicing You can customize settings that will apply to all generated invoices. New configurations will be applied to invoices generated after the changes are saved. #### Invoicing number You can customize how your invoices will be numbered. This is done in **Settings**, in the **Invoicing** section. Each invoice must have a **unique number**. These numbers should follow a sequential order. This is a legal requirement that applies internationally. Hyperline lets you however choose the invoice number pattern you want to use. The `{number}` variable is mandatory. You can then add any text, the year variable `{YYYY}`, the month variable `{MM}` and/or the day variable `{DD}` to customize the invoice number format. | Variable | Invoice number format | | ------------------- | --------------------- | | number | 1 | | number-YYYY | 1-2023 | | number-YYYY-MM | 1-2023-10 | | number-YYYY-MM-DD | 1-2023-10-10 | | YYYY-MM-DD-00number | 2023-10-10-001 | #### Invoice legal information As legal requirements vary from country to country, and are sometimes industry-specific, we leave a space for you to add any relevant legal information to your invoices. Check in with your legal and accounting teams if needed to make sure you include all necessary information here. It can go from tax specificities to penalties applied if the invoice is not paid on time, to anything else. #### Additional information You can insert here any additional information you'd like to provide. It could be details about your invoicing policy (late payment fees, conditions, etc.) or mentions about taxes if relevant. By clicking the globe icon on the right side of the text area, you can translate both the legal and additional information into multiple languages. The relevant language will be automatically selected when the invoice is generated. #### Template variables Invoice-family text fields support template variables that are replaced with the corresponding value when the document is generated. Supported fields include: * Invoice footer, additional information, and late fees * Credit note footer and additional information * Custom document footer and additional information * Custom note on invoices and on the subscription invoicing options form | Variable | Replaced with | | ------------------------ | ------------------------------------------------------------------------------------------------- | | `{{customerId}}` | The customer's Hyperline ID | | `{{customerExternalId}}` | The customer's external ID | | `{{subscriptionId}}` | The subscription's ID, only rendered when the invoice is tied to a subscription, otherwise hidden | | `{{invoiceId}}` | The invoice's ID | | `{{invoiceNumber}}` | The invoice's number | | `{{quoteNumber}}` | The quote's number | For example, a footer set to `Please reference {{invoiceNumber}} and subscription {{subscriptionId}} in your payment.` will produce a fully populated line on subscription-generated invoices, while `{{subscriptionId}}` is omitted on standalone invoices that aren't linked to a subscription. Quote footers and quote or contract templates don't support `{{subscriptionId}}`, because a quote isn't yet tied to a subscription. # Consolidated invoicing Source: https://docs.hyperline.co/docs/invoices/consolidated-invoicing Merge a customer's subscription invoices billed on the same day into one consolidated invoice, so they receive and pay a single invoice instead of many. Consolidated invoicing groups a customer's subscription invoices that fire on the same day into a single aggregated invoice. Each source invoice is held until Hyperline merges them into one consolidated invoice, which is then finalized, numbered and charged as usual. Use this when a customer has several subscriptions billing on the same day (for example, multiple product lines or seats renewing together) and you'd rather send them one invoice than several. ## How it works * Consolidation is a per-customer setting (`Consolidate invoices` toggle on the customer). * Each eligible invoice is grouped by the day it was scheduled to bill, in the customer's timezone. * Once the day has fully elapsed, Hyperline merges every held invoice for that day into a single new invoice — the **aggregate** — and marks the source invoices as **Consolidated**. * The aggregate is what gets finalized, numbered and charged. Source invoices never receive a number of their own. ### What's eligible Only invoices that meet all of these are held for consolidation: * The customer has `Consolidate invoices` enabled. * The invoice comes from a subscription (one-off invoices, documents and credit notes are excluded). * The invoice is not from an external source (imported invoices go through their own flow). * The invoice is of type `invoice` (credit notes and other document types are excluded). Ineligible invoices follow the normal lifecycle unchanged. ### Grouping by day Invoices are grouped by their **billing date** in the customer's timezone: * Bill-in-advance invoices group on the period start. * Bill-in-arrears invoices group on the period end. * Backdated subscriptions (a subscription created after its start date) group on the day they *would have* billed, not the day the catch-up invoice was actually emitted. This means a subscription starting July 1 but created on July 10 lands in the July 1 group, not July 10. ### The merge Hyperline waits until: 1. The consolidation day has fully elapsed in the customer's timezone, and 2. There are no pending renewals or in-flight invoices for that day still to land. Once both conditions are met, all held invoices for the day are merged into a single aggregate invoice: * Every line item from every source invoice is copied over, prefixed with the source subscription name so you can trace what came from where. * Line-item amounts, tax rate, tax amount, discounts, proration and debit/credit sign are preserved verbatim. The aggregate total equals the sum of the source invoices. * The aggregate carries no `subscriptionId` of its own (it spans several), so it is never itself held for consolidation. If only one invoice was held for the day, no aggregate is created — the lone invoice is released and finalized directly, so it never gets stuck waiting. ## Enable consolidated invoicing for a customer The toggle lives on the customer page, in the **Advanced** section of the customer edit form. Go to **Customers** and select the customer. Open the customer edit form and scroll to the **Advanced** section. Enable the toggle labelled **Consolidate invoices**. From this point on, new subscription invoices for this customer will be held until the daily merge. The current state is shown on the customer panel as a tag (**Enabled** / **Disabled**) next to the `Consolidate invoices` label, alongside the other invoicing settings. You can turn consolidated invoicing off at any time — but if the customer has invoices currently held (`Pending consolidation`), you'll need to let those merge (or delete them) before the toggle takes effect on new invoices. ## Invoice statuses Consolidated invoicing introduces two invoice statuses in addition to the [standard ones](./overview#invoice-status): `Pending consolidation` The invoice is held, waiting for the daily merge. It has no invoice number yet and hasn't been charged. Only action available: **delete** (see below). `Consolidated` The invoice was merged into an aggregate. It links to the aggregate invoice via `linkedInvoiceId`. The source is kept for record-keeping but the aggregate is what's charged. Both statuses appear in the invoice list and on the invoice detail page. ## The invoice detail page Hyperline surfaces the consolidation relationship directly on the invoice page: * **On a `Consolidated` source invoice**: a callout at the top of the page links to the aggregate the invoice was merged into. * **On an aggregate invoice**: a callout at the top of the page shows the number of source invoices consolidated into it and links to the filtered list of those sources. ## Actions on held invoices A `Pending consolidation` invoice is an internal, un-numbered state — it isn't a document to send. The available actions are limited on purpose: * **Delete** is allowed, so you can drop an invoice out of the day's group before it merges (for example, if the underlying subscription change was wrong). ## Stuck consolidations A group won't merge until the day is complete. Hyperline waits on: * Any subscription renewal for that day that hasn't fired yet. * Any peer invoice for the same day still in `grace_period`, `draft` or otherwise in-flight. ## Consolidated invoicing and organisation-based billing Consolidated invoicing composes with [organisation-based billing](../customers/organisation-based): * If the customer is an org **child**, the aggregate is routed to the parent following the child's org invoicing configuration (`Individual invoices` → `Charged on parent`, `Grouped` → `Pending parent concat`). The parent collects payment as usual. * If only a single invoice ends up being held for the day, that lone invoice is routed to the parent directly rather than being finalized standalone. ### Consolidating child invoices on the parent You can also consolidate the invoices of several children on the parent, so that a parent with multiple children each running their own subscriptions receives a single consolidated invoice per day instead of one per child subscription. To set this up: 1. On each child, open **Actions** > **Parent settings** and set the invoicing configuration to `Individual invoices`. **Do not enable `Consolidate invoices` on the children.** 2. On the parent, enable `Consolidate invoices`. With this configuration, each child subscription emits an un-numbered invoice in `Pending consolidation` state directly on the parent. At the end of the day, all of these invoices are merged into a single consolidated invoice on the parent, which is then finalized, numbered and charged as usual. ## Notes and limitations * Consolidation happens at most once per customer per calendar day (in the customer's timezone). Two subscriptions billing on the same day are merged; two subscriptions billing a day apart are not. * Held invoices don't get an invoice number — numbering is assigned to the aggregate when it's finalized. Your invoice number sequence is unaffected by consolidation (only the aggregate consumes a number). * Credit notes are never held for consolidation and follow the normal flow. * Tax is copied per-line from the source invoices rather than re-resolved by the tax engine, so the aggregate total is guaranteed to equal the sum of the sources. # Custom documents Source: https://docs.hyperline.co/docs/invoices/documents Create custom Hyperline documents with unique names that behave like invoices — numbered, payable, and tailored to specific business needs. In Hyperline, you can create custom documents with unique names that function like invoices—numbered, payable, and tailored to your specific business needs. These documents can serve various purposes, such as providing informational materials for customers or issuing special payment receipts required by clients outside the standard invoicing process. A document is generated when the **Generate documents instead of invoices** option is checked when creating a subscription. This document is then sent to the customer instead of an invoice. See more on the [subscription creation page](../subscriptions/create). ## Configuring your documents You can customize your documents by going to the **Settings > Invoicing** section. You have access to: * The **document number pattern**. * The available variables are: `number`, `YYYY`, `MM`, `DD`. * `number` is mandatory. * The **next document number**. This is a read-only field that shows the next document number that will be generated. If you want to update the value, please contact our support team. * The **document legal information**. This field is optional. * The **additional document footer**. This field is also optional. This information will be displayed on all documents generated by Hyperline. By clicking the globe icon on the right of the text area, you can translate the additional and legal information into multiple languages. The relevant language will be automatically selected when the document is generated. If no relevant translation is found, the default value will be used. # Chorus Pro Source: https://docs.hyperline.co/docs/invoices/einvoicing/chorus-pro Send invoices automatically to French public administrations via Chorus Pro with Hyperline's e-invoicing integration for B2G and G2G sales. ## What is Chorus Pro Chorus Pro is the official digital portal managed by the French public sector (AIFE), used to manage electronic invoicing with government entities in France. As of today, it allows automatic transmission of invoices to public administrations (G2G/B2G sales). Since early 2020, all companies operating in France—regardless of their size—are required to submit invoices to public bodies (ministries, local authorities, hospitals, etc.) via Chorus Pro. With the upcoming French e-invoicing reforms (2026-2027), Chorus Pro will become part of a broader "Portail public de facturation" (PPF), handling e-invoices between companies and public administrations. ## Setup Before setting up the integration, you need to configure a "Raccordement" (EDI/API). From the [Chorus Pro portal](https://portail.chorus-pro.gouv.fr), connect to your account. * Go to **Domaines** > **Raccordements** in the main menu * Go to the **Technical Account** section (**Compte technique** in French) * Set the type of request to **Création d'un compte technique** in French * Select your company in the company field * This creates a login and password — **copy these credentials** as you'll need them when setting up Chorus Pro in Hyperline. * Ensure you have entered your **VAT number** and **Registration number** (SIRET in France) on your invoicing entity. * In **Settings > Invoicing**: * Enable **Chorus Pro** — this option is only available for French invoicing entities. * Click the **Add credentials** button and enter your technical account credentials in the Supplier portal that opens. Once logged in, you can safely close the portal. ### Testing To test in sandbox mode, create an account in the [Chorus Pro sandbox](https://qualif.chorus-pro.gouv.fr/). Download the CSV file with test accounts and use one of them to log in. For more information, visit the [Chorus Pro documentation](https://portail.chorus-pro.gouv.fr/aife_documentation?sys_kb_id=2f95a09d3bbaae102e11034a85e45a6d\&id=kb_article_view). ## Enable Chorus Pro on customers Chorus Pro automatic transmission is only relevant for government-affiliated customers (B2G sales). For Hyperline to send invoices via Chorus Pro, you need to enable the **Government affiliated** flag on the relevant customers. For each customer where Chorus Pro transmission applies, go to the customer details page, click **Edit** in the **Information** section, and toggle on the **Government affiliated** option. ## Routing By default, invoices are routed to the customer using their registration number (SIRET), which identifies the public institution. On the customer details page, click the **Edit** button in the **Information** section and set the value in the **Registration number** field. Invoices for customers with a missing registration number will not be automatically transmitted via Chorus Pro. Both your invoicing entity and your customer must have a **14-character** SIRET for Chorus Pro to accept the invoice. ### Service code For some public institutions, an additional service code is required to route the invoice. This code identifies the service within the public institution. If not provided, the invoice may be rejected during transmission. To add service-specific routing for a customer, open the customer details page, click **Edit** in the **Information** section, then complete the **Service code** field. Leave this optional field empty when the customer's SIRET is sufficient. The e-invoicing code field on the customer form is labelled dynamically. For a government-affiliated customer whose invoicing entity has Chorus Pro enabled, the field appears as **Service code**, even when France PA is also enabled on the same invoicing entity. # French e-invoicing with a PA Source: https://docs.hyperline.co/docs/invoices/einvoicing/france-pa Transmit French domestic B2B e-invoices in Factur-X format through a Plateforme Agréée using Hyperline or Pennylane, with customer routing setup. A **Plateforme Agréée (PA)** transmits electronic invoices between French companies and reports the required invoice data to the French administration. Hyperline supports PA transmission for domestic B2B invoices in Factur-X format. For invoices sent to French public administrations, use [Chorus Pro](./chorus-pro) instead. ## Reform timeline France is introducing its e-invoicing requirements in two phases. All companies established in France must be able to receive electronic invoices from the first phase, while the obligation to issue them depends on company size. | Phase | Date | Requirement | Companies concerned | | ----------- | ----------------- | --------------------------------------- | -------------------------------------------------------- | | **Phase 1** | September 1, 2026 | Receive e-invoices | All companies established in France | | **Phase 1** | September 1, 2026 | Issue e-invoices and submit e-reporting | Large companies and mid-sized companies (ETI) | | **Phase 2** | September 1, 2027 | Issue e-invoices and submit e-reporting | Small and medium enterprises (SMEs) and micro-businesses | If your company generates less than €50M in annual revenue, the issuing and e-reporting requirements apply from September 2027. You must still be able to receive e-invoices from September 2026. ## Choose your PA connection You can transmit French e-invoices from Hyperline using one of two connections. ### Hyperline Select **Hyperline** to send domestic B2B invoices through Hyperline's connection, powered by Invopop's accredited platform. Your invoicing entity must be registered before invoices can be exchanged. You can follow the registration status from **Settings > Invoicing**. ### Pennylane Select **Pennylane** if your company uses Pennylane as its PA. Your invoicing entity must be connected to Pennylane in Hyperline, and Pennylane must be registered as the PA for your company. If Pennylane is disconnected or does not have the required permissions, reconnect it before selecting this option. ## Configure France PA 1. Go to **Settings > Invoicing**. 2. Select the relevant French invoicing entity. 3. In **French e-invoicing**, select **Hyperline** or **Pennylane** for business e-invoicing (B2B). 4. Complete the registration or reconnection requested for the selected provider. 5. Click **Save changes**. Once the connection is ready, Hyperline automatically transmits eligible domestic B2B invoices through the selected PA and displays their transmission status on the invoice details page. ## Customer routing ### Default routing address Hyperline builds the customer's default routing address with scheme `0225` and their SIREN. It resolves the SIREN in this order: 1. **Registration number**: Hyperline uses a 9-digit SIREN directly or extracts the first 9 digits from a 14-digit SIRET. 2. **Tax ID**: if the registration number is missing or invalid, Hyperline extracts the SIREN from the customer's French tax ID. A customer has the SIRET `12345678900015`. Hyperline uses the first nine digits as its SIREN and routes the invoice to `0225:123456789`. ### Override the routing address If the customer uses a routing address different from their SIREN, you can override the inferred value: 1. Open the customer details page. 2. Click **Edit** in the **Information** section. 3. Enter the address provided by the customer or their PA in **Routing address**. 4. Save the customer. The value in **Routing address** replaces the SIREN that Hyperline would otherwise infer for France PA routing. France PA expects a routing address rather than a generic e-invoicing code, which is why the field is labelled accordingly when France PA is enabled on the invoicing entity. If the same customer is marked **Government affiliated** and the invoicing entity also has Chorus Pro enabled, the field is instead labelled **Service code** and is used for Chorus Pro routing rather than France PA. ## Next steps * See the [e-invoicing overview](./overview) for supported countries and general transmission behavior. * Configure [Chorus Pro](./chorus-pro) for French public-sector customers. # E-invoicing overview Source: https://docs.hyperline.co/docs/invoices/einvoicing/overview Understand e-invoicing compliance with Hyperline: standardized digital invoice transmission across regions like the European Union and beyond. ## What is e-invoicing? E-invoicing, or electronic invoicing, is the process of sending bills and invoices digitally between buyers and sellers. This topic typically involves a standardized format that allows invoices to be issued, received, and processed automatically by the involved parties' financial systems. This standardization is crucial for compliance, especially in regions like the European Union, where certain standards for e-invoicing are mandated. ## Support in Hyperline Hyperline is **compliant with the e-invoicing standards** of the European Union, meaning it can generate valid invoices in both PDF and XML formats, and automatically transmit issued invoices to the appropriate tax authority in the invoicing entity's country. Hyperline is proactively integrating this compliance into its product foundations by partnering with a third party that is compliant with local requirements to offer this service in each country as the e-invoicing mandate becomes mandatory. | Country | Format / platform | Requirement scope | Hyperline status | Auto transmission | | ------------ | ------------------------------------------------- | --------------------------------- | ---------------- | :---------------: | | **Italy** | **SDI (Sistema di Interscambio)** / **FatturaPA** | B2G, B2B, B2C | **Supported** | ✅ | | **France** | **[Chorus Pro](./chorus-pro)** / **CII** | B2G | **Supported** | ✅ | | **France** | **[PA](./france-pa)** / **Factur-X** | Domestic B2B and e-reporting | **Supported** | ✅ | | **Belgium** | **[Peppol](./peppol)** / **BIS Billing 3.0** | B2G and B2B | **Supported** | ✅ | | **Germany** | **[Peppol](./peppol)** / **BIS Billing 3.0** | B2G and supported B2B recipients | **Supported** | ✅ | | **Germany** | **XRechnung** | B2G | **Supported** | | | **Germany** | **ZUGFeRD** | B2B | **Supported** | | | **Portugal** | **SAF-T PT** / **AT (Autoridade Tributária)** | B2G, B2B (progressively enforced) | **Planned** | | | **Spain** | **FacturaE** | B2G | **Supported** | | | **Spain** | **VERI\*FACTU** | B2B | **Supported** | ✅ | ## Customer routing information Hyperline uses the customer's country, tax ID, and registration number to determine the default routing value for each e-invoicing system. You only need to provide an override when your customer uses a different identifier or requires additional routing information. | System | Value inferred by Hyperline | Optional customer field | When to complete it | | --------------------------------------------------- | ----------------------------------------------------------------------------------- | ------------------------- | -------------------------------------------------------------- | | **[Peppol — Belgium](./peppol#routing-in-belgium)** | Scheme `0208` and the enterprise number derived from the Belgian tax ID | **Peppol participant ID** | The customer uses a different registered participant ID | | **[Peppol — Germany](./peppol#routing-in-germany)** | Scheme `9930` and the customer's German VAT ID | **Peppol participant ID** | The customer uses another participant ID, such as a Leitweg-ID | | **[Chorus Pro](./chorus-pro#routing)** | The customer's SIRET | **Service code** | The public institution requires routing to a specific service | | **[France PA](./france-pa)** | Scheme `0225` and the customer's SIREN | **Routing address** | The customer uses a routing address different from their SIREN | | **SDI — Italy** | The recipient's SDI code cannot be derived from their tax ID or registration number | **SDI code** | Enter the 7-character code provided by the customer | These customer fields use the same underlying e-invoicing code, but Hyperline displays a label adapted to the selected system. To set a value or override, open the customer details page, click **Edit** in the **Information** section, then complete the field shown for that system. The label the field takes depends on which e-invoicing systems are enabled on the customer's invoicing entity, and whether the customer is marked **Government affiliated**: * **Service code** — when the customer is government-affiliated and Chorus Pro is enabled on the invoicing entity. Chorus Pro takes precedence over France PA for B2G customers. * **Routing address** — when France PA is enabled (and the customer is not routed to Chorus Pro). * **Peppol participant ID** — when Peppol is enabled. * **SDI code** — when the Italian SDI is enabled. * **Service code** — when Chorus Pro is enabled without France PA. * **E-invoicing code** — fallback label when none of the systems above are configured on the invoicing entity. For SDI, the customer's tax ID identifies the company but not its electronic delivery channel. The customer must provide their **SDI code** separately. For France PA, the field expects a **routing address** (typically the customer's SIREN, or another electronic address they have registered) rather than a generic e-invoicing code. Copy an override exactly as provided by the customer or their e-invoicing platform. For [Peppol](./peppol), you can verify the participant ID in the [Peppol Directory](https://directory.peppol.eu/public). ## Activation If your country already requires this standard, you can activate this capability in your settings. Some systems require pre-registration before starting the automatic transmission of invoices. Click on the **Add credentials** button to provide the necessary information. You can then follow the status of the transmission for each invoice in the invoice details page. If automatic transmission is disabled for an invoicing entity, invoices will show a "Not supported" transmission status instead of tracking the transmission progress. ### Mark as transmitted If you handled the transmission outside of Hyperline (for example, by uploading the e-invoice manually to a tax authority's portal), you can record this on the invoice so its status reflects reality and downstream behavior treats it as transmitted. The **Mark as transmitted** action is available on the invoice detail page when the e-invoicing transmission status is **Not transmitted** or **Failed**. Use it when: * Your invoicing entity does not have automatic transmission enabled, but you have transmitted the e-invoice through another channel. * An automatic transmission attempt failed and you completed it manually outside of Hyperline. Once marked, the transmission status switches to **Manually transmitted** and the transmission date is set to the moment you triggered the action. The invoice is then treated the same as an automatically transmitted invoice: it becomes **edit-locked**, so you can no longer modify its content, and the [customer notification](#customer-notification) rules described below apply. Marking an e-invoice as transmitted only updates its status in Hyperline. It does not send the invoice to any tax authority or e-invoicing platform. Make sure the invoice has actually been transmitted before using this action. ## Customer notification When e-invoicing is enabled and the invoice is eligible for automatic transmission, the ["Invoice to pay"](../../account/settings#email-settings) email notification is not sent when the invoice is issued, but only when the invoice is actually transmitted to the e-invoicing system. This email indicates to the customer that the invoice has been transmitted and is ready to be paid. # Peppol Source: https://docs.hyperline.co/docs/invoices/einvoicing/peppol Send compliant electronic invoices to Belgian and German customers over the Peppol network with Hyperline using the Peppol BIS Billing UBL format. ## What is Peppol Peppol (Pan-European Public Procurement Online) is a standardized network that enables businesses to exchange electronic documents, including invoices, securely and seamlessly across borders. By connecting to the Peppol network, you can send legally compliant e-invoices directly to your customers' accounting systems, reducing manual processing, eliminating paper, and ensuring faster payment cycles. Peppol uses a four-corner model where certified Access Points handle the secure transmission of documents between parties. ## Setup Before sending invoices via Peppol, you need to register your invoicing entity with the Peppol network. Navigate to **Settings > Invoicing**, select the appropriate invoicing entity if you have multiple, enable **Peppol**, and enter your Peppol credentials. After uploading the required documents, the registration process can take up to 72 hours. Once registered, eligible invoices will be automatically sent via Peppol. Hyperline transmits invoices using the Peppol BIS Billing UBL Invoice/CreditNote V3 format. ## Routing in Belgium By default, Hyperline uses Peppol scheme `0208` and the customer's enterprise number, derived from their Belgian tax ID without the country prefix. For example, the tax ID `BE0543547220` produces the participant ID `0208:0543547220`. If the customer uses a different registered participant ID, you can override the inferred value in **Peppol participant ID**. You can verify a customer's participant ID in the [Peppol Directory](https://directory.peppol.eu/public). ## Routing in Germany By default, Hyperline uses Peppol scheme `9930` and the customer's German VAT ID. For example, the VAT ID `DE987654321` produces the participant ID `9930:DE987654321`. If the customer uses a different identifier, such as a Leitweg-ID, enter the complete participant ID in **Peppol participant ID**. You can verify that the ID is registered and able to receive invoices in the [Peppol Directory](https://directory.peppol.eu/public). Peppol is a delivery network. The participant ID identifies where to send the invoice; it is separate from the invoice format, such as XRechnung. ## Set a participant ID To set the Peppol participant ID manually: 1. Open the customer details page. 2. Click **Edit** in the **Information** section. 3. Enter the complete participant ID in **Peppol participant ID**, using the `scheme:identifier` format. 4. Save the customer. This optional value overrides the participant ID that Hyperline would otherwise infer from the customer's tax ID. ## Troubleshooting If a Peppol invoice fails, first verify the participant ID and routing scheme in the Peppol Directory. A valid tax ID is not always the same as a valid Peppol participant ID. For broader accounting and e-invoicing sync issues, see [Troubleshoot accounting and e-invoicing sync errors](../../../guides/troubleshooting-sync-errors). # Invoice emails Source: https://docs.hyperline.co/docs/invoices/emails Send automated invoice email notifications to customers in Hyperline when an invoice is issued, paid, or overdue, with customizable recipients. If you have [customer automated emails](../account/settings#email-settings) turned on, Hyperline will automatically send an email to your customer when an invoice 1) is ready to be paid 2) has been paid. The recipient email corresponds to the one specified in the **Invoice emails** field on your customer page (located in the Information panel), or, if not defined, to the main **Email** of the customer. ## Invoice ready to be paid When a new invoice is issued and the customer chose to pay manually by bank transfer (during their checkout), we will automatically send this email with the PDF attached. We attach automatically on the invoice the bank account details you configured in your Settings > Payment page (bank account corresponding to the currency of the invoice). If you want to learn more about payment reminders and dunning process, check the [Invoice reminders article](./reminders). ## Invoice or credit note paid Whenever a new invoice is settled (fully paid) for all payment methods including the manual "Mark as paid" action, we will automatically send this email with the PDF attached. This notification also applies for credit notes. ## Resend an invoice or credit note by email You can resend an invoice or credit note by email by clicking on the **Resend by Email** button in the invoice dropdown anywhere on the site either on the [invoices list](https://app.hyperline.co/app/invoices/list) or the invoice page. It will send the right email according to the status of the invoice. You'll be asked to confirm the action and reminded of the email it's going to be sent to. Note that the invoice email will take precedence over the customer's email. If everything looks good, click **Resend email**, and the email will be sent. An entry will also be added to the invoice's history. ## Email sending delay Emails regarding invoicing are sent right after the invoice is generated. Depending on the method, the delay might slightly vary: after actions such as checkout completions, payment errors and manual charge, the email is sent immediately. When the invoices are generated automatically by the billing schedule, the email can take up to 5 minutes to be sent to the customer. # Invoice exports Source: https://docs.hyperline.co/docs/invoices/exports Export Hyperline invoice data with built-in CSV exports — simple, accounting, or comprehensive formats — for bookkeeping and external analysis. If you wish to export your invoice data, especially for accounting purposes, Hyperline provides you with built-in and flexible file exports. ## Export flow On your [invoices page](https://app.hyperline.co/app/invoices), click the **Export invoices** button in the top-left corner. We provide you with three export types: * **Simple export**: Export a single file with the details of your invoices. * **Detailed export**: Export two files with invoices and their line items in a zip file. * **Complete export**: Export invoices, their line items and the PDF files in one go. Select the start date and end date of data you want to export. We provide you with CSV, XLSX or JSON format. A file is automatically downloaded with the related data. ## Large exports Invoice exports are generated asynchronously. On large workspaces or broad date ranges, the file can take longer to prepare before it is available to download. CSV exports are limited to 10,000 rows. If your export is too large, reduce the date range, export a narrower invoice set, use the public API for paginated extraction, or contact support for help with a bulk export. ### Amounts format The exported amounts are represented in the currency's smallest unit. For **European currencies**, this means that amounts are represented in **cents**. If you want to convert the exported amount into its decimals format you need to divide it by `100`. For example, an exported amount of `3417` (Euro, a two-decimal currency) will correspond to `€34.17`. The same logic applies for **zero-decimal currencies** and **three-decimal currencies**. In this case, you need to apply the right multiplier (or none). For example, an exported amount of `12065` (West African CFA franc, a zero-decimal currency) will correspond to `F CFA 12065`. # Public invoice page Source: https://docs.hyperline.co/docs/invoices/invoice-page Share a hosted public invoice page where customers can view, download, and pay outstanding or paid invoices through a secure Hyperline link. ## Overview Hyperline provides an invoice page where your customers can access both outstanding and paid invoices. This public page is also linked in the "Invoice to pay" email sent. This page can be accessed through your Hyperline interface on the invoice details page. ## Pay invoice Customers can pay their invoices directly through the public invoice page which acts as a payment link, similar to the checkout process. When the payment method allowed is credit card or direct debit, customers can enter their payment information to pay the invoice instantly. When the allowed payment method is bank transfer, the invoice will be displayed and can be downloaded with the bank transfer details included in the payment information section. ## Paid invoice Once an invoice is paid, the page will display the PDF invoice along with the date and payment method used. Customers can download the invoice using the button on the top right. ## Explore consumption For invoices containing metered products (usage and connected seats), customers can explore the details of every event billed during the period with full context. Additionally, they can export this data: * **Export single product**: Click the export button within a specific product's event table to download a CSV file containing only that product's events * **Export all products**: Click **Download all events** on the top-right corner to download a ZIP file containing separate CSV files for each product on the invoice # Manage invoices Source: https://docs.hyperline.co/docs/invoices/manage Create, edit, and duplicate Hyperline invoices manually for ad-hoc billing needs that fall outside subscription or recurring payment flows. While most invoices are automatically generated from subscriptions or one-time payments, Hyperline provides full flexibility to manually create, edit, and duplicate invoices for specific business needs. ## Create invoice Manual invoice creation is useful for ad-hoc billing needs that fall outside your standard subscription or payment flows. From the customer details page, click **Create Invoice**. ### Configuration Configure the header information and details of the invoice. * **Issue date**, for legal compliance, the issue date is automatically set to today's date and cannot be modified. * **Due date**, set any future date (including today) as the due date. Once reached, the invoice status will change to `late`, similar to the payment delay functionality. * **Purchase order**, optionally add a custom purchase order reference to the invoice. * **Custom note**, optionally include additional information for your customer in a custom note field. * **Link subscription**, optionally attach an invoice to a subscription for reporting purposes. ### Line items Line items represent the products and services on the invoice. Customize the name, description, billing interval, and tax rate for each of them. The total price is calculated automatically by multiplying quantity by unit price. You can also reference an existing product from your catalog. For usage-based products, retrieve the current usage for the invoice period by clicking the database icon in the quantity field. Note that pricing is not computed automatically when using catalog products. Using a catalog product enables your customer to explore consumption details for that product during the invoice period on the customer portal. Line items can have negative amounts to represent credits or adjustments. Note that the total invoice amount cannot be negative. ### Custom properties If you have created custom properties for invoices, you can fill them when creating or editing an invoice. Use invoice custom properties to keep structured information such as a contract reference, sales owner, internal cost center, or any value that should follow the invoice through reporting and integrations. When an invoice is generated from a subscription, Hyperline automatically copies the subscription's custom property values to the invoice when the same custom property is available on both entities. You can still edit the invoice value afterward when the invoice can be updated. ### Delete or re-order line items Line items can be removed from the invoice, or re-ordered to match the order of your choice. Re Order Or Delete ### Apply coupons Coupons apply a fixed amount discount to the invoice total before taxes. You can add a custom name to the coupon, set the discounted amount as well as the line items it will be applied to. Coupon amount will never exceed the total amount of the line item it's applied to. ### Create draft Click **Create draft invoice** to generate the invoice with `draft` status. Draft invoices are not sent to customers and can be edited multiple times before being finalized manually. ## Edit invoice Edit invoices to modify information before sending them for payment. This provides full control over the final invoice content. Once an invoice has been emitted, some elements like issue date, line items and coupons cannot be edited anymore due to legal requirements. Customer billing details, custom note, purchase order can be edited even after the invoice is marked as paid. ## Duplicate invoice Duplicate existing invoices to quickly create similar invoices or correct errors in finalized invoices. It's the right approach to: * Quickly replicate a payment for another period * Correct errors in a finalized invoice by creating a new version * Reuse invoice structure with updated information Duplicated invoices automatically reflect any updates to the customer's address or tax rate. If the original invoice had a bank account that has been deleted, the duplicated invoice will not include a bank account reference. ## Common validation errors When creating, editing, or duplicating invoices, you may encounter validation errors. Here are the most common ones and how to resolve them: **Missing required information** * **Missing customer ID**: Ensure a customer is selected before creating the invoice. * **Missing currency**: Select a currency for the invoice. * **Missing line item name**: All line items must have a name. * **Missing line item unit amount**: All line items must have a unit amount specified. * **Missing coupon amount**: All coupons must have a discount amount. **Date and status issues** * **Issue date cannot be in the past**: When creating invoices, the issue date must be today or later (except when duplicating). * **Settlement date can only be set for paid invoices**: Only invoices with `paid` status can have a settlement date. * **Settlement date is required for paid invoices**: Invoices marked as `paid` must include a settlement date. **Address and tax issues** * **The address is not complete enough for tax declaration**: Ensure the customer's billing address includes all required fields for tax compliance. * **Customer name is required for tax calculation**: The customer must have a name for tax calculations to work properly. **Product and invoice references** * **Product not found**: The referenced product may have been deleted. Select a different product or remove the product reference. * **Duplicate invoice found**: An invoice with the same details already exists for this customer. * **Some invoices don't exist or are already linked to another invoice**: When linking invoices, ensure all referenced invoices exist and are not already linked. **Payment provider issues** * **Failed to retrieve provider transaction**: There was an issue connecting to the payment provider. Try again or contact support. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Invoices overview Source: https://docs.hyperline.co/docs/invoices/overview Automate recurring invoicing and create one-off invoices in Hyperline, with automatic line items from subscriptions, multi-currency support, and PDFs. ## Invoices in Hyperline Hyperline provides a simple and versatile invoicing solution to automate your invoicing, no matter the pricing model or the currency. Automate recurring billing or create one-off invoices on demand for your customers. Hyperline automatically computes line items for invoices corresponding to products in the assigned plan. Invoices are managed in the **Invoices** section of Hyperline. You can [configure your invoice](./configuration) in the Settings pages. Invoice numbers always follow a sequential pattern (learn more in the [invoice configuration](./configuration#invoicing-number)). Invoices always feature: * A creation date * A due date * The invoice status * The invoice category * The payment method * The total amount for the transaction, including VAT if applicable * Names and addresses of both parties * Legal information (if any were added in the [Invoice settings](./configuration)) ### Invoice language Hyperline invoices are currently available in **English, French, German, Italian, Spanish, Polish, Portuguese and Dutch** languages. The invoice is generated in the primary language of your country for legal and accounting purposes. However, depending on your customer's language preference, you or they can download the invoice in their preferred language. ### Invoice customer address Invoices created before changing a customer's address will keep the previous address. Any change made to an invoice through the "edit" action will automatically update the customer's address. ### Invoice payment method The customer's default payment method is used when creating an invoice. While an invoice is not paid, you can update it. ### Invoice status `Draft` Represents an editable invoice. We are only using this status before the invoice is finalized (ready to pay). A draft invoice is generated without a number. `Open` Displays when your customer is assigned a metered subscription, we create an open invoice (generated without a number) in the background that we update on a regular basis to represent the latest consumption. `Grace period` Displays when a metered subscription has closed. During the grace period, the invoice isn't charged, and you can make modifications manually until the end of the grace period. A grace period invoice is generated without a number. `To pay` The invoice is finalized (a number is assigned) and is pending payment. Invoices attached to an automated payment method will be automatically charged. Invoices paid by bank transfer will remain with this status until [you mark them as paid](./reconciliations). `Late` The invoice has passed its due date and has not been fully paid yet. This status helps you identify overdue invoices that require follow-up. `Partially paid` The invoice has been paid only partially (only for transfers). See the [Reconciliation page](./reconciliations) for more details. `Paid` The invoice is fully paid and now has a settled date, you can book-keep it. `Pending consolidation` The invoice is held, waiting to be merged into a daily consolidated invoice for a customer that has [consolidated invoicing](./consolidated-invoicing) enabled. It has no invoice number yet and hasn't been charged. `Consolidated` The invoice was merged into an aggregate consolidated invoice. It links to the aggregate via `linkedInvoiceId`. The source is kept for record-keeping — the aggregate is what's charged. Learn more in [consolidated invoicing](./consolidated-invoicing). `Missing payment info` We haven't tried to process the invoice because the related customer doesn't have a payment method. `Error` We have tried to charge the invoice 4 times (3 retries) and it failed. Learn more on how to handle payment errors [on this page](../payments/payment-errors). `Uncollectible` Represents an invoice that cannot be collected due to reasons like bankruptcy, disputes, or prolonged nonpayment, and which is typically written off as a bad debt. Can still be marked as paid in case funds are finally collected. `Voided` The invoice has been voided and is no longer valid. Voided invoices are kept for record-keeping purposes but have no financial impact. `Closed` The invoice has been closed without payment, typically because there was nothing to bill after the grace period ended (for example, when all metered items resulted in zero usage). ### Invoice categories **Refund** - The related payment has been refunded. A credit note has been issued. **One-off** - Describes a one-off invoice. **Subscription** - Describes an invoice that is part of a subscription. You can filter invoices by category in the **Invoices** page using the **Category** filter dropdown. ### Invoice filters **Outstanding** - Invoices that have been only partially paid and are still awaiting payment. **Late** - Invoices with passed due date and not fully paid yet. **Paid** - Fully paid invoices. **Refunded** - Refunded invoices. ### View invoices by customer You can view all the invoices for a specific customer by going to **Customers**, selecting one customer and clicking on the **Invoices** tab. ### Accounting If the [accounting module](/docs/accounting/getting-started) is enabled, the invoice detail page carries an **Accounting** section showing how that invoice hit your books: * The **journal entries** posted for it — at issue, at settlement, and on any credit note * The **recognition schedules** created for its line items, when revenue is deferred Where an invoice's entity has more than one ledger, a selector lets you switch between them — the same invoice can post to a statutory and a management ledger with different accounts. **View in ledger** on any entry opens it in the [journal entry lines](/docs/accounting/entries#journal-entry-lines-drill-down) view, in the context of the account it hit. ## Send recurring invoices Recurring invoices are automatically generated with subscriptions. For this, you need to [assign a subscription](../subscriptions/create) and start a subscription to a customer to trigger recurrent invoicing. Recurring invoices can have different amounts or the same amounts each time, depending on the pricing model (pay-per-use is more likely to vary over time than monthly fixed-price subscriptions). ## One-time payments One-off invoices will be generated for one-time payments, such as onboarding fees, unique license fees or any other product you create from the **Product catalog** section. Whatever its usual pricing model, the product is charged as a fixed amount (quantity × unit price). To charge a one-time payment: Select the customer you want to charge.
  • Immediately: The date will be set to today, and result in a direct charge on your customer's payment method
  • Checkout completion: It will create a checkout link for your customer to pay with. The issue date will match the payment date
If none are set by default, you can still visit the **Product catalog** page to create new products. 1. If you select **Immediately**, the invoice is created instantly and will appear with a **Paid** status. 2. If you enabled the checkout session, an invoice will be created with a **Draft** status until the customer pays through their checkout page.
It is possible to generate one-time payment invoices for a customer who already has an ongoing subscription with recurring invoices. Alternatively, it is possible to generate one-time payment invoices for a customer without an active subscription. # Reconciliation Source: https://docs.hyperline.co/docs/invoices/reconciliations Reconcile invoices with banking transactions in Hyperline — automatic matching for PSP card and SEPA payments, plus bank statement import. Hyperline natively supports reconciliation between banking transactions and invoices in multiple ways, depending on the payment method used by your customers. ## Payment service provider (PSP) If you use a Payment Service Provider (PSP) with automated payment methods like cards or direct debit, invoices will automatically reconcile without manual intervention. As Hyperline orchestrates the payment initiation, it tracks payment status (money movement, chargebacks, etc.) in real-time and updates the invoice accordingly. ## Connected bank account Hyperline **supports a wide range of bank connections in France, the UK, Germany, Belgium, Spain, and the US**, enabling you to link your business bank account with a single click. Once connected, your bank account details can be added to invoices, and Hyperline will **automatically suggest matching transactions for each invoice, facilitating easy reconciliation**. Click on 'Connect bank account'. Click on the 'Link new bank' button and complete the authentication process. Once linked, select the bank account you want to connect to Hyperline. Hyperline will automatically match transactions or suggest one from your bank account for each unpaid invoice based on matching details. Additionally, you can access your bank statements and account balances, and reconcile invoices directly from the Transactions page. ### Reconciliation logic Reconciliation targets invoices with status 'to\_pay' or 'partially\_paid', and is restricted to payment methods 'transfer' or 'external' (or no payment method set). Hyperline automatically matches incoming bank transactions to outstanding invoices using a confidence-based scoring system. Each transaction is scored against unpaid invoices, and only matches above a minimum confidence threshold are suggested, ranked from most to least likely. Matching signals (from strongest to weakest): * Payment reference — If the transaction description contains the invoice's payment reference, it's an automatic match. * Alphanumeric invoice number — Invoice numbers containing both letters and digits (e.g. INV-2024-042) found in the transaction description are also treated as certain matches. * Known payer account + exact amount — When the paying bank account is already linked to the customer and the amount/currency match, confidence is very high. * Invoice number, customer name, amount — These signals are scored individually and combined. An invoice number appearing as a distinct word carries more weight than a partial match. Customer name and exact amount each contribute additional confidence. Only matches exceeding the confidence threshold are surfaced, sorted by likelihood so the best match appears first. Transactions are fetched daily, meaning that a transaction arriving in the bank account on one day will be suggested for reconciliation the following day. ### Viewing invoice status in transactions When viewing your bank transactions, Hyperline displays invoice status indicators next to reconciled or suggested invoices. These visual indicators help you quickly identify the payment status of each invoice. This makes it easier to understand the current state of each invoice directly from the transactions view without needing to navigate to the invoice detail page. ## Automated customer bank transfer Hyperline offers a method to **automate bank transfer reconciliation** by assigning unique bank account details per customer and a distinct reference for every invoice. The account details remain constant for each customer, while the reference changes with each invoice. The bank account details and reference are added to the invoice **when it is ready to be paid** and sent for payment. When a payment is received with the matching reference, Hyperline automatically reconciles the invoice and marks it as paid, eliminating the need for manual intervention. If a customer uses an incorrect or unrecognized reference, the funds are automatically returned to the customer's bank account. This feature is currently available only with Mollie. You can transfer payouts from your Mollie account to another bank account, just as you would with any other card or direct debit payments. ## Manual customer bank transfer If you enable manual bank transfers as a payment option (in the 'Settings > Payment' page), you will need to manually update invoice statuses to 'Paid' in Hyperline, as the platform cannot access your bank account information and transaction history. After setting up a subscription for your customer, they can pay via their checkout page by selecting 'Bank transfer'. When the customer clicks on **Pay**, they will be presented with a link to download their invoice as a PDF document. The invoice will then appear in the **Invoices** section with the status **To pay**. You will need to manually mark it as **Paid** or **Partially paid** in Hyperline once payment is received. ### Manually marking invoices as paid Manually changing the status of invoices only applies to bank transfers and other offline transactions. For all other transactions (credit cards, direct debit, automated transfers) through a Payment Service Provider, **invoices will be automatically updated in Hyperline**. When creating a new subscription with bank transfers, the invoice status will automatically be marked as **To pay** until the first payment is received from the customer. There are two ways to change an invoice status from **To pay** to **Paid** or **Partially paid**: From the Invoices page, click the three-dots menu on the invoice row, then select **Mark as paid**. Alternatively, from the invoice detail page, click **Actions** and select **Mark as paid**. Select whether to mark the invoice as **Paid** or **Partially paid**, specify the amount paid, and click **Save**. The **partially paid** status allows you to offer customers the flexibility to pay in multiple installments. You can update the invoice status after each payment is received until the total amount is paid. The invoice status will update to either **Paid** or **Partially paid**, and the transaction status will be marked as **Settled**. Below is an example of a partially paid invoice: And a fully paid invoice: # Credit notes & refunds Source: https://docs.hyperline.co/docs/invoices/refunds Issue credit notes and process refunds in Hyperline: cancel charges, return funds via the original payment method, or top up customer wallets. If you are looking to cancel subscriptions, please visit the [manage subscriptions page](../subscriptions/manage). It's currently not possible to create a credit note for an invoice not created by Hyperline.
As an alternative, you can [provide a free top-up on your customer's wallet](/docs/wallets/balance), which will be used to pay for future invoices.
## Choose the right action Hyperline separates the accounting correction from the money movement: * **Create a credit note** when an invoice amount must be cancelled or reduced. The credit note is the legal/accounting document. It can be created without money movement, or it can be settled by refunding the original payment method, crediting the customer wallet, or recording an external refund. * **Refund a transaction directly** when a settled PSP payment must be sent back but the invoice should remain payable. This creates a refund transaction for the full remaining refundable amount. It does not create a credit note or cancel any invoice amount; once the refund settles, the related invoice payment status is recalculated and can go back to **to pay**. | Situation | Use | | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------- | | Cancel or reduce an invoice amount | Create a credit note | | Cancel or reduce an invoice amount and send money back now | Create a credit note and enable **Refund transaction** | | Record money already refunded outside Hyperline for a cancelled or reduced invoice | Create a credit note and select **Mark as refunded outside of Hyperline** | | Send a captured payment back while keeping the invoice due | Refund the transaction directly | | Credit a customer for an invoice not created by Hyperline | Create an ad-hoc credit note or provide a wallet top-up | ## Configuring your credit notes Credit notes are generated manually or when you create a credit note from an invoice. You can customize the credit note template in the **Settings > Invoicing** section. You have access to: * The **credit note number** pattern * The available variables are: `number`, `YYYY`, `MM`, `DD`. * `number` is mandatory. * The **next credit note number**. This is a read-only field that shows the next credit note that will be generated. If you want to update the value, please contact our support team. * The **credit note legal information**. This field is optional. * The additional **credit note footer**. This field is also optional. By clicking on the globe on the right side of the text area, you can translate both the legal and additional information into multiple languages. The relevant language will be automatically selected when the credit note is generated. Credit note settings with translation options ## Create a credit note You can create a credit note from any invoice with the following statuses: **paid**, **partially paid**, **to pay**, or **error**. **Prerequisites and restrictions:** * You cannot create a credit note for an invoice that has already been fully credited (indicated by the `refundedAt` timestamp) * If an invoice has been partially credited, you can create additional credit notes up to the remaining amount available for credit notes * Credit notes cannot be created for invoices imported from external billing systems (see [Ad-hoc credit notes](#ad-hoc-credit-notes) for alternatives) Click on the invoice you want to create a credit note for. A modal will open with the credit note creation form. ### Credit note options The creation modal includes the following options: #### Partial credit note By default, the credit note is created for the full invoice amount. Enable this option to create a partial credit note by selecting specific line items. When enabled, a table displays all line items from the original invoice with the following columns: | Column | Description | | ------------------------- | ---------------------------------------------------- | | Selected | Checkbox to include the line item in the credit note | | Unit amount excluding tax | The unit price before tax | | Unit count | The quantity to credit | Partial credit note line items selection table You can adjust both the quantity and the unit amount for each selected line item. The credited amount cannot exceed the original line item amount minus any amounts already credited for that line item. If the invoice contains both credit and debit line items (including negative line item amounts), line item selection is not available. In this case, you can only specify a single amount to credit. When creating a partial credit note, you must select at least one line item before submitting. The form will display an error message if you attempt to create a partial credit note without selecting any line items. **Maximum credit note amount calculation:** The maximum credit note amount is calculated as the total invoice amount minus the sum of all non-voided credit notes already issued. Voided credit notes are excluded from this calculation, allowing you to create new credit notes if a previous one was voided. The total credit note amount cannot exceed the maximum credit note amount for the invoice. If you attempt to credit more than the available amount, the system will prevent you from creating the credit note. #### Send credit note via email When enabled, the credit note will be sent to the customer via email upon creation. This option is checked by default but only available if the customer has an email address configured for invoices. #### Refund transaction Enable this option to settle the credit note with a money movement. The availability of refund methods depends on the invoice status and payment method. **Refund availability by invoice status:** * **Paid invoices**: All refund methods are available (subject to additional restrictions below) * **Partially paid, to pay, or error invoices**: The refund transaction option is disabled. You can only create a credit note without processing a refund **Available refund methods:** * **Refund on original payment method**: Initiates a refund to the payment method used for the original invoice. When you execute a refund, Hyperline sends the refund request to your payment provider. The success notification indicates the refund has been **initiated**, not that funds have been transferred. The refund is processed asynchronously by the payment provider, and funds will be returned to the customer according to the provider's timeline (typically immediately for card payments, or within 3-4 days for bank transfers). Available when: * The invoice status is **paid** * The invoice was paid using an automatic payment method (not bank transfer) * The invoice has not been previously refunded * For GoCardless transactions: At least 7 days have passed since the invoice settlement date Monitor your payment provider dashboard for the final refund status and confirmation that funds have been transferred to the customer. * **Refund on customer wallet**: Adds the credited amount to the customer's wallet balance. Available when: * The invoice status is **paid** * Wallets are enabled in your settings * For invoices paid via bank transfer, this is the primary refund method available * **Mark as refunded outside of Hyperline**: Creates a record of an external refund transaction. Available for paid invoices when automatic refund methods are not available or when you prefer to handle the refund manually Refund transaction method selection options If you do not enable the refund transaction option, the credit note is created without any money movement. This is useful when you only need the accounting document or when you plan to process the refund separately. **GoCardless refund delay**: For invoices paid via GoCardless, you must wait 7 days after the invoice settlement date before processing a refund through the original payment method. During this waiting period, you can create the credit note and either mark it as refunded externally or refund to the customer's wallet (if enabled). ## Invoice status changes When you create a credit note, the status of the original invoice changes based on its current state: * **To pay invoices**: Creating a credit note automatically voids the original invoice, unless the invoice has a pending payment transaction (`to_process`, `pending`, or `scheduled` status). If a payment transaction is pending, the invoice will not be voided to prevent conflicts with the ongoing payment process. The invoice status changes to **voided**, and it can no longer be collected. The invoice remains visible in your system for audit and compliance purposes. **Irreversible action**: Once an invoice has been voided due to a credit note creation, you cannot reverse this action. If you need to correct a credit note, you can void the credit note itself and create a new one, but the original invoice will remain voided. * **Paid invoices**: The invoice status remains **paid**, but the system tracks that a credit note has been issued. The invoice displays an indicator showing that a credit note has been created. * **Partially paid invoices**: The invoice status remains **partially paid**. The credit note reduces the amount that can be credited in the future, but does not change the invoice's payment status. * **Error invoices**: The invoice status remains **error**. Credit notes can be created to resolve billing discrepancies. ## Credit note lifecycle Credit notes can be voided if they were created in error or need to be corrected. When a credit note is voided: * The credit note status changes to **voided** * Voided credit notes are excluded from credit note amount calculations * You can create new credit notes up to the full invoice amount (minus any other non-voided credit notes) * The voided credit note remains visible in the system for audit trail purposes * The original invoice status is not automatically restored when a credit note is voided To void a credit note, navigate to the credit note detail page and use the void action from the actions menu. **Voiding paid credit notes:** A paid credit note means the credit note itself has been settled, for example through a PSP refund, a wallet credit, or an external settlement. You can still void it when the accounting document needs to be corrected. Voiding a paid credit note does not reverse the money movement. You need to manually handle any necessary adjustment with your payment provider, wallet balance, or customer. You can void credit notes regardless of their status, including paid credit notes and credit notes that have been applied to other invoices. Void credit note action in the three-dots menu ## Visualize your credit notes To view and manage your credit notes: From there, you can: * Download credit notes as PDF files * View associated transactions on payment service providers (PSPs) * Access credit note details and history * Void credit notes if needed All actions are available through the actions menu for each credit note. Credit notes list with available actions menu Credit notes are linked to their original invoices. You can view this relationship from either the invoice or credit note detail pages. The invoice detail page shows all associated credit notes, while the credit note page displays the original invoice reference. Credit note detail page showing link to original invoice ## Ad-hoc credit notes Ad-hoc credit notes are standalone credit notes that are not linked to an existing invoice in Hyperline. This feature is useful when you need to issue a credit note for an invoice created in a different billing system or when providing a credit that doesn't correspond to a specific invoice. **Key characteristics:** * Not automatically applied to any invoice (manual application required if you want to offset amounts) * Do not affect the credit note amount calculations of existing invoices * Can be sent to customers via email * Follow the same template configuration as regular credit notes To create an ad-hoc credit note, use the **Create invoice** button in the customer details page. # Invoice reminders & dunning Source: https://docs.hyperline.co/docs/invoices/reminders Automate payment reminders and dunning sequences for overdue Hyperline invoices, with configurable email cadence and escalation rules. When using cards or direct debits, payment collection is fully automated with customer's payment method charged by Hyperline without any manual operation from either party. However, receiving payments on time from your customers paying manually can be more challenging, often requiring you to remind them about due invoices and missing payments. Only invoices without a payment method assigned, configured to be paid via bank transfer, or with a payment method in error are concerned by payment reminders. For invoices paid with valid automated payment methods (Credit Card, Direct Debit), "payment errored" emails will be sent. Hyperline provides a comprehensive invoice reminders module, enabling you to **schedule automated email reminders before, on, or after the invoice due date**. You can create multiple sequences, segmented by cohorts. These sequences can have as many reminder emails as you want, with customized email subject and body. This allows you to tailor your dunning communication, automate payment follow-ups and eliminate the need for manual intervention. All email reminders are sent at 6 AM UTC, regardless of the time the invoice was generated. ## Configuring a reminder sequence To create a new reminder sequence, head to Invoicing > Reminders. By default, Hyperline creates a default sequence (in English) for all new accounts. ### Audience When creating a sequence, you must configure an audience, which defines which customers the reminder sequence applies to. Only invoices paid by **bank transfer** or without any payment method set are eligible. There are two ways to define the audience for a reminder sequence: #### Using a segment You can select an existing [customer segment](../customers/segments) as the audience for your reminder sequence. This is the recommended approach when you already have segments that match the cohorts you want to target — for example, "Enterprise customers in France" or "Customers paying by bank transfer in English". Segments are evaluated continuously, so as customers enter or leave the segment, they are automatically included in or excluded from the reminder sequence. #### Custom filters Alternatively, you can define a custom audience directly on the sequence using filters: * **Language** — filter by customer language to ensure reminders are sent in the appropriate language. If language isn't a factor, select the `All` option to include all customers regardless of their language preference. * **[Custom properties](../properties)** — filter by custom properties configured on your customers. This allows you to tailor audiences based on specific attributes, enabling more precise control over your invoice reminder sequences. ### Customize the emails When adding an email to your reminder sequence, you can configure the trigger based on a number of days before, on, or after the invoice due date. You can also configure the email subject and body with your own content. The PDF invoice will be automatically attached in all email reminders sent. To preview the email in your inbox, you can use the 'Send test email' button. ## Opt out a customer from reminders To exclude a specific customer from reminder sequences, you can switch off the 'Invoice email reminders' setting on your customer: go to the Customer > Click on the customer > 'Edit' on the top right of the page > Switch off the 'Invoice email reminders'. ## Track emails sent When an email reminder is sent for a specific invoice, a corresponding history log is added to the invoice History. As for other emails, we provide delivery, open, and read status for complete traceability. # Tax management Source: https://docs.hyperline.co/docs/invoices/tax-management Apply the right VAT and sales tax rules on Hyperline invoices, with country-specific rates, reverse charge logic, and exemption handling. When invoicing customers, businesses must apply the correct tax scheme based on their location and the applicable laws. The two main types of taxes commonly seen on invoices are **Value-Added Tax (VAT)** and **Sales Tax**. ## How does VAT work VAT is a consumption tax applied at every stage of the supply chain where value is added, from production to the point of sale. The final consumer ultimately bears the tax. VAT is common in most countries worldwide, particularly in Europe and some parts of Asia and Africa. VAT rates vary by country and are often categorized into standard, reduced, and zero rates for different goods and services. ### In the EU First and foremost, ensure that you're registered with your country's tax authority and hold a valid VAT registration number, also known as an EU VAT Identification number. This number will be essential for conducting VAT-related activities. Next, determine whether your customers are businesses or consumers. Hyperline validates EU VAT numbers and uses the result when deciding whether reverse charge can apply. The chart below summarizes how Hyperline determines VAT for an EU-based invoicing entity. It assumes that automated tax collection is enabled. ```mermaid theme={null} flowchart TD A{"Is the customer marked
as tax exempt?"} A -- "Yes" --> B["VAT exempt"] A -- "No" --> C{"Is a manual VAT
rate set?"} C -- "Yes" --> D["Apply the manual VAT rate"] C -- "No" --> E{"Is the customer in
the EU VAT area?"} E -- "No" --> F["No EU VAT
Local tax rules may apply"] E -- "Yes" --> G{"Are the seller and customer
in the same VAT territory?"} G -- "Yes" --> H["Apply the seller-country VAT rate"] G -- "No" --> I{"Does the customer's VAT ID meet
your reverse-charge rules?"} I -- "Yes" --> J["Apply reverse charge
0% VAT"] I -- "No" --> K{"Is the customer typology
B2C (person)?"} K -- "No" --> H K -- "Yes" --> M{"Has this invoicing entity exceeded
€10,000 in eligible annual sales?"} M -- "No" --> H M -- "Yes" --> L["Apply the customer-country VAT rate"] classDef result fill:#FFF4D6,stroke:#E4B84B,color:#28251F; classDef exempt fill:#FCE8E6,stroke:#E39189,color:#28251F; class B,F exempt; class D,H,J,L result; ```
When issuing invoices, it is mandatory to include VAT, even if it is zero-rated. VAT returns must also be submitted on a regular basis, typically monthly, quarterly, or annually, depending on the specific requirements of each country. Be diligent in fulfilling these obligations to remain compliant. Once you are registered for VAT in another EU country, it's important to note that you should not charge VAT for both your own country and the customer's country. VAT should only be applied once, in accordance with the rules and regulations of the customer's location. Lastly, keep in mind that obtaining VAT registration in a new country can be a time-consuming process, typically taking around 6 weeks. This timeline can vary depending on the country where you are seeking registration. Patience and adherence to the necessary procedures will be key during this period. #### EU cross-border B2C threshold When you use Hyperline's automated tax engine, Hyperline automatically tracks the EU-wide €10,000 threshold used for eligible cross-border business-to-consumer (B2C) sales. Below this threshold, VAT is calculated using the rate of the invoicing entity's country. Once the threshold is exceeded, subsequent eligible invoices use the VAT rate of the customer's country. Hyperline tracks the threshold: * Separately for each invoicing entity * Per calendar year * Using amounts excluding tax from issued invoices in euros * Only when the customer's current typology is B2C (person) * Using invoices that do not include a tax ID Domestic sales do not change their applicable VAT rate when the threshold is exceeded. Cross-border B2B sales that qualify for reverse charge follow the [reverse charge rules](#eu-vat-and-tax-id-validation) instead. Your French invoicing entity sells to consumers in Spain. While its tracked annual amount is at or below €10,000, eligible invoices use the French VAT rate. After issued invoices bring the tracked amount above €10,000, subsequent eligible invoices use the Spanish VAT rate. The €10,000 threshold applies only to certain cross-border B2C supplies. See the [European Commission's cross-border VAT guidance](https://europa.eu/youreurope/business/taxation/vat/cross-border-vat/index_en.htm) and confirm your obligations with your tax adviser. ### Outside the EU If you're a business registered within an EU-based country, you don't charge VAT for customers that are based outside of the EU. Please take a look [at this page](https://uscib.org/value-added-tax-rates-vat-by-country/) to learn more about the different VAT rates globally. ## How does Sales Tax work Sales tax is a tax imposed on the sale of goods and services, collected only at the point of sale from the end consumer. It is primarily used in the United States and some parts of Canada, and rates are usually set by states or local governments and vary significantly across jurisdictions. ## Configure taxes in Hyperline In Hyperline, tax settings are managed per invoicing entity, allowing you flexibility in defining specific tax behavior depending on the legal entity responsible for issuing customer invoices. Hyperline automatically resolves the right tax scheme and applies the standard tax rate, the default rate of taxation applied to most goods and services. This is the general rate set by the government, which applies unless a specific good or service qualifies for a reduced rate, zero rate, or exemption. Two options are available regarding VAT collection: 1. **Automated tax collection**: Hyperline will automatically collect taxes based on your origin country and customer information (country, VAT number, tax ID, etc.). The correct VAT amount and rate will be applied on the issued invoices. 2. **Manual tax handling**: Hyperline allows manual tax handling where you are responsible for filing taxes by country. To use manual tax handling, go to **Settings** > **Taxes** for the relevant invoicing entity and turn off **Enable automated tax collection**, which is enabled by default. ## Tax calculation on invoices The taxes (rates and amounts) will appear on all invoices under the billed subtotal. When creating, editing, or duplicating invoices, you can manually set custom rates for each individual line. Tax is calculated on each invoice line item, then aggregated into the invoice totals. This means line-level rounding can affect the final tax total, especially when invoices contain several products, discounts, or mixed tax rates. If you need to review or adjust line-level taxes before the customer is charged, enable draft invoices or configure a grace period for usage-based invoices. ### Grace period for metered invoices For metered and usage-based subscriptions, the `grace_period` is the number of days an invoice stays open after the billing period ends. During this period, the invoice is not finalized or charged, so you can review usage, adjust line items, or correct taxes before payment collection starts. When the grace period ends, the invoice is finalized, assigned an invoice number, and moves to payment according to the customer's payment method and invoice settings. ## Customer tax settings You can customize the tax rate per customer if necessary, but be careful, a manual tax rate set on a customer will not allow Hyperline to display any legal information associated with that rate in the invoice. You can add a custom invoice note for the customer to fix this. ### Customize tax rate per customer ### Taxability per customer Each customer can be marked as **Taxable** or **Tax exempt** from the customer edit form. Use **Taxable** for the standard case where Hyperline should calculate taxes from your tax settings, customer location, tax ID, and product configuration. Use **Tax exempt** when a customer should not be charged tax, for example when you have collected and validated a tax exemption certificate outside Hyperline. Customer taxability is separate from a custom tax rate. Use taxability to decide whether tax applies at all, and custom tax rates to override the rate used for a taxable customer. ## EU VAT and tax ID validation Hyperline automatically manages VAT in the EU. For B2B customers in another EU country, the reverse charge rate can apply when the customer has a tax ID on their profile. You can add the tax ID yourself from the customer page, or ask the customer to provide it from a portal, checkout, or quote signature flow. ### Tax ID validation When a customer tax ID is added or updated, Hyperline checks its format and, for EU VAT numbers, validates it through the EU VAT Information Exchange System (VIES). EU VAT numbers are then revalidated with VIES regularly, at least once a month, so the status can change if the VAT number is updated in the official registry. The validation status appears next to the customer's **Tax ID** on the customer page. | Status | Meaning | | ------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `valid` | The tax ID has been verified and is valid. | | `invalid` | The tax ID has been checked and failed validation, for example because it has the wrong format, is not found in VIES, or belongs to an inactive VAT registration. | | `mismatch` | The tax ID is valid, but it belongs to a different country than the customer's country. | | `unverified` | The tax ID has not been verified yet. | | `unsupported` | Hyperline does not support automated verification for this tax ID type yet. | Use the **Customers** list to filter customers by tax ID status. This helps you find records with `invalid`, `mismatch`, `unverified`, or `unsupported` tax IDs so you can correct the tax ID, ask the customer to update their billing details, or decide the right follow-up action. For EU VAT numbers, Hyperline stores the VIES consultation number on the customer and on invoices that rely on that validation. This gives your finance team a reference for later checks. Tax ID validation helps you identify risky billing details, but it does not replace review by your finance, tax, or accounting team. VAT databases are not always up to date, and an otherwise valid VAT number may still require additional checks for your billing context. ## Tax enforcement options Tax enforcement is configured per invoicing entity. This lets each legal entity decide how strictly Hyperline should require and validate tax IDs before applying tax rules. To configure tax enforcement, navigate to **Settings** > **Taxes** for the relevant invoicing entity. ### Require customer tax ID Enable **Require customer tax ID** when all company customers billed by an invoicing entity must have a tax ID. When enabled, the tax ID field is treated as mandatory for company customers. Use it when your billing process requires a tax ID before invoices, quotes, or hosted-page billing details can be completed. This setting checks that a tax ID is present; it does not require the tax ID to be externally validated. To enable it, navigate to **Settings** > **Taxes** for your desired invoicing entity and toggle on **Require customer tax ID**. ### Enforce a valid tax ID for reverse charge By default, Hyperline applies the reverse charge rate as soon as a tax ID is provided on the customer's profile, without waiting for external validation. Enable **Require valid tax ID for reverse charge** when reverse charge should apply only after the customer's tax ID has the `valid` status. If the tax ID is missing, `invalid`, `mismatch`, `unverified`, or `unsupported`, Hyperline applies the standard tax rate for the customer's country instead. This setting is useful when your tax policy requires VIES validation before applying a 0% reverse charge rate. This setting is disabled by default. If VIES validation is temporarily unavailable, a tax ID may remain `unverified`; with this setting enabled, Hyperline will not apply reverse charge until validation succeeds. ## Tax mappings Tax mappings associate the tax rates used by Hyperline with the corresponding codes in your accounting software. They are configured separately for each invoicing entity. The **Tax mappings** list brings together: * Country-specific rates, including standard and reverse charge rates * Reusable custom rates, identified by the `Custom` label * The accounting code associated with each rate You can search the list by mapping name, country, rate, or code. Use the action menu on a row to manage an existing mapping. ### Create a tax mapping Go to **Settings** > **Taxes** for the relevant invoicing entity. Enter the mapping details and the code used by your accounting software, then save the mapping. When you send an invoice to connected accounting software, Hyperline associates the applicable tax mapping with its invoice lines. Custom tax mappings can also be assigned to products in your catalog for each invoicing entity. Use them when a product requires a reusable rate that differs from the country-specific rates resolved by the tax engine. # Invoice payment term Source: https://docs.hyperline.co/docs/invoices/term Set invoice payment terms in Hyperline to define how long customers have to pay and when invoices are flagged as late, with configurable defaults. Setting a payment term will mark the invoices as **late** once the delay is passed. Choose a number of days that fits your industry's standard or your company preferences. The payment term starts to run from the day the invoice is emitted to be paid. A default payment delay of **30 days** has been configured in your settings (**Settings** → **Invoicing** page), which can be changed to your preferred value. This payment delay is applied to all your customers. #### Customization per customer In the Advanced section, you can enter the custom payment term negotiated with your customer. This setting can be updated afterward using the 'Edit customer' action and will impact every invoice created afterward. ## Grace period For invoices with usage-based products, Hyperline uses a grace period - defined by a number of days - to **leave invoices open** before being sent to payment. This period allows you to review the invoices before they are finalised. At the end of this period, invoices are automatically sent for payment. The default duration is 3 days, but this can be configured on the **Settings** → **Invoicing** page. #### Behavior during the period During this period, newly ingested events for the invoice billing period are considered and invoices are regularly updated, so they have the latest accurate usage data. Invoices in grace period don't have a unique number (not part of the sequential numbering), this number is generated when the invoice is finalized/ready to be paid. When the invoice leaves the grace period and is ready to be paid, a webhook `invoice.ready` message is sent. You can check more details about webhooks in the [webhooks page](../../api-reference/docs/webhooks). # Payment orchestration Source: https://docs.hyperline.co/docs/payments/orchestration Connect Stripe, Adyen, GoCardless, and other PSPs in one click — Hyperline orchestrates payment processing, customer sync, and reconciliation. Hyperline natively supports major Payment Service Providers (PSPs). This means that using these services won't require any technical work from you: simply connect your account in one click and let Hyperline orchestrate it without extra work on your side. ## Orchestration Once connected, Hyperline automatically creates or updates customers and their associated information on the relevant payment providers as needed. Payment method collection forms—such as credit card inputs or Direct Debit mandates—are directly embedded within Hyperline flows, hosted pages, and frontend components. This requires no additional technical effort on your part. Payments are automatically triggered using the customer's payment method when appropriate. All related flows—such as retries, refunds, and chargebacks—are natively managed by Hyperline, so you don't need to handle them manually. By using Hyperline, you eliminate the technical complexity of integrating with a payment provider yourself. We abstract that layer for you. As a bonus, switching between payment providers becomes seamless, since your application is no longer tightly coupled to any specific one. ## Import Hyperline allows you to connect your existing payment provider account and seamlessly migrate to our platform. We provide built-in mechanisms to import your customers and their associated payment methods, so you can get started without asking your customers to re-enter their payment details. If you're interested in onboarding with an existing setup, please contact our support team—we'll guide you through the process. ## Multi-providers Hyperline lets you connect multiple payment providers at the same time, giving you the flexibility to distribute payment method usage across providers based on cost, geography, or preferred features. For example, you can route card payments through Stripe while using Mollie for SEPA Direct Debit, allowing you to take advantage of the best rates or capabilities each provider offers. You can also connect multiple accounts from the same provider, enabling more granular control over your payment routing strategy. # Handling payment errors Source: https://docs.hyperline.co/docs/payments/payment-errors Diagnose and resolve failed Hyperline payments: understand decline reasons, retry logic, and how to recover unpaid invoices for customers. ## Payments in Hyperline In most cases, Hyperline manages payment collection and reconciliation for you. But sometimes, payments can fail for a variety of reasons, resulting in unpaid invoices. When an invoice is issued and ready to be paid, Hyperline will attempt to charge the active payment method of the customer by initiating a payment. This is the basic use case for Credit Cards and Direct Debit. The payment method should have been previously added by the customer through checkout or portal page. Note that if the customer pays by bank transfer, we send the invoice to be paid by email and the reconciliation needs to be done manually on Hyperline (learn how to proceed on this page). If you connected a PSP, no action is required on your part. ## Errors and retry In certain situations, payment can fail (payment method expired, payment declined, processing issue on the bank side, etc.). For the relevant cases, we will attempt to retry the payment with the following schedule: * 2 hours after the first attempt * 12 hours after the second attempt * 24 hours after the third attempt For each attempt, a new transaction is created for the invoice. If all the attempts fail, we will mark the invoice as "error". Retryable errors include: * **Insufficient funds**: The payment method doesn't have enough funds to complete the transaction * **Declined payments**: The payment was declined by the card issuer or bank for various reasons (including cards reported as lost or stolen, reaching the limit available on the method, payment method on a known block list, security violations, banking service unavailability, etc.) Other error types like expired or invalid payment methods will not be retried automatically and require customer action to resolve. When a customer has multiple invoices in error and adds an automated payment method (credit card, direct debit), all previous invoices will be charged immediately. This state corresponds to the `error` status on the invoice API, and to the `invoice.errored` webhook message. ### Custom payment retry Retry schedule can be customized in Settings > Payments > Payment retry. You can add or remove attempts and adjust the delay between them. You can also disable payment retries entirely if you prefer to manually retry failed payments. ## Subscription error Additionally, if the invoice is related to a running subscription, we will switch the subscription to an "Error" state. This behavior can be disabled in Settings > Subscriptions, letting subscriptions remain active even if some invoices failed to be paid. If the subscription invoice is flagged as errored, we will consider the related subscription as **inactive** (as the customer failed to pay you) meaning that we won't invoice the customer in the future or collect payment. Invoices in `Open` state will stay in this state for as long as the subscription is paused. **This behaves as a paused subscription**. In this case, we offer you the choice to **manually re-activate the subscription** (the invoice will remain unpaid) or **fully cancel it**. This state corresponds to the `errored` status on the subscription API, and to the `subscription.errored` webhook message. This state can be used to switch off the access to your product or move your customer to a free product access. ## Manual retry If you wish to manually retry the payment of an invoice with a failed transaction, click **Charge invoice** in the invoice actions dropdown. If the new payment is successful, the invoice will now be paid and the subscription will automatically switch back to the live state if the customer is still in the period of the subscription. This will correspond to an `active` status on the subscription API, and to a `subscription.activated` webhook message. ## Customer notification If your customer can resolve the problem themselves — for example, their card expired or was declined and needs to be replaced, or they have insufficient funds — Hyperline emails them with a link to their dedicated portal page, where they can update their payment details. ## Error types You can retrieve on the invoice the related transactions with the following `error_type` if the status is `failed`: * `authentication_required`: The card was declined as the transaction requires authentication (e.g. 3-D Secure). The customer should go to their portal page and authenticate their card. If the error happened on an already authenticated transaction, the customer needs to contact their card issuer for more information. * `payment_method_authorization_error`: A transaction authorization cannot be created for a variety of reasons such as the card issuer couldn't be reached, or the card requires a PIN. * `payment_method_declined`: The payment method was declined for a variety of reasons such as a card reported as lost or stolen, insufficient funds or reaching the limit available on the method to complete the purchase, a payment method on a known block list, etc. * `payment_method_expired`: The payment method is expired. The customer should go to their portal page and change their payment method. * `payment_method_invalid`: The payment method is invalid in most cases because of incorrect details (card/account number, CVC, expiration date, postal code). * `payment_method_not_supported`: The payment method doesn't support this type of purchase (e.g. currency, online payment). * `declined`: The payment was declined for a variety of reasons such as security violation, banking service not available, transaction not allowed, etc. * `fraud`: The payment provider suspected the transaction was fraudulent and has been blocked. Don't report more detailed information to your customer, and check on your provider account. * `processing_error`: The payment couldn't be processed by the issuer for an unknown reason. * `provider_error`: An error occurred when contacting the payment provider to initiate the transaction. * `unknown`: A generic error happened on the payment provider side. ### Be notified of an errored invoice/subscription for a customer If, as the merchant, you want to be notified when one of the invoices for your customer enters an error state because of a failed payment, you can implement multiple strategies. You can set up a handler on the `invoice.errored` or `subscription.errored` message. See more details on using the [webhooks page](../../api-reference/docs/webhooks). You can also **leverage a no-code solution** with our native [Zapier app](../../integrations/zapier) to connect the tool of your choice and trigger internal action on your side: notify a Slack channel, change state in one of your internal tools, email a specific team, etc. # Payment methods Source: https://docs.hyperline.co/docs/payments/payment-methods Browse Hyperline-supported payment methods: credit cards, SEPA and ACH direct debit, bank transfers, Apple Pay, Google Pay, and more by country. Hyperline supports out of the box a variety of payment methods, giving you the flexibility to propose different options to your customers. The available payment methods on your account mainly depend on your country of incorporation and your connected Payment Service Provider (PSP). * **Credit & Debit cards**: Visa, Mastercard and American Express * **Direct Debit**: * **SEPA** Direct Debit for customers in the Single Euro Payments Area * **ACH** Direct Debit (for customers with a bank account in the US & in USD) * **Bacs** Direct Debit (for customers with a bank account in the UK & in Pounds) * **Bank transfers**: direct bank transfers from your customers to your bank account * **Apple Pay** and **Google Pay** In **Settings** > **Payment**, you can connect the PSP you want to use and select the payment methods you want to enable on your account. If you use invoicing entities, you can configure the bank account shown on bank transfer invoices for each entity. You can use one account for all invoices or [assign bank accounts by invoice currency, customer country, or customer segment](../account/invoicing-entities#configure-bank-accounts-for-bank-transfers). ## Payment service provider Hyperline natively supports major Payment Service Providers (PSPs). This means that using these services won't require any technical work from you, and your PSP account will be fully orchestrated by Hyperline without extra work on your side. | PSP | Supported payment methods | | ---------- | ---------------------------------------------------------------- | | Stripe | Card, SEPA Direct Debit, ACH Direct Debit, Apple Pay, Google Pay | | Mollie | Card, SEPA Direct Debit, SEPA Transfer | | GoCardless | SEPA Direct Debit, Bacs Direct Debit, ACH Direct Debit | | Airwallex | Card, SEPA Direct Debit, Bacs Direct Debit, ACH Direct Debit | | Adyen | Card, SEPA Direct Debit, Bacs Direct Debit | ### Configure Apple Pay and Google Pay To use Apple Pay and Google Pay, you must first enable them and register specific web domains in your payment service provider (PSP) account. These payment methods require domain verification in order to function properly when embedded in web pages. To complete this step, register the domain `hyperline.co` in your PSP account. If you've configured a custom domain on Hyperline for your hosted pages, you must register that domain as well. More details in the [Stripe documentation](https://stripe.com/docs/apple-pay/web#register-your-domain). ## Customer payment methods Hyperline gives you **fine-grained control over which payment methods are available to each customer**. This allows you to tailor the payment experience and **restrict certain methods** based on customer-specific needs or preferences. The enabled payment methods are displayed to the customer on their [**portal page**](../customers/portal) or when using [**embedded components**](../../api-reference/docs/react-components). You can configure this in two ways: * Via the **Settings** modal under the **Payment Methods** section on the customer's page. * While assigning a subscription to a customer, by selecting the allowed payment methods for the customer. You can optionally configure a **default payment method** for each customer—choosing between a saved payment method, **bank transfer**, or **Outside of Hyperline**. If no default is set, Hyperline will automatically use the **first payment method** provided by the customer. ## Manage payments outside of Hyperline If you prefer not to use Hyperline's built-in payment capabilities, you can manage payments **entirely outside of the system**. This is particularly useful if you already operate a complex banking infrastructure or act as your own payment processor. In this case, there's no need to connect a payment service provider (PSP). You can configure the customer's payment method as **"Outside of Hyperline"**, which: * Disables all payment-related logic in billing flows * Removes payment method sections from the **hosted pages** (checkout, quote, invoice) and **customer portal** This approach gives you full control over payment collection while still benefiting from Hyperline's billing and subscription management features. # Payout reconciliation Source: https://docs.hyperline.co/docs/payments/payouts Reconcile payment service provider payouts against bank account transactions in Hyperline, with grouped payment matching and finance overviews. Payout reconciliation helps you understand how money received in your bank account maps back to the payment transactions processed through a Payment Service Provider (PSP). When Hyperline detects a provider payout on a connected bank account transaction, it groups the matching payment transactions and displays the payout directly in the **Transactions** section. This gives finance teams a clear view of the gross amount collected, provider fees, and net amount included in the payout. Payout reconciliation is currently available for automatic Stripe payouts paid into a connected bank account. ## Before you start To use payout reconciliation, make sure that: * Your Stripe account is connected in **Settings** > **Payment** * The bank account receiving Stripe payouts is connected to Hyperline * Bank account transaction synchronization is active * The related Hyperline payment transactions are settled If you still need to connect a bank account, see [Reconciliation](../invoices/reconciliations#connected-bank-account). ## How Hyperline matches payouts After each bank transaction refresh, Hyperline looks for incoming bank transactions that can represent a provider payout. For Stripe payouts, Hyperline matches a bank transaction when: * The transaction is posted and incoming * The bank transaction label identifies Stripe * The amount and currency match one automatic Stripe payout * The Stripe payout arrival date is close to the bank transaction date * The payout contains settled payment transactions already recorded in Hyperline If several Stripe payouts could match the same bank transaction, Hyperline does not attach one automatically. This avoids linking the bank movement to the wrong provider payout. ## Review payouts Go to **Transactions** > **Connected Bank Accounts** to review bank account activity. Rows matched to a provider payout show a provider payout tag, such as **Stripe payout**, instead of the raw bank transaction label. Hover over the tag to see: * The original bank transaction description * The number of matched transactions * The payout arrival date Click the row to open the transaction drawer. The payout section shows: | Field | Description | | ----------------- | ------------------------------------------------------------------- | | **Provider** | The payment provider that issued the payout | | **Payout ID** | The provider payout identifier | | **Arrival date** | The payout arrival date reported by the provider | | **Matched at** | When Hyperline matched the bank transaction to the payout | | **Payout amount** | The total payout amount received from the provider | | **Provider fees** | The total fees included in the matched payout lines | | **Net included** | The total net amount included in the matched payout lines | | **Transactions** | The number of Hyperline payment transactions included in the payout | The side panel lists the matched transactions. Use it to confirm which customer payments and refunds are included in the payout before exporting or reconciling the bank movement in your finance workflow. ## What to do when a payout is missing If an expected payout does not appear as matched: * Check that the destination bank account is connected and syncing successfully * Confirm that the payout is an automatic Stripe payout * Confirm that the payout amount and currency match the bank transaction * Wait for the next bank transaction refresh if the payout has just arrived * Check whether the bank transaction is already linked to an invoice reconciliation If a payout still does not match, reach out via the in-app chat with the bank transaction date, amount, currency, and provider payout ID. ## Related pages * [Payment orchestration](./orchestration) * [Payment methods](./payment-methods) * [Invoice reconciliation](../invoices/reconciliations) # Scheduled transactions Source: https://docs.hyperline.co/docs/payments/scheduled-transactions Schedule future Hyperline transactions on a chosen payment method and date — useful for installments or splitting an invoice across methods. Hyperline allows you to schedule a transaction with a specific payment method at a custom future date, for a custom amount. This is particularly helpful to create payment installments for customers who wish to pay the invoice in multiple installments. Scheduling a transaction can be done on all allowed payment methods for a customer, enabling multiple methods for the same invoice to be used. ## Schedule a transaction It can be accessed while creating a new invoice, editing an invoice or by clicking on "schedule transactions" in the transactions section. Transactions can only be scheduled on draft, to pay and partially paid invoices. ## Edit a transaction All transactions can be edited after they have been created but before they are executed, as long as they are in a `scheduled` status. All transactions with a manual payment method (bank transfer, outside of Hyperline) can be edited afterwards without any limitations. ## Execute transactions Transactions with automated payment methods are processed at **the beginning of each hour**, after the scheduled process date has passed. # Price books Source: https://docs.hyperline.co/docs/price-books/overview Extend the Hyperline product catalog with price books, giving specific roles or customers tailored pricing on quotes and subscriptions. ## What is a price book? A price book extends the prices in your product catalog. It can be created for specific user roles or all users within your organisation, allowing fine-grained control over product pricing. Users with access to a price book can assign it to a customer or select it when choosing a price for a product they're adding to a quote or subscription. ## Create a price book To create a price book, go to the [products section](https://app.hyperline.co/app/products) of the Hyperline interface. From there, you will see a dropdown with "Default catalog". Click on it and select "New price book". Fill in the details of the price book and the user roles who can access it. ## Add and manage prices in a price book Once your products are added, they will be prefilled with the existing prices from your main catalog. Note that you can only edit the prices from the price book section. The rest of the product information is for reference only. ## Assign a price book to a customer If a customer is assigned a specific price book, its prices will be used by default when creating a subscription or quote for them. ## Apply a given price book when assigning a subscription or a quote When creating a subscription or a quote, you can choose which price book to use. If a price book is already set for the customer, it will be selected by default. You will see the price book used for the product in the subscription details. # Products and prices Source: https://docs.hyperline.co/docs/products/overview Manage your product catalog in Hyperline: define products, pricing models, currencies, intervals, and reusable price configurations for billing. In Hyperline, a product represents anything you sell to your customers. This can be a software, a capability, a service, etc. These products are managed in a **products catalog**, an interface allowing you to have a complete overview of your offering and manage in a single place the associated and reusable prices based on various parameters (currency, location, market, interval, duration, etc). Setting up products enables the creation of pre-configured plans, subscriptions, or one-time payments for your customers. Products can also grant [features and entitlements](../entitlements/overview), such as access to an integration, included seats, or a usage limit. Use product entitlements when a billed product should also define what the customer can access. ## Accounting mappings Use the product **Accounting** section to map a product to the external accounting record used by your accounting integration. These mappings are used when Hyperline sends invoice lines to connected accounting providers. Depending on the connected provider, you can configure: | Field | What it controls | | ---------------- | -------------------------------------------------------------------------------------------------------------- | | **Product code** | The product, item, or service identifier sent to the accounting provider for invoice lines using this product. | | **Account code** | The GL account code used by integrations that read account codes directly from the product. | ### Bulk update accounting mappings When you need to update several products at once, use the product catalog bulk action instead of opening each product individually: 1. Go to **Catalog** > **Products**. 2. Select the products you want to update. 3. Click **Bulk update**. 4. Update the accounting fields, such as **Product code** or **Account code**. 5. Click **Save**. Map products before running a first invoice sync. Missing product mappings can stop synchronization until the affected products are corrected and retried. ## Types of product Hyperline enables you to represent a variety of products for sale by leveraging four product categories. ### Fee A "flat fee product" refers to a product or service for which the cost is a **fixed**, **consistent charge**. It means that the customer or client pays a predetermined, flat fee, regardless of usage, quantity, or time duration. This contrasts with usage periods where the cost may fluctuate based on factors like usage, consumption, or time. This product can be used for **subscription fees**, **fixed-rate services**, **addon items**, or **additional fixed costs**. This provides predictability for your customer, as they know exactly how much they will pay without unexpected variations in costs. For example, this product can be used to bill a fixed platform access to a software, or an onboarding fee. This type of product can be: * included in subscriptions using the **Allow product to be added to a subscription** option * billed separately using the **Allow this product to be charged as a one-time payment** option **Pricing model** This product supports [flat fee](#flat-fee) prices. ### Seat A "seat product" refers to a type of licensing where the cost of a software application or service is based on a number of items also named "seats" (users, accesses, licenses, etc). This kind of product allows scalability, where customers can add or remove seats as needed, making it flexible for businesses with changing requirements. For example, this product can be used to bill a specific number of user licenses. Each license allowing one person to use a software or service. This type of product can be included in subscriptions with the ability to link to product data for automatic adjustment of billable items or manual configuration. Seat products also support **connected seats**, where the seat count is automatically tracked via an [aggregator](/docs/usage/aggregators) (count operation). This enables automated metering with background updates and customized payment terms, such as yearly pro-rated charges based on peak user counts. Learn more about connected seats in our [Automated seat-based billing](/docs/subscriptions/connected-seats) guide. **Pricing models** This product supports [volume](#volume), [bulk](#bulk), and [bundle](#bundle) prices. ### Usage A "usage-based product" refers to a type of product where the cost is directly tied to how much your customer uses or consumes the product. In this model, customers are typically charged based on their actual usage, rather than a flat fee. This kind of product offers flexibility, allowing customers to pay for what they actually use with a cost varying with the amount or extent of usage. It enables a "pay-as-you-go" or "pay-per-use" model where customers are billed periodically based on their usage during that period. For example, this product can be used to bill data transfer in gigabytes, cloud computing in CPU hours, or the number of API calls in a SaaS product. This type of product is related to usage data measured using `events` representing specific occurrences or happenings that need to be billed during a specific period. Detailed usage reports are also provided, making billing transparent and providing clarity on how charges are calculated. **Pricing models** This product supports [volume](#volume), [bulk](#bulk), and [basis points (BPS)](#basis-points-bps) prices. #### Metering configuration A usage-based product must be linked to an [aggregator](/docs/usage/aggregators) that defines how events are transformed into a billable metric. Aggregators support two operations: **count** (number of events) and **sum** (total of a numeric property). Additional filters can be configured on the aggregator to narrow down eligible events based on custom fields (strings, numbers, or booleans) from your system. **Price metering filters** In addition to configuring metering for the product, you can set metering filters for each price. This allows you to define pricing based on specific criteria, enabling complex pricing matrices and price points based on specific usage parameters and values. For example, if you offer cloud computing services, you can apply different prices based on compute instance type or region. Similarly, if you process banking transactions, you can apply specific fees depending on the scheme or card configuration. ### Credit A "credit product" represents a granted quota that customers can pay for upfront and consume over time. Each customer has a **single shared balance** that is automatically debited as eligible usage events come in — so credits act as a prepaid layer on top of your usage data. This kind of product is useful when you want to decouple purchase from consumption: customers buy a quantity of credits, and any combination of metered actions draws from the same balance until it is exhausted or topped up. For example, this product can be used to bill AI inference time, where 1 GPT-4 request consumes 5 credits, 1 GPT-3 request consumes 1 credit, and 1 image generation consumes 10 credits — all from the same balance. A credit product is linked to one or more [aggregators](/docs/usage/aggregators), each with a **weight** that defines how many credits one unit of usage consumes. All aggregators draw from the same balance. **Pricing models** This product supports [volume](#volume), [bulk](#bulk), and [bundle](#bundle-1) prices: * **Volume** applies progressive prices across quantity tiers. * **Bulk** uses the tier reached by the total quantity to price all credits. * **Bundle** offers predefined quantity and price combinations. When you add the product to a plan or subscription, Hyperline uses the assigned credit quantity and the selected catalog price to calculate the amount. The resulting amount is stored as a fixed fee on the subscription while retaining its catalog pricing context. For the full setup flow, customer-level balance management, expiration rules, and auto-topup, see [Set up credits on your account](/docs/credits/overview). ### Bundle A "bundle product" groups several existing products into a single offering, sold to your customers as one logical unit. This is useful when you want to package complementary products together — for example, a base subscription combined with a quota of API calls and a number of seats — and bill them as a single item. Don't confuse a **bundle product** (a product *type*, described here) with **bundle pricing** (a *pricing model*, described [below](#bundle-1)). A bundle product wraps multiple products together; bundle pricing offers predefined quantity/price packages on a single product. The two are independent and can be used separately. **Components and revenue allocation** A bundle is composed of one or more **components**, each pointing to an existing product in your catalog (any type — fee, seat, or usage). Each component carries a **percentage** that defines how the bundle's revenue is allocated to that product. The percentages of all components must sum to 100%. This allocation drives revenue recognition (each component's share is recognised against the underlying product) and, when configured, the per-line breakdown shown to your customers on the invoice. **Display mode** Bundles support two display modes that control how they appear on invoices: * **Single line** — the bundle is shown as one line item on the invoice. The component breakdown is tracked internally for reporting and accounting, but the customer only sees the bundle as a whole. * **Ventilated** — each component is shown as its own line item on the invoice, with amounts split according to the configured percentages. Use this when your customers expect to see exactly what is included in the bundle and at which value. **Exclusive components** Bundles offer an option to mark their components as **exclusive to the bundle**. When enabled, the underlying products can only be sold as part of this bundle and won't appear on their own in quotes or subscriptions. Disable this option if you also want to sell the same products independently outside of the bundle. **Pricing models** This product supports [volume](#volume), [bulk](#bulk), [packaged](#packaged), and [bundle](#bundle-1) prices. *** ## Pricing models Products in Hyperline support a variety of pricing models: **flat fee** pricing, **volume** pricing, **bulk** pricing, **bundle** pricing, and **basis points (BPS)** pricing. ### Parameters Each product can also contain multiple prices (of different models) depending on different parameters: **currency**, **country**, **interval**, and **commitment** period. This enables you to represent all the cases you propose with fine granularity, depending on the specific characteristics of the markets you operate in, or how you wish to adjust pricing based on your customers' engagement with your service. In the example above, the product costs 200€ per month except for UK customers where it's 220£ per month, or 2200€ per year except for customers committed 2 years where the price is reduced to 2000€ per year. The more specific or narrowed parameter values (such as a specific country or a specific commitment period) take precedence over the broader values (such as "all"). ### Flat fee Predetermined, fixed and unchanging price. ### Volume Cost per unit or item is adjusted proportionally to the quantity of items purchased or consumed. Usually, the more a customer buys, the lower the cost per unit becomes. Volume pricing often involves multiple price tiers, which can be used to change the price depending on certain volume thresholds. In the example above, the customer is billed 50€ per unit between 0 and 10 then 40€ per unit between 10 and 50, then 20€ per unit, so 2360€ for 63 units. We offer you a preview of the price evolution depending on the quantity which can help you have an overview of the trend a price can have; and a preview of the rendering of the price for your customer (e.g. on their checkout page). #### Pay tier in full The "Pay tier in full" option can be activated on a per-tier basis. This option allows you to charge the full price of the tier (i.e. `price per unit` `⨉` `to` value) if the consumption is contained in this tier range. In the example above, the customer is billed 250€ for this product between 0 and 5 units regardless of their consumption, then a progressive price for higher levels (e.g. 370€ for 9 units). ### Packaged As per a volume pricing, a packaged pricing is adjusted proportionally to the quantity of items purchased or consumed, usually involving multiple price tiers. The difference is that you can define packages of units, allowing you to define a price for a quantity of items inside a specific tier. In the example above, the customer is billed 6€ per 20 units if less than or equal to 200, then 4€ per 20 units if more than 200 (e.g. so 100€ for 400 units). ### Bulk The total number of units determines the tier used and therefore the cost of all units. Reaching a higher tier value will decrease the price per unit. In the example above, the customer is billed 50€ per unit if less than or equal to 10 or 30€ per unit if more than 10, so 1020€ for 34 units. As with volume pricing, the "Pay tier in full" is also available, and we offer an overview of the price evolution and final rendering on the customer's checkout page. ### Bundle Bundle pricing allows you to configure predefined bundles with specific quantity/price combinations. This model is particularly useful for seat-based products where you want to offer only specific package options to customers. With bundle pricing, customers can only select from the predefined bundles you configure when creating quotes and subscriptions, rather than choosing any arbitrary quantity. A software company offers user licenses in predefined bundles: 5 seats for $100, 10 seats for $180, or 25 seats for \$400. Customers must choose one of these exact bundles rather than selecting a custom number of seats. This pricing model is also used for credit products, where you can define packages of credits at fixed prices (e.g., 1000 credits for $50, 5000 credits for $200). ### Basis points (BPS) Method used to calculate prices based on a given percentage applied on the number of items considered in the computation (i.e. usage billed for the period). Tiers can be defined to vary this percentage. As with volume pricing, the "Pay tier in full" is also available, and we offer an overview of the price evolution and final rendering on the customer's checkout page. ## Translating product names If you have an international audience, it's important to have your products correctly translated on invoices and hosted pages. On the product page, you can add translations for the name and the public description by clicking on the globe icon. Once saved, we will update the portal, checkout and new invoices will use the translations when appropriate. ### Hosted pages rules On hosted pages, the translations being used are, by order of priority: * Customer's browser language (if the customer has defined Italian as their primary language, that's what we will use) * Customer's language set on Hyperline * Customer's country (if the customer's address is in Italy, we'll use Italian translations) * English * Default product name # Custom properties Source: https://docs.hyperline.co/docs/properties/overview Define custom properties in Hyperline to store extra data on customers, products, subscriptions, and invoices, and use them across templates. Flexibility and customization are key aspects we aim to provide in Hyperline. To achieve this, we allow you to define custom properties so that you can represent and store all the extra data you need. Custom properties can be defined and associated with **customer**, **product**, **subscription**, and **invoice** entities. Subscription custom properties can also be used in subscription templates. Furthermore, values are structured with a range of types including **text, number, boolean, date, and a select list** of predefined values. ### Use cases Custom properties provide a wide range of possibilities. For example, they can be used to represent additional fields for your customers, integrate extra billing details into your subscriptions or subscription templates, assist in entitlement and feature flagging by representing features activatable on specific products or subscriptions. These are just examples, and they can be customized to meet any specific needs based on your use case. ## Create a custom property You will be asked to enter a name, a slug (a unique identifier mainly used for technical integration using the API), the property type, and the entities on which the custom property will be available. Additionally, you can decide to activate this custom property only for technical purposes, meaning that it won't be editable in Hyperline's interface but will only be available through the API. When this option is untoggled, the field is both editable in the interface and the API. ## Managing custom property values When created, the custom property can be found on the related entity in the interface. On the **customer**, the custom properties appear at the bottom of the information panel on the customer details page. For **products**, they will appear in a dedicated box on the product in the 'Advanced settings' section. For **subscriptions**, you can set the value in the second step of the subscription assignment flow. The same subscription custom properties are available when configuring a subscription template. For **invoices**, you can set the values from the invoice details when creating or editing an invoice. When an invoice is generated from a subscription, Hyperline automatically copies the subscription's custom property values to the invoice when the same custom property is available on both entities. You can still edit the invoice value afterward when the invoice can be updated. Automatic copying only applies to custom properties that are available on both the **subscription** and **invoice** entities. ## Filtering by custom properties You can filter customers, subscriptions, and invoices by their custom property values in the respective list views. When you create custom properties for customers, subscriptions, or invoices, filter controls automatically appear in the filters dropdown on the **Customers**, **Subscriptions**, and **Invoices** pages. The filter type depends on the custom property type: * **Boolean properties**: Display as a dropdown with **On** and **Off** options * **Select properties**: Display as a dropdown with the predefined values you configured To filter by custom properties: 1. Navigate to the **Customers**, **Subscriptions**, or **Invoices** page 2. Click the filters dropdown 3. Select the custom property filter you want to apply 4. Choose the value to filter by The list will automatically update to show only records matching your selected criteria. Only boolean and select-type custom properties are available as filters. Text, number, and date properties cannot be used for filtering in the interface. Custom properties marked as "API only" will not appear in the filter panel. ## Displaying custom properties on hosted pages For now it is only available for the **customer** portal page. You can decide to select which custom properties to display on the customer portal by navigating to the **Settings** > **Hosted pages** section. ## Using the API You can [create](../../api-reference/endpoints/custom-properties/create-custom-property), [retrieve](../../api-reference/endpoints/custom-properties/list-custom-properties) and [manage](../../api-reference/endpoints/custom-properties/update-custom-property) custom properties using the API. Additionally, you can retrieve the values using the `custom_properties` field when fetching a [customer](../../api-reference/endpoints/customers/get-customer), [product](../../api-reference/endpoints/products/get-product), [subscription](../../api-reference/endpoints/subscriptions/get-subscription), or [invoice](../../api-reference/endpoints/invoices/get-invoice). You can also set invoice custom properties when you [create](../../api-reference/endpoints/invoices/create-invoice) or [update](../../api-reference/endpoints/invoices/update-invoice) an invoice through the API. Subscription template configurations use the same `custom_properties` field as subscriptions when you [create](../../api-reference/endpoints/subscriptions->-templates/create-subscription-template-configuration) or [update](../../api-reference/endpoints/subscriptions->-templates/update-subscription-template-configuration) a configuration through the API. ### How this differs from the `properties` field The `properties` field was introduced in the initial step, but it lacks structure (e.g., it is not named or typed) and is not manageable through the interface for non-technical users. While this field can still be utilized to store unstructured technical details on supported entities, we recommend using custom properties when possible to ensure safety and better manageability. # Quote approval Source: https://docs.hyperline.co/docs/quotes/approval Add multi-step approval workflows to Hyperline quotes so sales managers and finance can review and approve deals before they reach the customer. You have a large or growing sales team and want more control over the quotes being created? Hyperline allows you to add approval workflows before a quote is sent to a customer for signature. ## Approval workflows Approval workflows let you define custom rules to automatically require approval for quotes that meet specific criteria. You can configure multi-step approval processes with individual or role-based approvers, ensuring the right people review quotes before they're sent to customers. This feature is available on demand. Contact our support if you are interested. ### Configure approval workflows To set up approval workflows: 1. Go to **Settings** > **Approvals** 2. Open **Approval workflows** 3. Click **Create workflow** to add a new approval workflow 4. Configure the workflow rules and approval steps 5. Save the workflow You can create multiple approval workflows. When a quote matches multiple workflows, the one with the highest priority (lowest number) is applied. ### Rules Rules determine when a quote requires approval. You can combine multiple conditions using AND/OR logic: * **Total amount**: Trigger approval when the quote total exceeds a specific amount * **Discount amount or percentage**: Require approval for quotes with discounts above a threshold * **Products**: Trigger approval when specific products are included in the quote * **Coupons**: Require approval when certain coupons are applied * **Subscription template**: Require approval when the quote uses one of the selected subscription templates * **Trial period**: Trigger approval based on trial period duration * **Contract auto-renew**: Trigger approval based on the subscription auto-renew setting * **Contract clauses**: Require approval when specific reusable clauses are included in the quote contract terms * **Modified contract clauses**: Require approval when a reusable clause has been edited in the quote before validation * **Terms & conditions**: Require approval based on the quote contract terms * **Customer invoicing entity**: Require approval based on the invoicing entity assigned to the quote's customer * **Creator role**: Require approval based on the role of the user creating the quote * **Quote attachment**: Trigger approval based on whether an attachment is present on the quote. Via the API, this maps to the `has_attachment` field — use `eq` with `false` to require approval when no attachment is attached, or `eq` with `true` to require approval when one is You can create a workflow that requires approval when: * The total amount exceeds \$50,000 **OR** * The discount percentage is greater than 20% **OR** * A specific premium product is included **OR** * A required contract clause is included **OR** * A reusable clause has been modified Within each condition, you can use AND logic. For example, require approval when the total amount exceeds \$50,000 **AND** the discount is greater than 10%. ### Approval steps Each workflow can include one or multiple approval steps. Steps are processed sequentially—a quote must complete all steps before it's fully approved. For each step, you can configure: * **Step name**: A descriptive name for the approval step (e.g., "Sales Manager Review", "Finance Approval") * **Approvers**: Select individual team members or roles who can approve at this step * **Approval requirement**: Choose whether **all** approvers must approve or if **any** approver can complete the step * **All approvers**: Every selected approver must approve before moving to the next step * **Any approver**: Only one approval from the selected approvers is needed A three-step approval workflow for large deals: 1. **Sales Manager Review** (any sales manager can approve) 2. **Finance Approval** (any finance team member can approve) 3. **Executive Sign-off** (the CFO or CEO must approve) ### Notifications When a quote requires approval, Hyperline automatically notifies the relevant approvers: * **Email notifications**: Approvers receive an email when their approval is needed * **Delegated approver notifications**: If an approver has an active delegation, the delegated approver also receives the approval request email * **Slack notifications** (optional): You can connect a Slack channel to each approval workflow. When approval is needed at any step, a notification is sent to the configured channel with details about the quote, requester, workflow step, and approvers Configure Slack notifications in the workflow settings by selecting the channel where notifications should be sent. Learn more about [Slack integration](/integrations/slack). Quote approval request notifications can also be delivered through each user's personal notification channels. Users can manage these from **Profile** > **Notifications**, including Slack DMs when Slack is connected. Slack DMs include the quote details, the quote PDF in a thread, and actions to **Approve**, **Reject**, or **Open in Hyperline**. Learn more about [profile notifications](/docs/account/users-permissions#manage-profile-notifications). ### Workflow priority If you have multiple approval workflows, you can set their priority order. When a quote matches multiple workflows, only the workflow with the highest priority (lowest number) is applied. To adjust priority, drag and drop workflows in **Settings** > **Approvals** > **Approval workflows**. ## Approval delegations Approval delegations let an approver temporarily give another active team member the ability to approve or reject quote approval requests on their behalf. Use them when an approver is out of office or when another team member needs to cover approvals for a defined period. A delegated decision counts as a decision from the original approver, while Hyperline also records which user actually approved or rejected the request. A finance manager is away for one week and delegates approvals to another finance team member. During that week, the delegated approver receives quote approval requests, can approve or reject them, and their decisions count as the finance manager's decisions in the workflow. ### Create an approval delegation To create a delegation: 1. Go to **Settings** > **Approvals** 2. Open **Delegations** 3. Select the original approver whose approvals should be delegated 4. Select the new approver who should receive the delegated approvals 5. Choose the delegation start and end dates 6. Add a reason, if needed 7. Save the delegation Approvers can create or revoke their own delegation from the **Profile** tab on their profile page. Team members who can manage approvals can create or revoke delegations for other approvers from **Settings** > **Approvals** > **Delegations**. The original approver, new approver, and user creating the delegation must be active team members. A user cannot delegate approvals to themselves. ### How delegated approvals work During the delegation period, the delegated approver can find delegated quote approval requests with the **Need your approval** filter, alongside requests assigned to them directly. When the delegated approver approves or rejects a request: * The workflow treats the decision as coming from the original approver * Hyperline records who acted on behalf of the approver * The same **All approvers** and **Any approver** step rules still apply If a delegated approver is covering more than one approver for the same approval step, Hyperline asks them to choose which approver they are acting on behalf of before they approve or reject. ### Manage delegation periods Delegations are time-bound. A delegation only applies between its start and end dates, and you can revoke it before the end date if it is no longer needed. Keep these rules in mind: * Expired and revoked delegations no longer grant approval rights * Inactive users are excluded from delegated approval filters and notifications * An approver cannot have overlapping active delegations for the same period * Past delegated decisions remain in the approval history after a delegation expires or is revoked ## Approval process ### For quote creators When you create a quote that matches an approval workflow: 1. After validating the quote, it automatically moves to **Pending approval** status 2. You'll see which approval workflow was triggered and which step is currently active 3. You receive email notifications when: * Your quote is approved and ready to send * Your quote is rejected with a reason from the approver * An approver requests changes (quote moves to **Change requested** status) If your quote is rejected or changes are requested, you can: * Edit the quote to address the approver's feedback, then resubmit for approval * Void the quote if you decide not to proceed ### For approvers When a quote requires your approval: 1. You receive an email notification (and a Slack notification if configured) 2. Access the quote from the email or Slack link, or find it using the **Need your approval** filter in the quotes list. This filter also includes requests delegated to you. 3. Review the quote details 4. Click **Approve** or **Reject**: * **Approve**: The quote moves to the next approval step (or becomes approved if it's the final step) * **Reject**: You can provide a reason or comment. The quote moves to **Change requested** status, and the creator is notified If you receive a Slack approval request, you can approve or reject directly from Slack. If another approver has already acted, the Slack message updates to show the current approval state. ## Quote statuses Quotes in the approval process can have the following statuses: * **Pending approval**: The quote is waiting for approval at one or more steps * **Change requested**: An approver rejected the quote and requested changes. The quote creator must edit the quote or void it * **Approved**: All approval steps are complete. The quote can now be sent to the customer for signature You can filter quotes by these statuses in the quotes list, and use the **Need your approval** filter to quickly find quotes waiting for your review. *** ## Simple quote approval permission When the approval workflows feature (described above) is not enabled, Hyperline provides a dedicated **quote approval permission**. When a user without this permission creates and validates a quote (from the UI or a CRM), the quote moves into a **Pending approval** state and requires another user with the approval permission to approve it before it can be sent for signature. In this flow, Hyperline does **not** offer automatic notifications to users with the quote approval permission when a quote requires approval. However, you can set up dedicated notifications (email, Slack message, etc.) using external workflow tools like [Zapier](/integrations/zapier) or custom code. Hyperline provides a dedicated webhook event — `quote.approval_requested` — triggered whenever a quote is saved and requires approval. # Quote for one-off invoice Source: https://docs.hyperline.co/docs/quotes/one-off-invoice Create Hyperline quotes for one-off invoices to charge non-recurring fees, project work, or one-time setup costs that customers can sign and pay. If you wish to charge a one-off invoice to a customer, you can create a quote for it. This is ideal for one-time fees, additional charges, or any other non-recurring billing. ## Create a quote for a one-off invoice * from the [quotes page](https://app.hyperline.co/app/quoting/quotes), click `new quote` and select `Quote for one-off invoice` then select the customer You will find the familiar form for one-off invoice creation where you'll be able to pick products from your catalog and add coupons, edit the invoice period and notes. Any product from your catalog can be added to a one-off invoice. Whatever its usual pricing model, it is charged as a fixed amount (quantity × unit price). The invoice issue date is set to `quote signature` and cannot be changed. It means that the invoice will be emitted once the quote is signed. From now, the process is the same for a [new quote](./overview): * Configure owner, expiration date and required information to sign the quote * Choose to display the quote value on the document * Add a note for the customer and contract terms * Add additional documents like the updated contract On the Quote PDF, the invoice configuration will be displayed. Once the quote is saved, it will turn to the `ready to send` status. Review the quote configuration and decide to send it via email or generate a public link and send it by yourself. Note that by using the latter, the email reception and openings will not be tracked. Once the quote has been sent, it will turn to the `pending signature` status. At this stage, the quote can be edited again; note that it will turn to the `draft` status and the customer will not be able to access the link anymore until it is saved and live again by clicking on `generate public link`. Until the quote is signed, no changes can be made to the invoice. To allow updates again, you can delete the quote. During this stage, the invoice can be accessed in the quote details page. Once the quote is signed, the invoice will be emitted, in `to_pay` status and the payment is ready to be collected. The quote and invoice will be linked together. # Create and send quotes Source: https://docs.hyperline.co/docs/quotes/overview Run a full CPQ process in Hyperline: configure products, set custom prices, generate quotes for signature, and auto-activate the subscription. Hyperline provides a **complete CPQ process**, allowing salespeople to configure products, set a pre-configured or custom price and generate a quote ready for signature, facilitating internal approval process for customers. Once a quote is accepted and signed, the related subscription can be automatically activated, starting the billing and invoicing cycle without any manual actions required. ## Create new quote To create a quote, head to the **Quoting** section and click **Create quote**. A quote can be created and saved as draft to be completed later. Multiple quotes can be created for the same customer. ### Quote template Quotes can be created from an existing template, configured in the templates page. Learn more about [quote templates](./templates) on the dedicated documentation page. If you want to create a quote from scratch, select **Configure manually**. ### Name By default, the quote will be named "Quote ". You can rename it the way you want, using variables for dates and next quote number. ### Settings * **Expiration date** After this date, the customer will still be able to access the quote but won't be able to sign it. In Settings > Quoting, you can allow your customer to still sign the quote by toggling the option "allowed signature after expiration" in the signature section. * **Quote owner** The salesperson responsible for the customer and contract. This can be changed later in the process, and may affect whether the quote requires approval based on your configured approval workflows. * **Require tax ID** Require your customers to add their tax ID (VAT number for example) to enable quote signature. Validation and reverse charge enforcement are controlled from the invoicing entity's [tax settings](../invoices/tax-management#tax-enforcement-options). * **Custom properties** (if they are configured on your account) Additionally, you can require your customer to fill specific pre-configured [custom properties](../properties/overview) during the quote signature flow. This is useful for non-standard information collection, like country-specific details. * **Require payment method**, particularly useful when your customer pays by card or direct debit, as you can start invoicing and collect money directly once the quote is signed. * **Require shipping details** Request the customer to add their shipping details as a required part of the quote signature flow. ### Subscription Quotes must include a subscription in order to be sent. By clicking on add subscription, you will open the familiar subscription assignment flow: select plan, configure contract and invoicing settings, add products, customize price configurations, add coupons. See more details in the [assign subscription](../subscriptions/create) dedicated page. You can create a quote for a [one-off invoice](./one-off-invoice) or a [subscription update](./subscription-update) following a different flow. ### Quote value Every quote created must have a set value. This information can be hidden to the customer on the quote public page and PDF. Quote Value By default, the quote value is automatically calculated based on product prices, billing intervals, committed amounts, coupons, and the subscription or phase duration. You can edit this value to reflect a commercial adjustment that is not captured by the subscription configuration. For usage-based products, Hyperline includes committed amounts in the quote value. Future usage beyond the committed amount is not estimated automatically. Only coupons with a duration > 12 months are taken into account in the quote value. If needed, manually edit the quote value to reflect the discount applied by the coupon. ### Additional information These fields are rich text fields, where text can be stylized to structure information, emphasize on details and add hyperlinks. Both fields can be pre-configured in the quote template. Quote Value * **Note for customer** Freely add text that will be added to the quote header. It can be used to give contextual information to the customer ahead of signature. * **Contract terms** Contract terms will be displayed after the subscription details. It can be used to give contractual information. Additionally, pre-configured clauses can be added to the quote by selecting them in the **Add from existing clause** selector. Added clauses can also be used in [approval workflows](./approval), including when their text is modified before validation. ### Documents When creating or editing a quote, you can attach documents in the additional information section. This allows you to include custom files such as terms of use or any other relevant document. These attachments can be directly displayed on the quote public page and PDF if the option is selected. * **Accepted formats** `PDF`, `DOC`, and `DOCX`. Word documents are automatically converted to a signable PDF on upload, so they embed inline in the customer preview alongside PDFs. * **Maximum file size** 5 MB per file. * **Multiple files** You can select several files at once from the file picker, and drag documents to reorder them. The order defined here is the order shown to the customer. ### Display Information displayed on the quote can be modified easily by clicking on the display button in the bottom floating bar. They can all be configured in the quote template. For general quote settings, you can show or hide the **first invoice amount**, **quote value**, and **documents preview**. For the subscription preview, you can show or hide **phase value** and **taxes**, and configure how **price tiers** are displayed. ### Custom quote layout (beta) Update the quote layout the way you want with a "what you see is what you get approach", making the quote as easy to customize as a Notion document. Reorganize blocks, change the wording for all elements and add blocks anywhere. Custom Layout Enabling the custom layout fixes the quote in the customer language. It will no longer be dynamically translated based on the browser language. By default, the option is only enabled for Hyperline admins. This can be changed in Settings > Team > Roles > Edit. ## Send quote Once finalized, the quote appears as `Ready to send`. At this stage, you can decide to: * **Send quote** by email to your customer, with a custom message in the email body. This email will be tracked, and you will be able to see every time the customer opens it. * **Generate public link** to share it with your customer in the way you prefer. After this, the quote will switch to a `Pending signature` status. Once sent, you can resend the quote by email whenever you want to remind your customer to sign it. Simply use the 'Send quote' button in the 'Actions' dropdown to resend it. ## Edit quote A quote can be edited anytime as long as it has not been signed by the customer by clicking on "edit quote" in the actions dropdown. If edited, it will disable the public quote link and put the quote back to the `Ready to send` status. ## Update expiration date You can update the quote expiration date at any time without editing the entire quote using the 'Update expiration date' action. This is useful if you need to adjust the date following a discussion with your customer or after the quote has expired. This action will not disable the existing quote public link. ## Public link Hyperline offers a hosted public page to share a quote with your customer. On this page, the customer can view the entire quote details, access PDF attachments, fill in their billing details, and add their payment method (if required). The customer can also accept and sign the quote directly from this page. See more details in the [quote signature page](./signature). # Quote signature Source: https://docs.hyperline.co/docs/quotes/signature Collect customer signatures on Hyperline quotes — basic digital signature, DocuSign, Yousign, or countersigner workflows to formalize agreements. Hyperline natively offers a module where a customer reviews and formally accepts a quote by providing their digital signature. This action confirms their agreement to the terms, conditions, and pricing outlined in the quote, allowing the service or product subscription to commence as per the specified terms. ## Basic signature This is the default signature type used. This is the simplest form of signature offered by Hyperline. The signer simply needs to enter their name and tick a box to accept the quote (and any attachments). The basic signature doesn't have probative value but is useful if you need a simple and easy-to-implement quote confirmation step. ## Electronic signature Hyperline Signature allows your customer to sign the quote with probative value. It uses a secure electronic signature solution compliant with the requirements of Regulation 910/2014 of the European Parliament and Council on electronic identification and trust services for electronic transactions in the internal market (eIDAS). The process is fully embedded into Hyperline and does not require additional configuration or implementation from you. For additional security, electronic signature requires a confirmation step with a verification code sent by email to the signer. Once signed, an audit trail document is available on your quote details page, providing proof of the legal signature's validity in case of any event such as a customer dispute. This feature is available on demand. Contact our support if you are interested. ### Yousign & DocuSign You can also use your own Yousign or DocuSign account to sign quotes. This is useful if you already have a Yousign or DocuSign account and want to use it to sign quotes. To use your own Yousign or DocuSign account, you need to connect it to your Hyperline account. 1. Go to **Settings > Integrations** 2. Click on **Yousign** or **DocuSign** 3. Follow the instructions to connect your account 4. Update the signature provider to **Yousign** or **DocuSign** on the quotes settings page For Yousign, a Scale API plan is required. ### Countersigner When using electronic signatures, you can enable a countersigner (in Settings > Quotes settings) by specifying a name and an email address—typically someone from your organization. Once configured, future quotes will be automatically countersigned with this information after the customer completes their signature. No additional manual action is required. This setting applies only to quotes created after the change. ### One-off countersigner If you need a countersigner for a single quote only, use the countersigner setting temporarily before creating that quote. 1. Go to **Settings > Quotes settings** 2. Enable **Countersigner** 3. Enter the countersigner name and email address 4. Create and send the quote that needs countersignature 5. Return to **Settings > Quotes settings** 6. Disable or remove the countersigner so future quotes use your usual signature flow Because countersigner settings apply only to quotes created after the setting is changed, this does not update quotes that already exist. Keep the setting enabled only while you create the quote that needs countersignature. Any other quote created while the setting is enabled will use the same countersigner. The countersigner feature is not yet available for DocuSign. ## External signature If you prefer to manage the signature process yourself, do not want to use the Hyperline quote public page, or want your customer to sign a file manually, Hyperline offers an option to mark an existing quote as signed manually. In this flow, Hyperline is not responsible for the signature. However, using the 'Mark as signed' action, you can flag the quote as signed and optionally upload the corresponding PDF file. # Use Hyperline CPQ with Stripe Billing Source: https://docs.hyperline.co/docs/quotes/stripe-billing Integrate Hyperline CPQ with your existing Stripe Billing setup to give sales a robust quoting workflow while keeping Stripe as the billing engine. Hyperline CPQ can be integrated with Stripe Billing to provide your sales team with a robust CPQ solution, giving your customers a seamless contractualization experience while maintaining your existing Stripe Billing setup. While **we recommend using Hyperline as your full billing platform** — to take advantage of its advanced capabilities and reduce the operational complexity and limitations of external billing solutions — this integration still allows you to create and manage quotes directly from Hyperline and your CRM. Hyperline will automatically orchestrate the related subscriptions in Stripe Billing and process customer payments through Stripe Payments. With this setup, all data and billing activity monitoring can be handled in Hyperline, fully synced with your CRM, while continuing to leverage Stripe Billing as your existing billing engine and payment gateway. ## How it works Hyperline provides powerful integrations with both Stripe and CRMs (HubSpot, Salesforce and Attio), alongside a complete CPQ solution. Quotes for new subscriptions or subscription changes (upsell, cross-sell, etc.) can be created directly from your CRM using Hyperline's built-in widget, within Hyperline's interface, or via the Hyperline API. Once a quote is approved and signed by your customer, Hyperline automatically creates or updates the subscription in Stripe Billing — with no manual intervention or additional technical effort required. Stripe Billing then manages the full billing lifecycle and payment processing. All subscription details and related invoices are automatically synced from Stripe to Hyperline in real time, allowing you to monitor billing activity directly from Hyperline. This data is also pushed to your CRM, giving your operational and revenue teams full visibility. ## Prerequisites * A Hyperline account with admin rights * A Stripe account with admin rights * CPQ and Stripe integrations enabled in Hyperline ## Setup 1. Go to the [Integrations](https://app.hyperline.co/app/settings/integrations) page in Hyperline 2. Click on "Connect" for Stripe 3. Optionally, click "Connect" for Salesforce or HubSpot Please contact our support team after completing the steps above. This process is not self-served and requires a manual operation on our side to enable the Stripe Billing orchestration logic in Hyperline CPQ. ### Import Stripe products catalog Once connected, you can import your Stripe products and coupons catalog into Hyperline. In this setup, Stripe Billing remains the source of truth for configuring your products and coupons. All this data is automatically replicated and mapped to Hyperline concepts and settings (including product and coupon details, price types, variants, tiers, multi-currency setup, etc.). 1. Go to the [Products](https://app.hyperline.co/app/settings/products) page in Hyperline 2. Click on "Import from Stripe" on the top right corner 3. Go to the [Coupons](https://app.hyperline.co/app/settings/coupons) page in Hyperline 4. Click on "Import from Stripe" on the top right corner Edits to products and coupons must be made in Stripe. Any changes will be automatically synced back to Hyperline. After the initial import, we do not recommend manually reimporting products and coupons using the import buttons. All future updates (creation, modification, archival) made in Stripe will be automatically replicated to Hyperline in real time. Hyperline listens to Stripe webhooks under the hood to keep the data in sync. #### Tax behavior By default, Hyperline only considers products/prices with "exclusive" tax behavior. All prices in Hyperline are considered excluding tax in the catalog, taxes being added at the quote/invoice level (depending on customer details). This means **some Stripe products/prices might not appear in Hyperline** because they are ignored by the system during import. Even if we strongly recommend using prices excluding taxes by default, if you are dealing with different tax behaviors in Stripe (inclusive or unspecified for example), you might need to check with our support team on the best way to handle this. #### Archive products While you can archive or delete products in Stripe, Hyperline also provides a way to archive products directly within the platform. The key difference is that archiving a product in Hyperline does not archive it in Stripe. This allows you to decouple the product status between Stripe (for your internal needs) and Hyperline. A product archived in Hyperline will no longer be visible or available when creating new quotes. 1. Go to the [Products](https://app.hyperline.co/app/settings/products) page in Hyperline 2. Click on the product you want to archive 3. Click "Actions" > "Archive" button #### Archive prices In addition, following the same logic, you can archive a specific price of a product. The product will still be available when creating new quotes, but the archived price will no longer be suggested. 1. Go to the [Products](https://app.hyperline.co/app/settings/products) page in Hyperline 2. Click on the product you want to archive 3. On the related price configuration row, click the "Archive" button ### Import Stripe customers After importing your products and coupons, Hyperline allows you to import your existing customers. With this action, Hyperline will automatically map Stripe customers within Hyperline, alongside their related payment methods. New customers and changes to existing customers in Stripe — including payment methods being added or removed — will be automatically synced to Hyperline in real time. This action is not available in the interface yet, but you can contact our support team to trigger it for you. ### Import Stripe subscriptions and invoices Using the same logic as for customers, subscription and invoice histories can be imported from Stripe. All subscription data will be mapped to Hyperline subscription, phase, subscription product and subscription coupon objects, and invoices to Hyperline invoice and line item objects. Tracking and reporting in Hyperline are available for this data, and you can also query the historical data using the Hyperline API. New subscriptions, subscription renewal details, invoice details, statuses, and PDF invoices will be automatically synced to Hyperline in real time. ## CRM widget If you've connected your CRM to Hyperline, the related customer data (quotes, subscriptions, etc.) will automatically be displayed in the CRM widget. As a consequence, you can consult Stripe subscriptions data and invoices in your CRM. [Learn more about reconciling data](#reconcile-customers-between-tools). This widget can be used in both the Account/Company and Opportunity/Deal objects in your CRM. The Contact object is also supported in HubSpot for B2C sales/use cases. In addition to displaying data, the widget allows CRM users to create quotes directly from within the CRM. Hyperline's interfaces are embedded so the full Hyperline experience is available without leaving the CRM. In this context, the CRM's CPQ and product catalog modules are not used. Hyperline delivers the complete CPQ flow and experience, surpassing the limitations, poor user experience, and lack of flexibility of built-in CRM modules, while providing more advanced capabilities and richer integrations. We suggest you follow these guides for more details: * [HubSpot card](../../integrations/hubspot.mdx) * [Salesforce component](../../integrations/salesforce.mdx) * [Attio actions](../../integrations/attio.mdx) ### Creating Hyperline customers When the widget is loaded on CRM pages, the related customer in Hyperline is looked up using the [reconciliation logic](#in-your-crm) to display the corresponding data. If no match is found, Hyperline will create a new customer. To prevent CRM users from creating a new Hyperline customer when no match is found, you can disable the "Allow creating new customer" option under your Hyperline [CRM settings](https://app.hyperline.co/app/settings/integrations). When disabled and no match is found, the widget will display a message (e.g., "*This company has no associated Hyperline customer.*") and no data or actions will be available. This is particularly useful to avoid creating duplicates in your billing system or to ensure that the External ID field in your CRM is populated before displaying the widget — and therefore before any link is created between CRM and Hyperline customers. ## Create a quote Following the setup (only the products import is required), you can start creating quotes directly from your CRM or Hyperline. We suggest you follow these guides for more details: * [Create and send quotes](./overview.mdx) * [Quote for subscription update](./subscription-update.mdx) * [Learn about quotes signature](./signature.mdx) * [Configure reusable quote templates](./templates.mdx) Once the quote is signed, Hyperline will automatically apply the related changes on the subscriptions in your Stripe account. Some advanced Hyperline quote subscription configurations are not available in this flow, as we ultimately depend on Stripe's subscription capabilities, which can be more limited and less flexible than Hyperline's built-in logic. ### Post-signature automation By default, Hyperline automatically creates or updates the related subscription in Stripe Billing once a quote is signed. This is the recommended behavior, as it keeps both platforms in sync without any manual work. For cases where you'd rather handle the Stripe subscription yourself — for example, when the deal requires a specific Stripe setup that can't be expressed through the quote, or when an existing subscription will be updated manually — you can disable this automation on a per-quote basis. When configuring a quote, open the **Post-signature automation** section and switch off **Orchestrate Stripe Billing after signature**. Once disabled: * After signature, no subscription will be created or updated in Stripe by Hyperline. * A notice is displayed on the quote to remind your team that the subscription must be set up manually in Stripe. * The rest of the CPQ flow remains unchanged: quote configuration, approval, signature, PDF, and CRM sync all keep working as usual. The toggle can be changed at any time before the quote is signed. Access to this setting is restricted by permission (Manage quote activation), so it can be reserved for admins or specific roles in your team. ### Quote for subscription update A quote for a subscription update always starts from an existing customer subscription. For subscriptions imported from Stripe into Hyperline, you can select the subscription you want to update to begin creating a quote for update. ## Manage invoices ### Payment terms When configuring a quote or a Hyperline customer, you can set payment terms in days. This setting is then passed to Stripe when Hyperline creates the related subscription, populating the "days until due" parameter when the collection method is set to "send invoice" (i.e., bank transfer payments). ### Purchase order number When configuring a subscription in a quote, you can enter a purchase order (PO) number. This number will be synced to the Stripe customer invoice settings as a custom field, so it is automatically displayed on the invoice PDF header (PO number) when the subscription is created in Stripe. ### Mark as paid Imported unpaid Stripe invoices can be marked as paid in Hyperline. On the invoice details page, click "Actions" > "Mark as paid". The invoice will then appear as paid in Hyperline and be marked as paid (paid out of band) in Stripe. ## Customer payment methods As previously mentioned, customer payment methods are imported from Stripe and displayed in Hyperline. You can configure available payment method options in the [Payment](https://app.hyperline.co/app/settings/payment) settings page in Hyperline, for both automated payment methods (card, direct debit, etc.) and bank accounts used for manual bank transfers. Customer payment methods can also be collected during the quote signature process. When creating a quote, you can select which payment method types you want your customer to use, and require method collection to sign the quote. Then on the public quote page, your customer can enter their payment method details (card details, direct debit mandate, etc.). These details are automatically stored in the related Stripe customer, and Stripe Billing will then use them to charge future invoices. ### Bank transfers You can choose for your customer to pay by bank transfer. To make this option available on quotes, first configure a bank account in Hyperline's **Payment** settings and enable it as a payment method. When creating a quote, allow only bank transfers by selecting that bank account in the customer's payment method settings (all other payment method types can be disabled). The bank account details will then be displayed directly on the quote: * If Stripe supports bank transfers for the customer (based on currency, country, etc.), the Stripe virtual bank account number assigned to the customer will be shown. * Otherwise, the bank account you configured in Hyperline will be displayed. In this scenario, Stripe's customer balance mode will be used. The bank account configured in Hyperline acts as the bank transfer payment method and fallback display. When Stripe can generate virtual bank account details for the customer, those Stripe details are displayed on the quote instead. You do not need to enable a separate Stripe virtual IBAN payment method in Hyperline. ## Switch subscriptions to Hyperline At some point, you may want to switch a subscription from Stripe Billing to Hyperline to take advantage of Hyperline's additional capabilities and features for managing the subscription lifecycle. This can be done in a single click by selecting "Actions" > "Switch to Hyperline" on the subscription details page. Hyperline also offers the option to cancel the subscription in Stripe at the same time, helping you avoid future double invoicing and duplicate subscriptions between the two platforms. ### Impact on customers With this flow, there will be no impact on your end customers: their payment methods will be imported from Stripe Payments, so they won't need to re-enter their card details or create a new direct debit mandate. Subscriptions will run in Hyperline with the exact same configuration as in Stripe Billing without service interruption. New invoices will be created and managed by Hyperline, so the only difference for end customers will be the invoice PDF layout, as it will be issued by Hyperline. We recommend proceeding with this action carefully, and only after fully configuring your Hyperline account—especially the invoicing settings. Once switched, all upcoming subscription renewals and invoices will be managed and issued by Hyperline, while Stripe will continue to serve as the payment gateway to charge the customer. Don't hesitate to [contact our support team](mailto:support@hyperline.co) for any advice or assistance. ## Reconcile customers between tools Hyperline provides a way to reconcile customers between your CRM, Hyperline, and Stripe. This is useful for ensuring that data is consistent across all tools and for avoiding duplicates. To achieve this, Hyperline customers have a dedicated External ID field, which serves as the unique identifier shared between HubSpot and Stripe. In most cases, this ID corresponds to your internal customer ID. ### In your CRM In your CRM, create a custom field named `hyperline_external_id` for HubSpot or `HyperlineExternalId__c` for Salesforce on the Company/Account object. Make sure this field is populated in your CRM records: * You can leverage workflows to automatically fill this field with data from another field or source in your CRM, or have your team input it as part of your internal processes. * If you don't have a dedicated ID, you can use the Stripe customer ID. * You can also use the Hyperline customer ID. This field value will be used to link the CRM entity to the corresponding Hyperline customer. This linkage is created the first time you interact with the Hyperline widget in the CRM. Once a CRM entity is linked to a Hyperline customer, this link will be used for future uses of the widget for that entity, regardless of the value in the External ID field. If you need to unlink or change a CRM entity attached to a Hyperline customer: in the Hyperline customer details page, click the "Edit" under the "Integrations" section, and change the CRM entity ID. ### In Stripe With the same logic, a Hyperline external ID (`hyperlineExternalId`) key in the Stripe customer metadata can be used. * If not configured: Hyperline will try to find the related Stripe customer by comparing the customer's external ID in Hyperline with the Stripe customer ID. * If configured: Hyperline will look up the related Stripe customer using the `hyperlineExternalId` metadata on the Stripe customer. This reconciliation logic is triggered only when attempting to look up a Stripe customer from a Hyperline customer for the first time Hyperline needs to create a new subscription or interact with Stripe and the customer is not yet linked to a Hyperline customer. If no match is found, Hyperline will create a new Stripe customer and store the related Hyperline external ID in the metadata. If the Stripe customer has already been imported into Hyperline (e.g., during the initial setup or after a customer was created in Stripe), the Hyperline and Stripe customers are already linked, and no reconciliation logic will be applied. ### In Hyperline The actual external ID value can be found on the Hyperline customer details page, under the Integrations section. ## Sync custom properties ### Customer custom properties Syncing customer custom properties from CRM to Stripe, or simply from Hyperline to Stripe is also supported. In Hyperline, you can create custom properties for your customers: 1. Go to the [Custom properties](https://app.hyperline.co/app/settings/custom-fields) page in Hyperline 2. Click on "Add custom property" 3. Enter a name, a slug, select a type, and select "Customers" as Enabled entities If the Company/Account object in the CRM has a custom field with the same slug, the value will be synced from the CRM to the Hyperline customer custom property each time Hyperline syncs a customer from the CRM (i.e., when the widget is used in the CRM). Hyperline customer custom properties are synced to Stripe as metadata on the Stripe customer. The custom property slug is used as the metadata key. ### Subscription custom properties If you create a custom property enabled for the “Subscriptions” entities (using the same process as for customers above), you will be able to set its value when creating a subscription or when configuring a subscription as part of a quote, including from the CRM (via the embedded Hyperline UI). When the Hyperline subscription is created in Stripe, the related custom properties are synced to Stripe as metadata on the Stripe subscription. The custom property slug is used as the metadata key. ## Dates and timezones Hyperline supports timezone-specific settings per customer, while Stripe operates exclusively in UTC. This difference can cause dates to appear shifted by one day in Stripe. For example, if a customer's timezone is set to `Europe/Paris` and a subscription is configured to start on **April 1**, Hyperline will represent this as **March 31 at 22:00 UTC** (during summer time, UTC+2). Since Stripe only works with UTC dates without timezone information, the subscription start date in Stripe will appear as **March 31** instead of April 1. This is expected behavior and does not affect billing accuracy — the subscription will still start at the correct local time for the customer. The same logic applies to all date-based fields synced to Stripe (subscription start dates, phase transitions, etc.). If date alignment in Stripe is important for your reporting or internal processes, we recommend setting all your customers' timezone to UTC in Hyperline. This ensures that dates in Hyperline and Stripe always match. Otherwise, customers with timezones ahead of UTC (e.g., Europe, Asia) may see dates shifted one day earlier in Stripe. ## Connect multiple Stripe accounts Hyperline allows you to connect multiple Stripe Billing accounts to a single Hyperline account. This is useful for organizations operating in multiple regions or managing different business units with separate Stripe accounts. In this setup, you can import products and coupons from multiple Stripe accounts into your Hyperline product catalog. Each Hyperline customer can be linked to a specific Stripe account (i.e., a single Hyperline customer may be associated with multiple Stripe accounts). When creating a quote, Hyperline filters the list of available products and coupons based on the first product selected by the user creating the quote. This first selected product determines which Stripe account will be used for the quote and for creating the subscription. ## Technical details ### Stripe subscription orchestration When a quote is signed, Hyperline automatically orchestrates the creation of subscriptions in Stripe Billing. Depending on the context, Hyperline creates either a Stripe **subscription** or a **subscription schedule** (e.g., when the subscription includes future phases or scheduled changes). All Stripe subscriptions are created in flexible mode to ensure compatibility with Stripe's newest capabilities and features. This orchestration is fully automated — no manual intervention is required. Hyperline handles the mapping of products, prices, coupons, and phases to their Stripe equivalents. ### Look up Hyperline IDs from Stripe When a subscription is created in Stripe, Hyperline automatically adds custom metadata fields to the corresponding Stripe subscription object: * `hyperlineSubscriptionId` — The Hyperline subscription ID, stored on the Stripe subscription. * `hyperlinePhaseId` — The Hyperline phase ID, stored on the Stripe subscription. * `hyperlineProductId` — The Hyperline product ID, stored on the Stripe subscription product. These metadata values can be used to look up the related Hyperline entities from a Stripe subscription using the Hyperline API. # Quote for subscription update Source: https://docs.hyperline.co/docs/quotes/subscription-update Generate a Hyperline quote to update an active subscription with customer approval — ideal for contract upsells, add-ons, and price changes. If a subscription is already active in Hyperline, you can update it with customer approval by requiring a signed quote before applying changes. This is ideal for contract upsells, adding products, or adjusting prices and quantities. ## Create a quote for subscription update To create a quote to update a subscription, the subscription must be in `active` state. You can have several open quotes for subscription update on the same subscription at once — for example, to negotiate multiple upsell scenarios in parallel or prepare a follow-up change while a first quote is still awaiting signature. There are two ways to create a quote for subscription update: * from the **quotes** page, click `new quote` and select `quote for subscription update`, then select the customer and the subscription that needs to be updated. * from the **subscription details** page, click `actions` and select `create update quote` All open quotes for subscription update on a subscription are listed on the **quotes** tab of the subscription details page, so you can review, edit or void any of them at a glance. ### Select update effective date Upon starting the update process, you will be presented with two options to select when the update will take effect. Quote Update First Step **On quote signature** The subscription start date will be set to `quote signature` meaning that the new version of this subscription will only be applied once the quote is signed. **On selected date** The subscription start date can be selected freely on a future date. Once the quote is signed, the new subscription will be in a pending state, and will automatically replace the previous one on the selected date. If the selected date is passed once the quote is signed, the subscription will automatically be activated on quote signature. #### Expiration date for scheduled updates When the update is scheduled on a selected date, the quote expiration date is capped so it cannot extend past the planned transition. The latest allowed expiration is: * the **end of the current billing period** when the transition date falls within it * the **transition date** itself when it falls after the current billing period If a scheduled subscription-update quote reaches its expiration date before being signed, Hyperline automatically voids it and cancels the pending transition. The voided quote remains visible in the quotes list for auditability, and the source subscription continues unchanged — invoicing continues normally on its existing schedule. ### Keep current configuration or start from an existing template You can decide to update the current subscription configuration, which is ideal for adding products, coupons, phases and editing transition dates, or start from an existing template, which is ideal for pre-configured upsells and downsells. Keep Configuration Select Template ### Configure your subscription Just like when creating a subscription, you can now freely edit its new configuration. * Contract * Subscription configuration * Invoicing settings * Custom properties ### Select the transition settings Decide how the transition will be handled between the two subscriptions, like when [updating a subscription](/api-reference/endpoints/subscriptions/update-subscription). This configuration can be re-configured on the quote configuration page by clicking on `revise transition`. Subscription Update Configure Transition Select whether you'd like to keep the current billing cycle or start a new one, and generate a transition invoice or not. ### Configure your quote To ensure accuracy, Hyperline highlights all subscription changes, including added or removed products, price and quantity updates, and any phase modifications. Quote Update Details Then, the process is the same for a [new quote](./overview). On the display settings, you can choose whether to show the subscription details or not, allowing you to choose between just showing the subscription diff, or the newly configured subscription. ### Send quote Once the quote is finalised, it will turn to the `ready to send` status. Review the quote configuration and decide to send it via email or generate a public link and send it by yourself. Note that by using the latter, the email reception and openings will not be tracked. ### Pending signature Once the quote has been sent, it will turn to the `pending signature` status. At this stage, the quote can be edited again; note that it will turn to the `draft` status and the customer will not be able to access the link anymore until it is saved and live again by clicking on `generate public link`. Quote Pending Update While a quote for subscription update is pending signature, the source subscription cannot be edited directly, but you can still create additional update quotes on it. All open update quotes are visible on the **quotes** tab of the subscription details page. ### Quote signed Once the quote is signed, the subscription is executed or pending the selected date. The previous version of the subscription will be overridden by the new one and changes made will be automatically applied. # Quote templates Source: https://docs.hyperline.co/docs/quotes/templates Speed up the Hyperline quoting process with reusable quote templates that pre-fill products, pricing, terms, and clauses for sales teams. To simplify the quote creation process, Hyperline offers a feature to create templates, allowing you to pre-configure a quote for it to be sent in a few clicks. As with any other concept in Hyperline, values entered in the quote template can be overridden after selecting the template in the quote creation process. Editing a quote template will not impact the draft quotes created using this template. ## Creating a template Quote templates are nested under the `quoting` folder, on the `templates` page. Add a name and optionally an internal description to make it easily identifiable for your sales team. Pre-configure the expiration delay and information required from customers to sign the quote. Quote templates can contain a pre-configured subscription template. This will generate a subscription filled with the contract, products and price configurations, coupons and invoicing settings based on the customers' country and currency. This pre-filled information can be overridden while creating the quote. More details in the [subscription templates page](../subscriptions/templates). You can add a note for the customer and contract terms, that can be pre-filled with clauses configured in settings > quoting. When sending a quote to a customer, you might want to attach a contract or your terms and conditions so they can sign both the quote and the contract simultaneously. Attachments can be: * **Added manually** on the template * **Added dynamically** based on the customers' country and language through localized attachments configured in settings > quoting. ## Using a template When creating a quote, you can select a pre-configured template or start with an empty quote by selecting `configure manually`. ## Localized attachments If your team frequently sends quotes with the same contract details, manually attaching files can become time-consuming, especially for sales teams that may struggle to select the right templates. With localized attachments, you can configure attachments to be automatically added based on the invoicing entity, country and language of the customer. Give it a descriptive name and select the invoicing entities eligible (attachments will only be available for customers linked to selected entities). Click on `new file` and choose the language and country. You can add up to **10 documents** per entry, select multiple files at once from the picker, and drag them to reorder. The documents will be automatically attached to quotes for customers matching these criteria when using a quote template with this localized attachment, in the order defined here. Each document must be in one of the following formats: `PDF`, `DOC`, `DOCX`, `PPT`, `PPTX`, or `TXT`, with a maximum size of 5 MB per file. With your localized attachment now configured, you can add it to your quote templates. Attachments will then be automatically added to quotes created using the template. ## Clauses Clauses are a lighter version of localized attachments that allows you to add dynamic text based on the invoicing entity and customer's language in the `contract terms` text field. You need the **Contracts read** permission to view and use contract clauses in the quote editor. Without this permission, the clause insertion options will not be available. Learn more about [user roles and permissions](../account/users-permissions#manage-roles). Give it a descriptive name and select the invoicing entities eligible (clauses will only be available for customers linked to selected entities). Enter content in the text area. You can add alternative versions for different languages by clicking on the **blue globe icon**. If translations are not set, the default version will be added. After configuring the clause, you can add it to your quote templates. When creating a quote using the template, the clause content will be automatically pre-filled in the contract terms field in the customer's language. You can also add a clause while creating or editing a quote from **Contract terms** by selecting **Add from existing clause**. Selecting an added clause again removes the clause text when the original text is still present. If you edit the inserted text, Hyperline keeps the quote linked to the selected clause and can identify it as a modified clause for [approval workflows](./approval). This lets you route quotes for review when standard legal language changes. ## Links and legal terms Quote notes and contract terms support Markdown formatting. To add a clickable legal link, write the label in brackets and the URL in parentheses: ```mdx theme={null} [General terms and conditions](https://www.example.com/legal/terms) ``` This displays a readable link label on the quote instead of the full URL. For more formatting options, see [Markdown text](../account/settings#markdown-text). Legal terms can be configured in two places: * **Settings** > **Quoting**, where you manage reusable clauses and default quote terms. * Quote templates, where you pre-fill the terms used by quotes created from that template. Hosted checkout legal terms are configured separately from quote templates. Keep both settings aligned if customers can sign through either flow. # Sentinel monitoring Source: https://docs.hyperline.co/docs/sentinel/overview Monitor Hyperline billing operations with Sentinel — actionable tasks for failed payments, disconnected integrations, and other revenue issues. Sentinel is Hyperline's built-in monitoring system. It continuously watches your billing operations and surfaces actionable alerts — called **tasks** — whenever something needs your attention, from failed payments to disconnected integrations. The Sentinel panel is available only to users with the **View tasks** role. Within the panel, each user only sees the tasks and entities they have permission to access, based on their role. ## How it works Sentinel runs in the background and creates a task whenever it detects an issue in one of the monitored areas (payments, invoicing, subscriptions, quotes, or integrations). Tasks are deduplicated so you see a single rolled-up alert per issue category, with a count of affected entities. Each task includes a short description, the number of affected entities (invoices, customers, subscriptions, etc.), and a link to the relevant list page so you can drill down and resolve the issue. You can filter the list using the **All**, **Critical**, **High**, and **Moderate** tabs to focus on the most pressing issues first. ### Refreshing tasks When you take an action that resolves part of a task, the task count and list of affected entities refresh automatically a few seconds later. If the count still looks out of date, you can trigger a manual refresh directly on the task. ## Monitored alerts Sentinel monitors the following alerts, grouped by category: ### Payments | Alert | Description | | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------- | | Invoice in error | A payment attempt on an invoice has failed. | | Customer with expired payment method | The saved payment method has expired. | | Customer with payment method expiring soon | The saved payment method is about to expire. | | Payment method from a different invoicing entity | The customer's payment method belongs to a different invoicing entity than the one issuing the invoice. | | Payment provider disconnected | A payment provider connection is no longer authorized. | | Bank account failed to sync | Hyperline could not refresh transactions from a connected bank account. | ### Invoicing | Alert | Description | | ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | | Invoice is late | An invoice has passed its due date without being paid. | | Invoice draft | A draft invoice is waiting to be finalized. | | Electronic invoice failed to sync | An electronic invoice could not be delivered to the tax authority. | | Customer has invalid tax ID | The tax ID on the customer record failed validation, for example because it is `invalid` or does not match the customer's country. | | Child invoice can't be grouped onto parent | A child invoice in a `Grouped` organisation-based billing setup can't be rolled up onto its parent because its invoicing entity differs from the parent's. | ### Quotes | Alert | Description | | ----------------------- | ----------------------------------------------------------------- | | Quote activation failed | A quote was accepted but could not be turned into a subscription. | ### Subscriptions | Alert | Description | | --------------------------- | --------------------------------------------------------------------- | | Subscription is errored | The subscription is in an error state and is not billing as expected. | | Subscription renewal failed | Automatic renewal of a subscription did not complete. | ### Integrations | Alert | Description | | --------------------------------- | ----------------------------------------------------------------- | | Integration disconnected | A third-party integration lost its authorization. | | Integration setup error | A newly added integration could not finish setup. | | Integration needs reconfiguration | An existing integration requires updated credentials or settings. | | Issue with integration | The integration sync produced an error. | | Data loader failed to sync | A usage data loader could not refresh data. | ## Settings Open the Sentinel settings to control which alerts are surfaced. Each alert can be individually enabled or disabled, which is useful for issues that don't apply to your setup — for example, hiding electronic invoice alerts if you don't issue them. Disabled alerts won't be created or shown in your task list. # Checkout page Source: https://docs.hyperline.co/docs/subscriptions/checkout-page Create hosted Hyperline checkout sessions where customers review pricing, enter billing details, and pay securely across multiple payment methods. When assigning a subscription or processing a one-time payment, Hyperline allows you to create a **checkout session**. This generates a shareable public page where customers can review payment details, enter billing information, select a payment method, and complete their purchase. Hyperline’s checkout pages are optimized for seamless payments and support multiple methods, including credit cards, direct debits, and bank transfers. ## Create checkout Checkout completion can serve as a **subscription** or **one-time payment** trigger, automatically generating the first invoice once completed. You can also set subscriptions to begin on a future date or require manual activation. In either case, the customer still needs to fill in their information via the checkout. When assigning the subscription, you can decide whether to generate a checkout session in the payment settings (step 2). You can **send the checkout link by email** to share it directly with your customer. By default, the email field is pre-filled with the customer’s email address, but you can customize it as needed. Once assigned, the subscription will be pending checkout completion. A customer can have multiple checkout links at the same time, for several subscriptions and one-time payments. You can find all of them at the top right of the customer page. ## Checkout lifecycle A checkout session remains available until it is completed, cancelled, or errored. Checkout sessions do not expire automatically after a fixed duration. | Status | Meaning | | ----------- | ------------------------------------------------------------------------------------- | | `opened` | The checkout link has been created and the customer can still complete it. | | `completed` | The customer completed checkout and the related subscription or payment can continue. | | `cancelled` | The checkout session was cancelled and the link should no longer be used. | | `errored` | Checkout could not be completed because an error occurred. | Because checkout sessions do not auto-expire, there is no `checkout.expired` webhook event. Use `checkout.completed` to detect successful completion, and cancel the checkout from Hyperline if the link should no longer be usable. ## Complete checkout Once on the checkout page, the customer can review their subscription details and enter their billing information. They will then be required to enter their payment details, based on the **allowed payment methods** configured on their Hyperline page. You can enable credit card, direct debit, bank transfer, or any combination of these options. ## Require tax ID at checkout If your billing process requires a tax ID, enable **Require customer tax ID** in the hosted page settings before sending the checkout link. When enabled, company customers must enter a tax ID before they can complete checkout. Use this setting when the customer's VAT number or local tax identifier is required for compliant invoicing, reverse charge handling, or internal approval. This collects the tax ID during checkout. Validation and reverse charge enforcement are controlled from the invoicing entity's [tax settings](../invoices/tax-management#tax-enforcement-options). Once the customer completes the checkout, they will receive a confirmation email verifying that their payment has been successfully processed. The emails sent for **checkout created** and **checkout completed** can be disabled in settings > emails > automated emails. # Automated seat-based billing Source: https://docs.hyperline.co/docs/subscriptions/connected-seats Automate seat-based billing in Hyperline by syncing seat counts directly from your database in real time as users, licenses, or units change. ## Concept Connected seats are an improvement over the existing [seat](/docs/products/overview#seat) product. Instead of manually entering the number of units when initiating a subscription, this data is fetched directly from your database. This is especially useful if: * You want your billing system to reflect any changes made to your product (e.g. a user adds a new license) * You want to keep track of which seat was added or removed, and when * You want to bill prorated amounts (e.g. a customer starts with 5 licenses but adds another one mid-year) ## Practical application ### How to create an automated seat-based product? Navigate to the Products Section for this. Select an existing **count** [aggregator](/docs/usage/aggregators) to track your seats. The aggregator determines which events are counted and how incoming data is factored into billing calculations. If you haven't created one yet, head to **Usage > Aggregators** to set one up first. That's it! Your seat-based product should now be marked as "**Connected seat**". ### How to configure connected seats product in subscriptions? There are four configuration parameters: **Refresh schedule**, **Charging method**, **Invoicing schedule**, and **Seat change policy.** #### Refresh schedule * **Realtime**: The `count` updates immediately when a change is detected, instantly if you're using the API, or based on the dataloader interval if you're using loaders. * **Periodic**: The `count` refreshes based on the interval entered by the user in the Refresh interval field. It's independent of the subscription billing interval but can be matched to it. * **Manual**: Users must trigger the refresh using the endpoint for a more customized experience. #### Charging method Determines how seat changes are billed when detected during the period. * **Do not charge**: Track seat counts without generating charges. * **Prorata**: Charge proportionally based on when the change occurred in the period. * **Full amount**: Charge the full period price regardless of when the change occurred. #### Invoicing schedule Controls when invoices are generated after seat changes are detected. This setting is only available when the charging method is not set to “Do not charge”. * **Immediately**: Hyperline charges (or refunds) the update as soon as it detects it, even in the middle of the period. If selected alongside the “periodic” option, it will simply invoice the customer at every “end” of period. * **With next invoice**: Hyperline adds the update amounts to the next invoice as additional lines (so if the update is realtime but invoicing is at the end of the month, we'll update the subscription count in realtime but will then add the charge to the next invoice). * **Custom**: Allows the user to set an invoicing period, for instance, if they have an annual subscription they want to update in realtime but want to charge the update every month. #### Seat change policy Determines how increases or decreases in seat count affect billing during the period. This setting is only available when the charging method is not set to “Do not charge”. * **Standard**: No special handling for seat changes during the period. * **Charge highest**: Always bill based on the highest seat count detected during the period. Useful to always commit the maximum number of seats. * **Refund decrease**: Issue a refund when the seat count decreases. Instructs Hyperline to count negative updates as refunds if they've already been paid. ### Managing seat decreases When a seat is removed (e.g., a user is deleted or a license is revoked), you need to signal this change to Hyperline. Since the API is append-only, you don't delete events directly—instead, you update them with a flag and configure the aggregator to filter them out. **Using an `active` or `archived` (or what you want) boolean:** Use a boolean flag to mark the seat as inactive: ```json theme={null} { "customer_id": "", "timestamp": "2024-03-15T10:00:00.000Z", "event_type": "users", "record": { "id": 258, "email": "user@company.com", "created_at": "2024-01-01T00:00:00.000Z", "archived": true } } ``` Then, configure the product's [aggregator](/docs/usage/aggregators) to filter out archived seats: * For a boolean field: add a filter where `archived` **equals** `false` ## Billing calculation examples Understanding how Hyperline calculates billing adjustments when seat counts change is essential for predicting your invoices. This section walks through concrete examples using a base price of **10€ per seat** with a monthly subscription running from the 1st to the 30th. Those examples do not take into account the settings: `Refund when a decrease in unit count is detected` and `Charge the highest detected value for the period`. ### End of period billing When your subscription is configured to bill at the end of the period, Hyperline calculates the final seat count and applies adjustments for any mid-period changes. With pro-rata billing, adjustments are calculated proportionally based on when the change occurred during the billing period. **Adding seats (60 → 100 seats)** You start the month with 60 seats and add 40 seats on the 15th. | Item | Calculation | Amount | | ---------------------------- | ------------------- | -------- | | Base charge | 10€ × 100 seats | 1,000€ | | Update adjustment (Jan 1–15) | -40 × 10€ × 15d/30d | -200€ | | **Total** | | **800€** | The adjustment credits back the 40 seats for the first half of the month when they weren't in use. **Removing seats (100 → 60 seats)** You start the month with 100 seats and remove 40 seats on the 15th. | Item | Calculation | Amount | | ---------------------------- | ------------------ | -------- | | Base charge | 10€ × 60 seats | 600€ | | Update adjustment (Jan 1–15) | 40 × 10€ × 15d/30d | +200€ | | **Total** | | **800€** | The adjustment charges for the 40 seats that were used during the first half of the month. With pay in full billing, seat additions are charged at full price regardless of when they were added, while removals still account for usage during the period. **Adding seats (60 → 100 seats)** You start the month with 60 seats and add 40 seats on the 15th. | Item | Calculation | Amount | | ----------------- | --------------- | ---------- | | Base charge | 10€ × 100 seats | 1,000€ | | Update adjustment | — | 0€ | | **Total** | | **1,000€** | New seats are charged at full price for the entire period, regardless of when they were added. **Removing seats (100 → 60 seats)** You start the month with 100 seats and remove 40 seats on the 15th. | Item | Calculation | Amount | | ----------------- | -------------- | ---------- | | Base charge | 10€ × 60 seats | 600€ | | Update adjustment | 40 × 10€ | +400€ | | **Total** | | **1,000€** | Removed seats are still charged at full price for the period they were active. When configured to not charge for updates, no adjustment line items are generated. * **Adding seats:** No additional charge (0€) * **Removing seats:** No refund or adjustment (0€) ### Start of period billing When your subscription is configured to bill at the start of the period, you pay upfront based on your current seat count. Adjustments for mid-period changes are applied on the following invoice. With pro-rata billing, adjustments are calculated proportionally and applied to the next invoice. **Adding seats (60 → 100 seats)** You start January with 60 seats and add 40 seats on the 15th. *Invoice on 1st January (for January period):* | Item | Calculation | Amount | | ----------- | -------------- | -------- | | Base charge | 10€ × 60 seats | 600€ | | **Total** | | **600€** | *Invoice on 1st February (for February period):* | Item | Calculation | Amount | | ----------------------------- | ------------------ | ---------- | | Base charge | 10€ × 100 seats | 1,000€ | | Update adjustment (Jan 15–30) | 40 × 10€ × 15d/30d | +200€ | | **Total** | | **1,200€** | **Total for January + February: 1,800€**\ The February invoice includes the pro-rated charge for the 40 seats added mid-January. **Removing seats (100 → 60 seats)** You start January with 100 seats and remove 40 seats on the 15th. *Invoice on 1st January (for January period):* | Item | Calculation | Amount | | ----------- | --------------- | ---------- | | Base charge | 10€ × 100 seats | 1,000€ | | **Total** | | **1,000€** | *Invoice on 1st February (for February period):* | Item | Calculation | Amount | | ----------------------------- | ------------------- | -------- | | Base charge | 10€ × 60 seats | 600€ | | Update adjustment (Jan 15–30) | -40 × 10€ × 15d/30d | -200€ | | **Total** | | **400€** | **Total for January + February: 1,400€** The February invoice includes a credit for the 40 seats removed mid-January. With pay in full billing, seat changes trigger full-price adjustments on the next invoice. **Adding seats (60 → 100 seats)** You start January with 60 seats and add 40 seats on the 15th. *Invoice on 1st January (for January period):* | Item | Calculation | Amount | | ----------- | -------------- | -------- | | Base charge | 10€ × 60 seats | 600€ | | **Total** | | **600€** | *Invoice on 1st February (for February period):* | Item | Calculation | Amount | | ---------------------------- | --------------- | ---------- | | Base charge | 10€ × 100 seats | 1,000€ | | Update adjustment (full Jan) | 40 × 10€ | +400€ | | **Total** | | **1,400€** | **Total for January + February: 2,000€** The added seats are charged at full price for the previous period. **Removing seats (100 → 60 seats)** You start January with 100 seats and remove 40 seats on the 15th. *Invoice on 1st January (for January period):* | Item | Calculation | Amount | | ----------- | --------------- | ---------- | | Base charge | 10€ × 100 seats | 1,000€ | | **Total** | | **1,000€** | *Invoice on 1st February (for February period):* | Item | Calculation | Amount | | ----------- | -------------- | -------- | | Base charge | 10€ × 60 seats | 600€ | | **Total** | | **600€** | **Total for January + February: 1,600€** A refund is applied for the removed seats from the previous period. When configured to not charge for updates, no adjustment line items are generated. * **Adding seats:** No additional charge (0€) * **Removing seats:** No refund or adjustment (0€) ## Explore consumption In the context of connected seats, consumption refers to the usage of the seat-based product. You can review this consumption in the dedicated section within the Hyperline platform. This view provides a comprehensive look at the usage of each seat-based product, allowing for better understanding and management of your billing process. You can as well review the consumption of a subscription in the subscription timeline. More detailed information can be found in the [Explore usage consumption section](/docs/usage/explore-usage-consumption). # Contract duration Source: https://docs.hyperline.co/docs/subscriptions/contracts Add a contract duration to Hyperline subscriptions to reflect contractual commitments with start and end dates, replacing the legacy commitment model. Contract duration replaces the notion of **commitment** that has been deprecated. All commitment periods have been migrated to contract duration with the settings previously set. They are working the same way, but contract duration offers more granularity by adding a contract start date. Contract duration reflects the contractual agreement that links you and your customer. As of now, contract duration is simply set for informational purposes and does not have any impact on billing (except when the subscription has `same as contract start` as start strategy, where the contract start date will dictate the subscription start date). ## Set a contract duration during subscription assignment By default, a subscription does not have a set contract duration. It can be added by toggling the option in the contract section. A default contract duration can be set in a [template](./templates) and be added by default when the template is selected when creating the subscription. Contract duration is not linked to the subscription duration. The contract duration has a start and an end date, that can be defined with relative events and absolute dates: * **Immediately** on the date the subscription will be assigned * **Checkout completion** on the date the checkout will be completed by the customer * **Quote signature** only in the context of a quote creation, on the date the quote will be signed * **Manual start** will allow the contract to be started manually at any time after subscription assignment * **Custom date** will set the start date in the past or in the future `Contract start date` can be selected as a subscription start date strategy. Once this is the case, the contract start date will affect the subscription start date and potentially the initial billing date if it is set to `same as subscription start`. Contract end date can be set in the following ways: * **After a relative duration** like 6 months, 1 year, 2 years. * **Forever** contract will end manually later, or when the subscription ends * **Custom date** a fixed date in the future When the contract end is different from forever, the contract can be `automatically renewed after the end of duration` for a relative custom amount. Once the subscription ends, the associated contract will be marked as finished. ### Contract status Depending on its start and end date, a contract can fall under the following statuses: * **Inactive** the contract has not already started * **Active** the contract has started and not ended yet * **Finished** the contract end date has passed The contract status is for informational purposes only as of now. ### Contract duration after subscription is assigned A contract duration can be associated or edited once the subscription has already been assigned by clicking on **update subscription** in the contract section. There are no restrictions in the possibilities for contract duration edition, except when the contract is active: * The contract start date cannot be less than today's date at 00:00 * The contract end date cannot be less than today's date at 00:00 # Create a subscription Source: https://docs.hyperline.co/docs/subscriptions/create Assign subscriptions to customers in Hyperline manually or via templates, with options for trials, contracts, billing cycles, and activation strategies. Creating subscriptions is a central capability in Hyperline. In this article, we will explore the various options available to assign them to your customers, from simple to more complex needs. Before starting a subscription, you must [configure the products](../products/overview) you wish to bill and, optionally, create [templates](../subscriptions/templates) to streamline the subscription assignment process, using reusable package configurations. Though products are configured at the account level, you can customize every option at the customer level, allowing you to adjust them according to specific needs on a per-case basis without impacting your overall configuration. ## Configure a subscription Configuring a subscription in Hyperline only takes a few clicks. However, we also provide the flexibility to customize subscriptions on a per-customer basis, offering you greater versatility and agility. You can also create new subscriptions from the subscription list page. In this case, you will have to select the customer. You can start a subscription either from a [pre-configured template](./templates) or configure your subscription manually from scratch. **Subscription start** * **In the past**, if you want to backport a subscription that has already started but not in Hyperline, or you want to bill a customer in arrears—any past period that's due will be billed. * **Immediately**, the default value * **In the future**, if you want to schedule a subscription for the future * **On checkout completion**, once the checkout is completed by your customer **Subscription alignment** Subscriptions follow a predictable renewal pattern based on their start date: * If a subscription begins at the standard start of a billing period (e.g., the 1st of the month for monthly plans or the 1st of the year for annual plans), it aligns automatically, and each new period starts on the same fixed date. * If a subscription starts on any other day, it renews on the same calendar day in the next period (e.g., a subscription starting on March 15th renews on April 15th for a monthly plan). In the contract configuration, we allow you to configure a **contract duration** by activating the toggle. Contract duration replaces the notion of **commitment** that has been deprecated. More information [here](../subscriptions/contracts) When adding products outside of a template, after selecting the product, you will be presented with the list of prices that are set in your product catalog. It's divided into a few sections: * **Suggested:** will list the best pricing according to various parameters of the subscription: The customer's country, their currency, the commitment duration. * **Others:** will list the rest of the prices available for the product. * **Manual configuration:** If no matches are found or you don't find the right price, you can select "Manual configuration" and you can get to the next step where you will be able to enter the price and frequency by yourself. Once the pricing configuration is selected, you can edit the product details. When editing a product configuration, it **will not impact your catalog** and only have effect on the subscription you're currently creating. This gives you the flexibility to set customer-specific pricing. You can adjust the quantity directly from the main subscription view, making it easy to customize a subscription especially when starting from a pre-configured template. You also have the ability to assign [coupons](../coupons/overview) to your subscription. These coupons can be a fixed amount in the customers' currency, or a percentage of the product price. They can apply to specific or all products. Once you selected a coupon, you will be able to select: * The **application date**: choose whether the coupon will be applied once, forever or for a custom period (referring to the period during which invoices will be generated) * The **eligible products**: choose **All products** to apply the coupon to every product, or **Specific products** to select individual products Adding a free trial allows you to start a subscription without charging the customer until a specified period has passed. In Hyperline, a free trial **creates a new phase** that duplicates the first phase, but with all products set to free. To add a free trial, the first phase must include at least one product. The free trial is set to 14 days by default. It can be ended after a **custom duration** like 14 days or 1 month, at a **fixed date** or with a **manual end**. The free trial can be terminated earlier on with `mark phase as finished`. The free trial details will appear on the checkout page if the subscription is configured to start after checkout completion. * **Initial billing date** The initial billing date is when the billing period will start. It defaults to the subscription's start date, as set in the `subscription duration` selector. If the subscription starts on a specific date, the billing date can be set to a custom day (which is always after the subscription start date). * **Align billing period to the first day of the next cycle** Toggling the option `on` will make sure that the next billing period is aligned on the first day of the next billing cycle. You can configure this option to be toggled on by default under Settings > Subscriptions. For example, the subscription will charge the first billing period from the start date (e.g., January 14, 2025) until the end of the current cycle (e.g., January 31, 2025, when the product is billed every month). From the next cycle onward, billing will follow the regular interval (e.g., monthly, from February 1, 2025, to February 28, 2025), ensuring alignment with the standard billing schedule. **Purchase order** Add a text element that will be present on the header of every invoice emitted by this subscription. **Generate draft invoices** The draft invoices feature allows you to review an invoice before it's sent. It's handy if you have to double-check what's sent to your customer, or when you're first trying out the platform. When an invoice is generated, it will be set as a draft that you can edit, finalize and then send to your customer. The customer-level [**Force draft invoices**](/docs/customers/overview#force-draft-invoices) setting overrides this option. When it is enabled on the customer, every invoice is created as a draft regardless of what is configured here. **Generate documents instead of invoices** When Hyperline generates documents instead of invoices, the documents have no legal value compared to invoices and can be used for reporting. You can choose to add VAT to the document or not and set a custom name for the document. **Do not charge subscription** The invoices will be created and the invoice will be marked as paid, however, the platform won't charge for the invoices. It's handy for adding subscriptions to your reporting when payment is handled elsewhere. ## Subscription payment After clicking on the next button **Payment settings**, you'll need to configure how you want the subscription to start and your customer to pay it. You can also configure invoicing options as an optional step. #### Payment methods In this section, you are shown the default payment method (the one that will be used for charging the invoices), and the allowed payment methods (the ones the customer can add during checkout and on their portal). You can edit the customer's default payment method and toggle on or off the allowed ones. These changes will be applied on the customer level. ##### Require payment method for activation Under **Settings > Subscriptions**, the **Require payment method** toggle (off by default) enforces that a customer has a usable payment method before a new subscription can start billing. Turn it on when you want to prevent activating subscriptions that cannot be collected on. When the setting is enabled: * **Manual assignment** — creating a new subscription assignment for a customer without an acceptable payment method is blocked. A callout appears at the top of the assignment form linking directly to the customer's payment method settings so you can add one before assigning. * **Quote signature** — if a customer signs a quote but does not have an acceptable payment method, the quote is marked as signed but subscription activation is paused. The quote surfaces a **Quote activation paused** callout, and activation resumes automatically once the customer provides an acceptable payment method. In the API, this state is exposed as `error_type: activation_missing_payment_method` on the quote. A customer is considered to have an acceptable payment method when any of the following is true: * Their default payment method type is **bank transfer**, **automated bank transfer**, or **external collection** — these are always considered satisfactory because they do not depend on a stored instrument. * Their default payment method is any other type (card, direct debit, and so on) and its state is **active**. This check only applies to **new subscription assignments**. Updates to existing subscriptions, quote creation and editing, and subscription templates are not affected. #### Checkout session Hyperline provides a hosted checkout page for your customers, allowing them to **enter their billing details** (contact information, address) and **add the payment method** they wish to use for recurring subscription payments. This page is for **single use** and is provided at the beginning of the subscription process to allow your customer to **complete the act of subscribing** to your service. The use of this page is optional, and can be disabled by toggling off **Generate checkout session** in the global settings under the Subscriptions section. Additionally, we provide you a way to add an email address so Hyperline can **automatically send the related checkout page link** to your customer, without any action from your side. #### Activation The subscription activation is now managed within the previous step, now being aligned with the subscription start strategy (quote signature, checkout completion, manually or at a set date). #### Assign the subscription When everything is set and ready to go, you can click **Assign subscription**. If the customer is going to be charged immediately, you will be reminded with a message that will prevent you from charging unintentionally. *** # Using the API If you want a deeper technical integration to start subscriptions with no manual action in the product you can use the [create subscription endpoint](../../api-reference/endpoints/subscriptions/create-subscription). ``` POST /v2/subscriptions ``` Additionally, you can retrieve the subscription's details using the [get subscription endpoint](../../api-reference/endpoints/subscriptions/get-subscription), or list all of them using the [list subscriptions endpoint](../../api-reference/endpoints/subscriptions/list-subscriptions). ### Create a subscription from a template In this example, we create a new subscription from the template `subt_7gdusOkqr5L0B8` for the customer `cus_3PYD5R2q5NFK5E`. ```sh theme={null} curl --request POST \ --url https://api.hyperline.co/v2/subscriptions \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "customer_id": "cus_3PYD5R2q5NFK5E", "template_id": "subt_7gdusOkqr5L0B8" }' ``` ### Create a subscription from a list of products In this example, we create a new subscription with two products paid every month for the customer `cus_3PYD5R2q5NFK5E`, with a starting date on December 12, 2025 and activated automatically at the start date. The product prices will be automatically determined based on the prices configured in the product catalog for the corresponding currency, interval, etc. ```sh theme={null} curl --request POST \ --url https://api.hyperline.co/v2/subscriptions \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "customer_id": "cus_3PYD5R2q5NFK5E", "starts_at": "2025-12-20T00:00:00Z", "activation_strategy": "start_date", "payment_method_strategy": "current", "products": [ { "id": "itm_4vea8Gj0a5HZr9", "payment_interval": { "period": "months" }, }, { "id": "itm_vBBCZSTR6NzzuL", "payment_interval": { "period": "months" }, "count": 2, }, ] }' ``` Here, product `itm_4vea8Gj0a5HZr9` is a **fee** product and `itm_vBBCZSTR6NzzuL` a **seat** one with 2 items applied. ### Override prices When creating a subscription, you can override the price for a specific product with a custom amount. Note that this operation is only allowed for `flat_fee` products. If we take back our previous example and adjust it: ```sh theme={null} curl --request POST \ --url https://api.hyperline.co/v2/subscriptions \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "customer_id": "cus_3PYD5R2q5NFK5E", "starts_at": "2023-12-20T00:00:00Z", "activation_strategy": "start_date", "payment_method_strategy": "current", "products": [ { "id": "itm_4vea8Gj0a5HZr9", # flat_fee product "payment_interval": { "period": "months" }, "price": { type: "fee", amount: 1234 }, # override }, { "id": "itm_vBBCZSTR6NzzuL", "payment_interval": { "period": "months" }, "count": 2, }, ] }' ``` # Subscription exports Source: https://docs.hyperline.co/docs/subscriptions/exports Export Hyperline subscription data to CSV — including products, prices, ARR, billing cycle, and customer info — for accounting and analysis. If you wish to export your subscription data for external analysis, Hyperline provides you with built-in file export within the Subscriptions section. ## Export flow After clicking the export button, your subscription data will be compiled into a CSV file. Download the file to access a complete export, including subscription details, associated customer, estimated ARR, next payment, and more. # Manage a subscription Source: https://docs.hyperline.co/docs/subscriptions/manage Manage the Hyperline subscription lifecycle: activate pending subscriptions, pause invoice issuance, cancel, reactivate, and generate future invoices. ## Activate a pending subscription If you want to activate a subscription from a `pending` status (e.g., if **manually**, **after checkout**, or **after quote signature** activation strategies were used during assignment), you can: If the subscription's **start date is today or is already exceeded**, the subscription will switch to an active state (with a `Live` tag), and products that need to be billed at the start of the period will be charged immediately. If the **start date is in the future**, the subscription will switch to a `Starts on ...` state, signifying that the subscription is now active but hasn't started yet. The products will begin to be charged on the starting date. ## Pause invoice issuance You can pause a subscription if you want to stop issuing new invoices without cancelling the subscription: New invoices are not issued while the subscription is paused. The subscription still renews so billing periods stay up to date. You can reactivate it anytime, instantly or later. When pausing invoice issuance, you can optionally select a date when the subscription will automatically resume. ## Reactivate a paused subscription Click on **Actions** then **Resume invoice issuance**. Upon reactivation, missed invoices from the paused period will not be issued retroactively. Invoice issuance resumes on the next billing date. ### Update the reactivation date While a subscription is paused, you can **update the scheduled reactivation date** at any time to postpone or bring forward the automatic restart. You can also **clear the reactivation date** entirely to leave the subscription paused indefinitely — it will then only resume once you manually resume invoice issuance. ## Cancel subscription If a customer wishes to stop their subscription or if you need to make changes to their subscription that can't be done through the update subscription option, you can cancel the subscription. * **Refund last invoice:** Refunds the total of the last settled invoice to your customer, if available. * **Refund custom amount:** Displays a field for entering a custom refund amount to your customer. * **Refund pro rata:** Refunds a pro-rata amount based on customer usage so far, with a breakdown showing the products and respective balances. * **Do not refund:** Cancels the subscription without issuing a refund to your customer. When canceling a subscription before billing, for instance, the products within the subscription are billed at month-end ("end of period") and the cancellation is initiated mid-month you'll have the option to charge the customer instead. The selection choices will stay consistent, with the exception of the 'last invoice' option, which will be adjusted to reflect the estimated amount for the upcoming invoice. A credit note will be issued and visible in the Invoices page of this customer. Its category will be `Refund` with an item "Refund for invoice X". ## Generate future invoices Hyperline allows you to generate subscription invoices in advance. To do so, go to Subscription > Generate future invoices, then select the date up to which you want invoices to be issued. The subscription will be advanced to that date, and all corresponding invoices will be generated and sent immediately. Depending on the payment method: * Invoices will be **charged automatically** (credit card, direct debit) * Invoices will be marked as **to pay** (bank transfers, outside of Hyperline) ## Viewing past subscription history In order to provide enhanced transparency regarding subscription activities, you now have access to your past subscription history. This feature is particularly useful for tracking changes and cancellations of subscriptions that are no longer active. Upon navigating to a customer's subscriptions page, you will find a section titled 'Past subscriptions'. Additionally, you can choose to archive a subscription by using the 'Delete subscription' action. The subscription will then no longer be displayed in the history list. *** ## Using the API You can also decide to manage subscriptions using the Hyperline API. Visit our API reference documentation for more details. * [Create subscription update endpoint](../../api-reference/endpoints/subscriptions/create-subscription-update) * [Cancel subscription endpoint](../../api-reference/endpoints/subscriptions/cancel-subscription) # Usage-based product metering Source: https://docs.hyperline.co/docs/subscriptions/metering Configure usage-based products in Hyperline by linking them to aggregators that turn raw events into billable metrics at the end of each period. Usage-based products are a bit more complex than standard products. A usage-based product is a product for which price is calculated at the end of a billing period based on the data provided through our events system. Each usage-based product must be linked to an [aggregator](../usage/aggregators) that defines how events are computed into a billable metric. To know more about ingesting and managing events, you can read our [dedicated article](../usage/send-usage-data). Metering is especially useful when your pricing depends on an unpredictable and variable usage, if everything is committed upfront or not depending on usage data, you should check out our seat-based options instead. ## Pricing configuration To understand how our different pricing models work, you can refer to our [pricing models glossary](../products/overview#pricing-models). As with any other products, metered prices can be overridden on a per-customer basis directly in the product dropdown. When you override a price, it's only applied to your current subscription and will be later noted on the customer page. ### Min, max and committed amounts You can add safety thresholds to your subscription to ensure your customer won't pay below or above a certain price. Minimum and maximum amounts are applied on prices and we'll show the correct usage as well as the capped/floored price on both the invoice and the interface. Committed units are another way to set up a minimum committed amount. If the actual usage is under the threshold value, we'll show the minimum committed usage instead. ## Metering periods You can configure metering options when assigning a subscription manually or in a plan if you need to reuse the product. Metering is only available for dynamic products and the configuration will appear below the price preview within the product dropdown. Hyperline offers several metering periodicities that should cover most use cases. Don't hesitate to reach out to us if you feel like you need something different. #### Option 1: Same as payment interval This option will select all billable events for which the `timestamp` value is within the current subscription period of the product. This is the most common and straightforward option for most use cases, like billing overheads for a given subscription period or standard usage-based pricing. For example, on a product billed every month with a metering period set to `Same as payment interval`, if the current subscription period is Sept 1st - Oct 1st, we'll take into account all events with a timestamp between these dates. #### Option 2: Current contract period This option will select all billable events for which the `timestamp` value is within the current subscription committed period. This is useful when billing usage-based past a certain annual threshold (for instance your customer is allowed 10M€ of spend every year with additional usage billed monthly). For example, on a subscription committed yearly from Jan 2023 to Jan 2024, we'll take into account all events within that timeframe. #### Option 3: Current phase This option will select all billable events for which the `timestamp` value is within the subscription's current [phase](../subscriptions/phases). A phase is a bounded section of a subscription with its own start and end date, so the metering window automatically follows the phase you're on and resets when the next one starts. Use it when a product's pricing is scoped to a specific phase of a deal — for example, a ramp-up phase that meters usage for its full duration independently of the payment interval or the overall contract period. On the subscription overview, the metered period is shown as the phase's date range. #### Option 4: Whole database This option will configure Hyperline to not take into account the timestamps of your events and include all of them in each invoice. It's useful to automate a seat-based billing based on realtime data for instance. ### Only bill the difference with the last invoice This option tells Hyperline to only bill the difference between usage for your current period and your previous period. It's only available for the last 3 options. It's particularly helpful when you're billing overages. For instance, coming back to our 10M€ example, if you want to bill the additional revenue every month you don't want to re-bill previously billed revenue. When this option is selected, Hyperline will take into account the total usage billed the last month and subtract it from the current period usage. ## Include child customers' usage When a customer has child customers through [organisation-based billing](../customers/organisation-based), a usage-based product can bill the parent subscription on usage from the parent and its direct children. Use this when the parent owns the contract, but usage events are sent by several child customers. Each child keeps its own customer record and usage history, while the subscription on the parent calculates one metered charge. To enable it, open the usage-based product configuration while creating or updating the subscription, then turn on **Include child customers' usage**. You can then choose how Hyperline combines usage: * **Sum across child customers** adds the parent usage and each direct child's usage together. * **Max across child customers** bills only the highest-consuming customer among the parent and its direct children. Child usage roll-up applies to direct child customers only. It is configured per usage-based product on the subscription, so you can roll up usage for one metered product while keeping another product billed only on the parent's own usage. # Subscriptions overview Source: https://docs.hyperline.co/docs/subscriptions/overview Understand the Hyperline subscription model: a contract between you and a customer, with products, pricing, terms, and scheduled future changes. In Hyperline, the subscription model represents a contract—a sold configuration of products and their prices, with a set of terms and optionally pre-configured future changes—between you and a customer. Subscriptions can be created via the customer page in the UI by a Hyperline user, the CRM, or orchestrated via the API. ## Subscriptions lifecycle A customer can have one or multiple subscriptions running at the same time. These subscriptions can be active, scheduled to start in the future, or started and scheduled to be cancelled. Our flexible subscription model makes it easy to configure multiple products with different options and renewal logic, as well as multiple phases (scheduled changes), all combined inside a unique contract. Hyperline provides the ability to set a commitment period, which may differ from the billing interval of the products it encompasses. Furthermore, the billing intervals can also vary between different products. Depict intricate scenarios, such as a situation where a customer subscribes annually (annual commitment) but pays for a product based on monthly usage, along with an add-on with a fixed price paid on a quarterly basis. When a subscription is created, its default status is `pending` and it can be activated: * automatically at the scheduled start date * when a customer signs its associated [quote](../quotes/overview) * when a new customer completes its associated [checkout](../subscriptions/checkout-page) * manually in the interface * using the API Once a subscription is active, it will be shown with a `live` green tag. A subscription **will automatically be invoiced** following the schedule described below once it's active. If you need to pause invoicing, you can pause the subscription directly in the interface using the pause subscription option. For more details on how to manage your subscriptions please see [this page](../subscriptions/manage). ## Subscription status Here is a description of each subscription status: * `pending` The subscription has been created and won't be charged until it is activated using one of the options described above. * `active` The subscription is running and will be invoiced at the next payment date. * `cancelled` The subscription has been cancelled from an active state. * `voided` The subscription has been voided directly from the pending state without ever being activated. * `paused` The subscription's invoicing is paused. * `errored` We attempted 4 times (3 retries) and failed to charge a subscription's invoice, see [Handling payment errors](../payments/payment-errors). Here, we consider the subscription as inactive (as the customer failed to pay you) meaning that we won't invoice the customer in the future nor collect payment. You can choose to reactivate it manually. ## When is a subscription billed? Hyperline lets you decide if each product is billed at the start or at the end of the billing period independently. Usage-based products will always be billed at the end of the period, depending on the final consumption. Create a yearly subscription with a flat fee billed at the start of the period, and add-ons billed at the end of each quarter. #### Products charged only once You can assign products billed only once. This is useful for charging implementation or onboarding fees. You can also choose to bill these products at the start or end of the period. When billed, they will be detached from future invoicing. #### Subscriptions with start and end of period products You can assign products that are charged at the beginning of the period for one, and at the end of the period for the other with the same billing period (i.e. monthly). These products will be grouped within the same invoice. My subscription has a product "Platform Access" billed at the start of period, and a product "API Calls" billed at the end of period. Both products are billed monthly, and grouped within the same invoice. Example for an invoice generated on September 1st: * Platform Fee's billing period will be September 1st > September 30th (in advance) * API Calls's billing period will be August 1st > August 31st (in arrears) * The global billing period of the invoice will span over two months (August 1st > September 30th). # Subscription phases Source: https://docs.hyperline.co/docs/subscriptions/phases Split Hyperline subscriptions into phases with different products and coupons to build ramp-up deals, free trials, and evolving contracts. Phases are a concept that splits subscriptions into multiple sections, allowing granular-level deal customization. Just like subscriptions, phases have a start and end date, and contain products and coupons. Invoice upfront fees, create ramp-up deals, and evolutionary contracts within the same subscription, automatically or manually changing from one phase to another. Let's take the example above. With phases, you can now charge your customer a **setup fee** of 1000.00 € automatically once they sign their quote, and manually start their **recurring fee** of 20 licenses at 20.00 €/license/month that will increase automatically to 40 licenses at 25.00 €/license/month after one year. ### Add phase To add phases to your subscription you can: * **Create empty phase** to add a new phase and start from scratch. * **Duplicate phase** to duplicate the content (products, coupons). For every phase other than the first one, its start strategy is necessarily `previous phase end`. When adding a new phase, if the previous phase end strategy is set to `forever`, it will automatically be changed to `manual end` and the last phase end strategy will be set to `forever`. By setting the end of the subscription on a fixed date, the new phase will start the next day. You can also add phases to live subscriptions through [update subscription](./manage#generate-future-invoices). ### Phase transition Phases will transition automatically once the phase end strategy is reached (date, duration, manually). There are two types of transitions: * **Direct**, where the new phase will be charged according to its configuration, without taking into account the previous phase balance. New billing intervals for every product will start on the day the phase transitions. My current phase contains 10 licenses costing 100€ monthly, current cycle from September 1st to September 30th. If I decide to transition to a new phase on September 15th, containing 20 licenses costing 200€ monthly, on September 15th, a new invoice of 200€ will be issued. New billing interval will be September 15th to October 15th. * **Pro-rata**, where an adjustment invoice will be generated, containing the balance owed or due from the previous phase, and what is owed for the next phase based on the invoicing schedule of the products. If the new phase contains the same products with the same billing interval (i.e. monthly, yearly) the billing interval will be preserved and all products with the same billing interval will be aligned to it as well. My current phase contains 10 licenses costing 100€ monthly, current cycle from September 1st to September 30th. If I decide to transition to a new phase on September 15th, containing 20 licenses costing 200€ monthly, on September 15th, a new invoice of 50€ (new phase due amount = 200\*(15/30) = 100€) - (previous phase surplus = 100\*(15/30) = 50€) will be emitted. Billing interval will remain September 1st to September 30th, and be kept for October 1st to October 31st, and so on. ### Update products and coupons Products and coupons can be added, removed and updated during the current phase following the same pattern as subscriptions without phases. For future phases, products and coupons are added, removed and updated immediately. ### Update phase start and end strategy For current phases, the phase end strategy can be updated for any date or duration later than the current time. For future phases, the phase end date cannot be set before the end date of the previous phase. ### Transition to next phase When there is a next phase, the current phase can be transitioned manually with immediate effect. # Subscription templates Source: https://docs.hyperline.co/docs/subscriptions/templates Pre-configure reusable subscription templates in Hyperline that auto-fill products, pricing, billing cycles, and contract terms during assignment. When assigning new subscriptions to your customers, Hyperline offers a powerful way to create pre-configured and reusable templates. Subscription templates support all configuration options and parameters available when creating subscriptions. By selecting a template during the subscription assignment flow, the form will automatically be filled with all configurations from the selected template. All details inherited from the template can still be customized in the final customer subscription without affecting the original template, typically configured by an admin. Subscription templates are the evolution of plans. They are more powerful, flexible, and future-proof. **Plans are deprecated and will be removed in summer 2026.** We recommend using subscription templates instead of plans to benefit from the latest features and improvements. Hyperline does not provide automatic migration from plans to templates, since templates offer significantly more flexibility and capabilities. However, we can assist in assigning template IDs to existing subscriptions to ensure continuity in tracking. ## Configuration Templates have a name (which becomes the subscription name when assigned, though it can be overridden during creation) and an optional internal description. They can include multiple subscription configurations — each with a currency and, optionally, a country for which it is eligible. If no specific country is defined, the configuration applies to all countries. Each subscription configuration supports all the same options as a standard subscription form, including contract settings, invoicing preferences, products/coupons, multi-phase setups, ... By adding multiple configurations to the same template, you can pre-configure variations by currency or market while keeping them under a single template. Hyperline also provides a one-click action to duplicate configurations, saving time when creating similar setups for another currency. You cannot create duplicate configurations within a single template for the same currency/country pair. If needed, we recommend creating separate templates. ### Price inheritance When configuring a template, product prices from the catalog are suggested and instantiated within that template. If product catalog prices are later updated, template prices will **not** automatically change. This prevents unintended modifications and ensures stability for legacy offers. You can still update template prices manually if desired. ## Subscription assignment When assigning a new subscription to a customer, only templates matching the customer’s currency and country will be suggested. If multiple configurations match, the most specific one will be selected automatically. For example, a template has three configurations: 1. EUR — eligible for all countries 2. EUR — eligible for France 3. GBP — eligible for the UK If this template is selected for a French customer using EUR, configuration **2 (EUR/France)** will be applied, even though configuration 1 also matches. ## Quote templates Subscription templates can also be used in quote templates. This enables quotes with fully pre-filled subscription configurations, reducing manual work, minimizing errors, and promoting internal standardization. ## Updating templates When updating a subscription template (currency, country, or configuration), existing subscriptions linked to it will **not** be automatically updated. This allows you to evolve offers without affecting active subscriptions. Existing subscriptions can still be updated manually using the [subscription update flows](./update), independently of the template. # Subscription translation overrides Source: https://docs.hyperline.co/docs/subscriptions/translations Store custom product names and descriptions per Hyperline subscription so invoices stay translated for multilingual customers despite catalog edits. Translation overrides let you save custom product names and descriptions directly on a subscription. Once enabled, future catalog edits won't affect that customer's invoices. Without overrides, Hyperline uses catalog translations when available, or falls back to the main product field. ## Set a default for all subscriptions Go to **Settings → Subscriptions** and enable **Override product translations on subscriptions**. New products added to any subscription will have the override on by default. Existing subscriptions are unaffected. ## Enable per product When creating or editing a subscription, scroll to the bottom of any product and toggle on **Override product translations**. A globe icon appears on the name and description fields. The toggle only appears when the customer has a language set that differs from the invoicing entity's language. When both are the same, the main field already covers the only relevant locale. ## Edit translations Click the globe icon to open the translation panel. It shows one tab per language, limited to the customer's and invoicing entity's languages. The **Current** tab (customer's language) stays in sync with the main field automatically. ## Templates Templates show all available languages in the translation panel since no customer is attached. When assigned to a customer, the stored values carry over and the customer's language is marked **Current**. ## Precedence From lowest to highest: **default** (`false`) → **subscription settings** → **template** → **subscription product**. A higher-level value always wins. ## FAQ Hyperline reverts to catalog translations (or the main field if none exist). Your custom values are preserved on the subscription and restored if you re-enable the override. Either the customer has no language set, or the customer and invoicing entity share the same language, in which case no separate translation tab is needed. Yes. The same globe icon appears on name and description fields when editing an invoice manually. # Update subscription Source: https://docs.hyperline.co/docs/subscriptions/update Update active Hyperline subscriptions globally or locally — change products, prices, quantities, contract terms — with previews and version history. Subscriptions can be edited from the subscription details page. There are two types of updates: * **Global update** where you can update the whole subscription directly * **Local update** where you can update a single part of the subscription (product price, contract configuration...) Updating a subscription is not available for subscriptions that are in a future state after [generating future invoices](./manage#generate-future-invoices) or that have a [quote for subscription update](../quotes/subscription-update) pending signature. You can still create additional update quotes in that state — all open update quotes are listed on the **quotes** tab of the subscription details page. For cancelled, voided, or archived subscriptions, only simple fields (contract value, estimated ARR, CRM opportunity ID, and shipping details display) can be updated. ## Global update A subscription can be updated by clicking on `update subscription` in the subscription action dropdown. You will be presented with the following options: ### Simple update When selecting this option, the subscription will be updated immediately, the billing intervals will be conserved and no pro-rated invoice will be generated. This is recommended when updating product information or adding, removing or updating a product or coupon without impacting the current billing period. ### Advanced update When selecting this option, you will enter a multi-step process to configure exactly when and how the update should be applied, as well as manage the transition invoice precisely: Select when the subscription update should take effect: * **Next renewal** — The update is applied when the current billing cycle ends * **At last renewal** — The update is applied retroactively as of the start of the current billing cycle * **Immediately** — The update is applied right away * **Scheduled date** — The update is applied at a specific date in the future Decide how you want to configure the updated subscription: * **Update current subscription** — Modify the existing subscription configuration directly * **Update to a template or a plan** — Reset the subscription configuration using a pre-defined template or plan as a starting point, that can be further customized if needed Define how the billing cycle and invoicing should be handled during the transition: **Billing cycle alignment** * **Keep current period** — The subscription continues with its existing billing dates * **Start new period** — The subscription billing dates are reset to start a fresh cycle from the update date **Transition invoice** * **Waive transition invoice** — No transition invoice will be issued * **Generate transition invoice** — A transition invoice will be issued to settle the current billing period before the update takes effect * **Refund and re-invoice** — The current billing period's invoice is refunded and a new invoice is issued to reflect the updated subscription configuration (available only for updates **At last renewal**) The **Generate transition invoice** option is not available when the subscription has products billing in a future period (for example, after using [generate future invoices](./manage#generate-future-invoices)). You can still proceed with the update by waiving the transition invoice. At this step, you can preview both the **transition invoice** (settling the period before the update) and the **following invoice** (the first invoice after the update) to understand the financial impact before confirming. ### Scheduled updates A subscription with a scheduled update cannot be updated until the scheduled update is applied or cancelled. However, you can manage the scheduled update through the subscription dropdown: * **Revise update** — Edit the scheduled update configuration * **Cancel** — Cancel the scheduled update entirely, allowing the subscription to be updated again ### Subscription versions Previous subscription versions, as well as scheduled updates, can be accessed through the versions tab. *** ## Local update If you do not wish to update the entire subscription at once, but rather just a single part, you can proceed with a local update. ### Duration The subscription or phase end date can be edited to end at a later or closer date with the following options: * Forever * After a custom relative duration * At a specific date The end of the phase or subscription cannot be set before the end of the current billing period of its products. In order to do that, you need to [cancel the subscription](./manage#cancel-subscription). If the subscription has not started yet, the start date can be edited too. ### Products Products that currently belong to a subscription can have their price and quantity edited, and they can be added or removed freely. #### Update product price Prices can be edited immediately by clicking on the product `...` then `update price`. Their price will be updated immediately, with an impact on the next invoice. #### Update product quantity Quantity can be edited (except for usage-based and connected seats) by clicking on the product `...` then `update quantity`. The quantity change **always applies immediately**. Two settings control only how it is billed: * **Payment schedule** sets *when billing happens* (not when the change applies): * **Immediately**: a separate invoice (or credit note) is issued and charged right away. * **Next invoice**: the adjustment is added as a line on the next invoice. * **Update method** sets how the adjustment is computed: * **Pro-rata**: only the remaining or elapsed portion of the period. * **Full price**: the full period amount. * **Do not charge / refund**: apply the new quantity without any billing. Whether the adjustment is a **charge** (positive line) or a **credit** (negative line), and whether a line appears at all, depends on whether the product is billed at the **start** of the period (in advance) or at the **end** of the period (in arrears). It also depends on the direction of the change (increase or decrease). See [Subscriptions with start and end of period products](/docs/subscriptions/overview#subscriptions-with-start-and-end-of-period-products). | Billing timing | Update method | Quantity increase | Quantity decrease | | ---------------------------- | ------------- | ----------------------- | ---------------------- | | Start of period (in advance) | Pro-rata | Charge (prorated) | Credit (prorated) | | Start of period (in advance) | Full price | Charge (full) | No line (already paid) | | End of period (in arrears) | Pro-rata | Credit (prorated) | Charge (prorated) | | End of period (in arrears) | Full price | No line (billed at end) | Charge (full) | With **Full price**, no adjustment line is produced for an end-of-period increase (the added quantity is billed at full price on the regular end-of-period invoice) or a start-of-period decrease (the removed quantity was already paid for the current period). **Do not charge / refund** never bills the customer, but whether a line is recorded depends on the payment schedule: * **Immediately**: nothing is billed and no invoice is generated. * **Next invoice**: a **zero-amount line** is added to the next invoice to record the change (labelled as not invoiced for the period). For worked billing examples of each case, see [Connected seats billing calculation examples](/docs/subscriptions/connected-seats#billing-calculation-examples), which uses the same start and end of period, pro-rata, full, and no-charge logic. This dialog always applies the change immediately. To apply a quantity change on a **future date**, use an [Advanced update](#advanced-update) instead. #### Add product Products can be added directly to a live subscription by clicking on `add product`. Products can be added with an existing price configuration or manually configured. They will be added immediately to the subscription, and can be charged full price, pro-rata or not charged, immediately or on the next invoice. #### Remove product Products can be removed from the subscription immediately by clicking on the product `...` then `remove product`. Depending on the product balance, they can be charged or refunded, at a pro-rata or full price or without payment, immediately or with the next invoice. ### Coupons Coupons can be added or removed freely from the subscription, with immediate effect. #### Add coupon Coupons can be added directly to a live subscription by clicking on `add coupon`. You will then be able to configure the coupon name, application, discount type and products to which it is applied. When adding a coupon with a duration (e.g., 6 months) during a subscription update or transition, the coupon's expiration date is automatically calculated from the transition date. This ensures the coupon applies for the correct duration starting from when the update takes effect. #### Remove coupon Coupons can be removed from the subscription immediately by clicking on the coupon `...` then `remove coupon`. ### Contract Contract can be attached, edited or removed from the subscription at any time. ### Invoicing Invoicing configuration such as the purchase order displayed on every invoice, draft invoices generation and document type can be edited at any time, with an impact on the invoices emitted after the update. # Upfront metered products Source: https://docs.hyperline.co/docs/subscriptions/upfront-metering Bill usage-based products upfront at the start of each period based on projected consumption, then true-up against actual usage on the next invoice. By default, a usage-based product is invoiced **in arrears** — at the end of the billing period, once all usage for that period has been consumed. Hyperline also supports the opposite pattern: **upfront metered products**, where usage is invoiced at the *start* of each period and reconciled against real consumption on the next invoice. This is useful when: * Your customer has a **minimum committed volume** and you want to charge for it upfront each period. * You want cash to come in at the start of the period rather than the end. * Your customer's usage is fairly predictable period-over-period. Upfront billing is a property of a **usage-based (dynamic) product** on a subscription. You configure it by setting the product's payment schedule to **start of period** when adding it to the subscription or plan. ## How it's billed At the start of each period, real usage for that period hasn't happened yet, so Hyperline has to bill on a projection. The projection is: ``` billed units = max(committed units, usage billed for the previous period) ``` * **Committed units** is the minimum volume you configure on the product (`min_committed_count` on the API). It acts as a **floor**, not a cap. * **Previous period's billed usage** is what actually got consumed in the period that just closed. Two consequences follow from this rule: * **On the very first period** there is no prior usage, so the customer is billed on the committed amount. If you didn't set a commitment, the upfront charge for the first period is **zero** and the whole charge lands on the correction line the following period. * **On subsequent periods** the upfront charge floats up if the last period ran hot. If a customer consumed 500 units when they committed to 250, the next period's upfront charge is priced on 500 — the commitment is only a floor. ## The correction line item Because you charged the customer upfront on a projection, real usage will drift from what was billed. To reconcile, **every renewal invoice includes a correction line item for the period that just closed**: ``` correction = actual usage for that period (priced) − amount already invoiced upfront ``` * If the customer **used more** than what was billed upfront, the correction is a **debit** (extra charge). * If the customer **used less**, the correction is a **credit** (refund). A typical renewal invoice for an upfront metered product therefore contains **two lines** for that product: 1. **Upfront charge** for the new period, sized on `max(committed, last period's usage)`. 2. **Correction** for the previous period, settling the difference between actual and projected usage. Corrections are pre-populated on the next period's draft invoice as soon as the current invoice is finalized, and are kept in sync as new usage events arrive — so both you and your customer can see the running true-up before the invoice is issued. ## Worked example Setup: * Metered product priced at **€50 per unit**, billed monthly, upfront. * Committed units: **250 per month**. **January (first period)** * No prior usage yet → billed on the committed 250 units. * Upfront charge: `250 × €50 = €12,500`. * Actual January usage turns out to be **500 units**. **February renewal invoice** * Upfront charge for February: `max(250, 500) × €50 = 500 × €50 = €25,000`. * Correction for January: `500 × €50 − 250 × €50 = €12,500` **debit** (customer used more than was billed upfront). * Total on the February invoice for this product: `€25,000 + €12,500 = €37,500`. **March renewal invoice** — assume February usage came in at **300 units** * Upfront charge for March: `max(250, 300) × €50 = 300 × €50 = €15,000`. * Correction for February: `300 × €50 − 500 × €50 = −€10,000`, applied as a **€10,000 credit** (customer used less than was billed upfront in February). * Net on the March invoice for this product: `€15,000 − €10,000 = €5,000`. **April renewal invoice** — assume March usage came in at **200 units** (below commitment) * Upfront charge for April: `max(250, 200) × €50 = 250 × €50 = €12,500` — the commitment kicks in as the floor. * Correction for March: `200 × €50 − 300 × €50 = −€5,000` credit. * Net on the April invoice for this product: `€12,500 − €5,000 = €7,500`. ## Interaction with other settings ### Metering period The projection and the correction always look at usage **within the product's own billing period** (the period being billed upfront and the one being trued up). If you configure a different metering period (`Current contract period`, `Current phase`, `Whole database`, `Custom`), the same upfront + correction mechanic applies, but the "actual usage" figure used in the correction reflects that broader window rather than a single billing period. ### Only bill the usage difference The **Only bill the difference with the last invoice** option combines with upfront billing: the customer is charged upfront for the projected units, and the correction on the next invoice reflects only the incremental usage vs. what was previously billed, rather than the full period's usage. Use this when the priced quantity is a running total (e.g. cumulative revenue against an annual threshold) rather than a per-period consumption count. ### Min and max amounts Minimum and maximum **amounts** on the product are applied to each invoiced amount independently — both the upfront line and the correction line are subject to the caps in force at the time they are computed. ## When not to use upfront metering Upfront metering is a poor fit if: * Usage is highly volatile and you don't want large corrections swinging invoice totals up and down. * The customer has no meaningful commitment — you'll end up billing zero upfront and everything on the correction, which is just arrears with extra steps. * You need revenue tied precisely to consumption events with no timing gap. In that case, use standard (in-arrears) metering. # Aggregators Source: https://docs.hyperline.co/docs/usage/aggregators Configure aggregators to transform raw usage events into billable metrics for subscription products or assign them to customers for usage monitoring. Aggregators turn raw usage events into a single metric, such as API calls, active users, or storage consumed. You can use that metric for subscription billing or, with the Customer Intelligence module, assign it directly to customers for monitoring without billing them. Aggregators are managed independently in **Usage > Aggregators** and can be linked to multiple products. ## Subscription billing or direct customer assignment An aggregator can reach a customer in two ways: | Configuration | How the aggregator applies | Billing impact | Availability | | ------------------------------ | ---------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | ------------------------------------------ | | Through a subscription | Link the aggregator to a usage, credit, or connected seat product, then add that product to a subscription | The aggregated value drives the product's billing or credit consumption | Included with the relevant billing feature | | Directly assigned to customers | In the aggregator's **Visibility** settings, select all customers or specific customers and segments | Monitoring only; no product, subscription, or invoice line is created | Requires the Customer Intelligence module | The same aggregator can be used in both configurations. If it is both part of a subscription and assigned directly to the same customer, Hyperline avoids showing a duplicate usage card. The subscription's metering period takes precedence for the subscription-linked card. Direct assignment is not an alternative way to bill usage. It only exposes the metric on the selected customer records for monitoring, analysis, and threshold alerts. ## Operations An aggregator uses one of three operations to compute a usage metric from your events: ### Count Counts the number of matching events. Use this when you bill based on the number of occurrences (e.g., API calls, logins, transactions). ### Sum Sums the value of a specific numeric property across matching events. Use this when you bill based on a cumulative measure (e.g., data transferred in GB, compute hours consumed). When using **Sum**, you must specify which event property to aggregate. ### SQL formulas Use **SQL formula** when Count or Sum is not enough, and you need to combine, compare, or adjust values before billing them. A formula runs on the events selected by the aggregator's **Event type** and **Filters**. Write event properties directly by name, and place them inside an aggregate function: | What you need | Formula pattern | | ---------------------------------------- | -------------------- | | Sum a numeric event property | `sum(totalAmount)` | | Count matching events | `count(*)` | | Count events where a property is present | `count(totalAmount)` | | Average a numeric event property | `avg(unitPrice)` | | Keep the highest matching value | `max(seats)` | | Keep the lowest matching value | `min(seats)` | You can then combine those results: | Billing rule | Formula | | ----------------------------------------- | ------------------------------------------------------ | | Bill at least 500, even if usage is lower | `greatest(sum(totalAmount), 500)` | | Remove an included allowance | `greatest(sum(totalMinutes) - 50000, 0)` | | Cap the billed value | `least(max(seats), 1000)` | | Apply a per-event adjustment | `sum(totalAmount) - sum(if(type = 'one_off', 500, 0))` | Use **Test formula** before saving to preview the result on matching events. Use field names exactly as they appear in your event properties. Text values in conditions use single quotes, for example `type = 'one_off'`. ## Configuration When creating an aggregator, you configure the following: * **Name**: A descriptive label for the aggregator * **Event type**: The type of event to aggregate (e.g., `api_calls`, `storage`, `users`) * **Operation**: Count, Sum, or SQL formula (and the target property for Sum) * **Unit name**: The label displayed alongside aggregated values (e.g. `API calls`, `GB`, `seats`). Surfaces on usage charts, prices, invoices, and the customer portal. * **Filters**: Optional conditions to narrow which events are included. Filters support AND/OR logic with operators like `equals`, `in`, `gte`, `lt`, etc. * **Exposed event keys**: Event fields to surface in the UI for transparency and debugging * **Allow negative values**: Whether the aggregated result can go below zero The unit name is configured on the aggregator itself. It used to live on each product; products linked to an aggregator now inherit its unit name automatically. ### Default aggregation interval You can set a **default aggregation interval** on an aggregator by specifying a count and a period (days, weeks, months, or years). It is used to display and evaluate the metric when the aggregator is assigned directly to customers without a subscription. For an aggregator used through a subscription, the subscription's metering period determines the current value instead. The aggregator's default interval does not change how that subscription is billed. ## Aggregator filters Aggregator filters let you define **named filter sets** on an aggregator. Each filter combines conditions using AND/OR logic on event properties (e.g., `region equals "eu"`, `plan in ["pro", "enterprise"]`). Filters serve two purposes: * **Billing**: different prices can apply based on which filter an event matches (see [price metering filters](#price-metering-filters)) * **Usage visualization**: on the [customer Usage tab](./customer-usage), each filter is displayed as a separate line on the usage chart with its own color and legend entry A filter can only be deleted if it is not referenced by any product price. ## Thresholds Thresholds let you define **alert conditions** on an aggregator. Each threshold specifies: * **Name** (optional): A descriptive label for the threshold * **Operator**: Greater than or equal to (`>=`) or less than or equal to (`<=`) * **Value**: The numeric threshold value Thresholds are evaluated separately for each customer to whom the aggregator applies: * For a subscription-linked aggregator, Hyperline uses the subscription's metering period. * For an aggregator assigned directly to customers, Hyperline uses its default aggregation interval. This direct monitoring workflow requires the Customer Intelligence module. When a customer's aggregated usage crosses a threshold, Hyperline can notify you via [webhooks](../../api-reference/docs/webhooks) (`aggregator.threshold_crossed` event) or [Slack notifications](../../integrations/slack). A threshold alert does not create a charge or change an invoice. On the [customer Usage tab](./customer-usage), thresholds are displayed as dashed horizontal reference lines on the usage chart, with the operator and value shown as labels. ## Which products use aggregators? Not all product types require an aggregator. Here's when you need one: | Product type | Aggregator required? | Allowed operations | | ------------------ | -------------------- | ----------------------- | | **Fee** | No | — | | **Seat** | No | — | | **Connected seat** | Yes | Count only | | **Usage** | Yes | Count, Sum, SQL formula | | **Credit** | Yes | Count, Sum, SQL formula | A seat product becomes a [connected seat](/docs/subscriptions/connected-seats) product when an aggregator is selected. ## Managing aggregators Navigate to **Usage > Aggregators** to create, edit, and delete aggregators. ### Create an aggregator Click **New aggregator**, configure the operation, event type, and optional filters, then save. ### Edit an aggregator Click on an existing aggregator to update its configuration. The detail page also shows which products are currently linked to this aggregator. ### Delete an aggregator An aggregator can only be deleted if no products are linked to it. ## Linking an aggregator to a product When creating or editing a usage-based, credit, or connected seat product, you select an existing aggregator from a dropdown instead of configuring metering inline. * **Usage products**: select any aggregator (count or sum) * **Credit products**: select any aggregator (count or sum) * **Seat products**: select a count aggregator (only when connected seats are enabled) For more details on product configuration, see [Products and prices](/docs/products/overview). ## Price metering filters For usage-based products, you can further refine billing by adding **metering filters at the price level**. This allows different prices for the same product based on specific event properties (e.g., region, instance type). Learn more in the [usage-based product documentation](/docs/products/overview#metering-configuration). # Connect with BigQuery Source: https://docs.hyperline.co/docs/usage/bigquery Connect a Google BigQuery dataset to Hyperline as a data loader to pull usage events automatically, with service account permissions and queries. This guide is specific to setting up a dataloader with [Google BigQuery](https://cloud.google.com/bigquery), to learn more about data loaders in general, you can read our [general article](./usage-data-with-connectors). ## Authorizations To set up our BigQuery connector, you'll need to configure a Service Account with the right permissions. To do so, you can follow these steps: 1. Go to the Google Cloud Console for the project containing your database and navigate to the [IAM & Admin](https://console.cloud.google.com/iam-admin) tab. 2. Click "Create Service Account", enter a name and description for the service account, then click "Create". 3. Assign the following roles to the service account: **BigQuery Data Viewer** and **BigQuery Job User**, then click "Continue" and "Done". 4. Find the newly created service account in the list, click the service account, go to the "Keys" tab, then click "Add Key" and choose "Create new key", select JSON, and click "Create". ## Load your data To get started, just go to the [data loaders page](https://app.hyperline.co/app/events/loaders) in Hyperline, create a new Connection and select "Google BigQuery" in the dropdown list. Copy and paste the content of the JSON key file in the correct box, choose a name and then save the connection. When creating or updating a connection, Hyperline always performs a ping test to check the database is accessible, so if it's safe, it's all good. # Customer usage Source: https://docs.hyperline.co/docs/usage/customer-usage Monitor per-customer consumption from subscription-linked and directly assigned usage aggregators with real-time charts, thresholds, and event details. The **Usage** tab on a customer page gives you a real-time overview of aggregator-based consumption for that customer. It can show aggregators from running subscriptions and aggregators assigned directly to the customer through the Customer Intelligence module. | Source | Why the aggregator appears | Period used | | -------------------- | --------------------------------------------------------------------------------- | --------------------------------------------- | | Running subscription | A product in the subscription is linked to the aggregator | The subscription's metering period | | Direct assignment | The aggregator is assigned to all customers or to matching customers and segments | The aggregator's default aggregation interval | Assigning an aggregator directly to a customer without a product or subscription is a Customer Intelligence feature. It provides usage monitoring and threshold alerts, but does not bill the customer. ## Aggregator cards Each aggregator is displayed as a card showing: * **Aggregator name** and linked subscription (if any) * **Current aggregated value** for the active metering period * **Area chart** of the aggregated value evolution over time (last 6 months by default) * **Threshold lines** displayed as dashed horizontal references on the chart, with the operator and value as labels (see [thresholds](./aggregators#thresholds)) ### Filters on charts When an aggregator has [aggregator filters](./aggregators#aggregator-filters) defined, the chart displays **one line per filter** with a distinct color. A legend below the chart identifies each filter by name. ### Card display logic The Usage tab handles different scenarios to avoid duplicated cards: | Scenario | Display | | ----------------------------------------------------- | ------------------------------------------------------------- | | Aggregator from a subscription | Current value + subscription's metering period | | Directly assigned aggregator + 1 subscription | Current value + that subscription's metering period | | Directly assigned aggregator + multiple subscriptions | One card per subscription, each with its own metering period | | Directly assigned aggregator + no subscription | Current value + the aggregator's default aggregation interval | ## Period range and grouping Use the date range picker at the top of the Usage tab to select a custom period. You can also choose how data is grouped: | Group by | Best for | | ----------- | ------------------------------------------------------------------------ | | **Monthly** | Long-term trends (presets: last 3/6/12 months, current/past year) | | **Daily** | Weekly or monthly analysis (presets: this/last week, current/past month) | | **Hourly** | Intraday monitoring (presets: today, yesterday, this/last week) | Each aggregator card updates to show the aggregated value for the selected period, and charts are filtered accordingly. Numbers in cards and tooltips use a compact format (e.g. `1.2K` instead of `1,200`). ## Sorting You can sort aggregator cards by: * **Name** (ascending or descending) * **Current value** (ascending or descending) ## Explore consumption Click **Explore** on any aggregator card to open a side panel with the underlying events. The selected date range and grouping are forwarded to the panel. The exploration panel provides: * **Event list** filtered on the aggregator's event key, with timestamps and values * **Search** to find specific events * **Date range filter** to narrow the time window * **Filter selector** to view events matching a specific aggregator filter * **Pagination** for browsing through large event sets From the card's dropdown menu, you can also navigate directly to the aggregator detail page or the linked subscription. ## Related * [Global usage](./global-usage) — same charts aggregated across all customers, with a per-customer ranking drill-down * [Aggregators](./aggregators) — define how raw events become a usage metric * [Custom usage tracking](../customer-intelligence/custom-usage-tracking) — assign aggregators to customers without a subscription # Explore usage events and consumption Source: https://docs.hyperline.co/docs/usage/explore-usage-consumption Explore raw usage events in Hyperline at global, customer, subscription, and invoice levels, or pull events programmatically through the API. In the Hyperline platform, an event is a specific action or occurrence that can be tracked and measured. You can explore it in the **Events** section or retrieve events programmatically via the [API](../../api-reference/endpoints/billable-events/get-events). This view is global and will show all the events that are being tracked. However, for each subscription and invoice, you can explore a more detailed view of the events. ## Explore usage data You will be able to view the product's consumption along with the amount billed for each event. In order to do so, an action **Explore consumption** is available on different levels: ### Open data consumption on subscription ### Explore invoice consumption ### Explore consumption on customer portal In the customer portal, you can delve into the consumption details of each subscription. This can be found in the 'Subscription Details' section. Here, you can view and analyze the usage data associated with each subscription. ## Download usage data You can export usage data in CSV format for analysis and processing. ### Export single product events To download events for a specific product, click the **Export CSV** button in the consumption view. The CSV file includes the following columns: ### Export all invoice events When viewing an invoice with multiple usage-based products, you can download all events at once as a ZIP file containing separate CSV files for each product. Click the **Export all events** button on the invoice page. The ZIP file will be named `events-{invoiceNumber}.zip` and contain one CSV file per product, with filenames based on the product names. This is particularly useful when you need to analyze usage data across multiple products for a single billing period. ## Customize displayed event name The event name can be customized when you create or edit the product. It will be used to identify the event in the consumption. In order to have a dynamic name for each event, it can depend on a specific key of the event. ## Customize exposed columns In the product editing section, you have the option to customize the columns that appear in the consumption CSV export. # Getting started with usage-based billing Source: https://docs.hyperline.co/docs/usage/getting-started Build your first usage-based billing workflow in Hyperline: send events, create an aggregator, configure a metered product, and bill a subscription. Usage-based billing lets you charge customers based on what they consume: API calls, transactions, storage, compute hours, seats, AI usage, or another measurable activity. Monetizing AI products? See [AI monetization](/docs/ai-monetization/overview) for guidance on usage-based billing, prepaid credits, wallets, and hybrid pricing patterns for AI products. In Hyperline, the setup has four building blocks: | Building block | What it does | | ----------------- | --------------------------------------------------------------------------------------------------------- | | **Usage events** | Raw customer activity sent to Hyperline through a CSV import, API, data loader, or test simulation. | | **Aggregator** | Turns usage events into one billable metric, such as a count of API calls or the sum of stored gigabytes. | | **Usage product** | Defines what you sell and how that metric is priced. | | **Subscription** | Assigns the product to a customer, with billing, payment, and metering settings. | Start with one simple usage metric before adding tiered pricing, filters, commitments, or spending caps. It is easier to validate the full billing flow when the first setup is intentionally small. ## Before you start Make sure you have: * A customer to test with, or permission to create one in **Customers** * A usage metric you want to bill, such as API calls, processed transactions, or storage volume * Usage data available through one of the supported ingestion methods * A [test mode](/docs/getting-started/sandbox) workspace if you want to experiment before billing real customers You sell an API product with a monthly platform fee and a usage-based add-on. The add-on bills each customer for the number of API calls they make during the month. To set this up, you send API call events to Hyperline, create an aggregator that counts those events, link the aggregator to a usage product, then add that product to the customer's subscription. ## Setup flow ### 1. Connect usage data Hyperline needs usage events before it can calculate a usage-based charge. Choose the ingestion method that matches where your usage data already lives: Upload usage events from a spreadsheet or exported report. Send events from your application or backend systems. Pull usage data from a connected database or warehouse. Create test usage directly from a customer page in test mode. For each event, Hyperline needs enough information to identify the customer, event type, timestamp, and usage properties you want to bill or filter on. If you are still exploring the model, use [simulated events](./simulate-usage-data) in test mode. You can validate the subscription and invoice behavior before connecting a production data source. ### 2. Create an aggregator Go to **Usage** > **Aggregators**, then click **New aggregator**. An aggregator defines how Hyperline turns raw events into a billable number. Configure: * **Event type**: the event category to measure, such as `api_call`, `transaction`, or `storage_snapshot` * **Operation**: how the metric is calculated * **Unit name**: the label shown in usage charts, prices, invoices, and the customer portal * **Filters**: optional rules that include only matching events | Operation | Use it when | | --------------- | ------------------------------------------------------------------------------------------------ | | **Count** | Each matching event should count as one unit, such as one API call or one transaction. | | **Sum** | A numeric field on the event should be added up, such as gigabytes stored or compute minutes. | | **SQL formula** | You need a custom calculation, such as applying an allowance, cap, or adjustment before billing. | Learn more in [Aggregators](./aggregators). ### 3. Create a usage product Go to **Products**, click **New product**, then choose **Usage**. When configuring the product: 1. Add the product name and description. 2. Select the aggregator you created. 3. Configure at least one recurring price. 4. Choose the pricing model and tiers that match your commercial offer. 5. Save the product. For a simple first setup, use one recurring price with a straightforward rate. You can add advanced pricing later, such as volume tiers, basis points, or price-level metering filters. Usage products are configured in the product catalog, then reused in quotes, subscriptions, and customer-specific agreements. See [Products and prices](/docs/products/overview#usage) for the full product setup reference. ### 4. Add the product to a subscription Once the usage product has a recurring price, assign it to a customer subscription. 1. Open the customer page. 2. Click **Actions** > **Assign new subscription**, or go to **Subscriptions** and click **New subscription**. 3. Select the customer and subscription start date. 4. Click **Add product** and select the usage product. 5. Review the product price, billing interval, and metering settings. 6. Open **Payment settings**. 7. For testing, choose **Manually later** so the subscription can be created without collecting payment immediately. 8. Click **Assign subscription**. After the subscription is assigned, Hyperline starts tracking usage for the product based on the subscription's metering period. If the customer has both fixed and usage-based charges, add both products to the same subscription. This keeps the recurring fee and usage charges together in the customer's invoice flow. ### 5. Check usage and invoices After events are connected and the subscription is active, validate the setup from the customer page: * Open the customer's **Usage** tab to see current aggregator consumption. * Open the customer's **Subscriptions** tab to review usage on the active subscription. * Click **Explore** or the usage detail icon to inspect the events behind the total. * Open the customer's **Invoices** tab to check the `open` invoice preview for the current period. An `open` invoice is a live preview. For usage-based subscriptions, it updates as new events are recorded. At the end of the billing period, the invoice enters the configured grace period before it is finalized and sent for payment. ## Common first checks If the subscription does not show the usage you expect, check these items first: * The event timestamps fall inside the subscription's current metering period. * The event type matches the aggregator's **Event type**. * The event belongs to the same customer as the subscription. * The aggregator filters do not exclude the events. * The usage product is included in an active subscription. For more invoice behavior details, see [Invoice terms](/docs/invoices/term). ## Next steps Walk through an end-to-end usage-based subscription setup. Learn how count, sum, formulas, filters, and thresholds work. Monitor consumption and inspect the events behind each metric. Understand subscription-level metering periods and usage windows. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Global usage Source: https://docs.hyperline.co/docs/usage/global-usage View aggregator usage across all Hyperline customers from one place, drill into top consumers, and analyze billable metric trends in real time. The **Usage** section gives you a client-wide view of every [aggregator](./aggregators), with a chart per aggregator covering all customers and all subscriptions. From there, you can drill into any aggregator to see which customers are driving its consumption. Access it from the sidebar under **Usages > Usage**. ## Aggregator cards Each aggregator is displayed as a card showing: * **Aggregator name** and unit (e.g. `API calls`, `GB`) * **Total aggregated value** for the selected period across all customers * **Area chart** of the value evolution over time, with one line per [aggregator filter](./aggregators#aggregator-filters) when filters are defined * **Threshold lines** as dashed horizontal references when [thresholds](./aggregators#thresholds) are set on the aggregator Numbers are rendered with a compact format (e.g. `1.2M` instead of `1,200,000`) so cards stay readable at a glance. ## Period and grouping Use the date range picker at the top of the page to select a custom period. You can also choose how data is grouped: | Group by | Best for | | ----------- | ------------------------------------------------------------------------ | | **Monthly** | Long-term trends (presets: last 3/6/12 months, current/past year) | | **Daily** | Weekly or monthly analysis (presets: this/last week, current/past month) | | **Hourly** | Intraday monitoring (presets: today, yesterday, this/last week) | Presets adapt to the selected grouping. Filter values are persisted in the URL, so a view can be shared by copying the link. ## Sorting and search Sort cards alphabetically by name, ascending or descending. Use the search box to narrow the list when you have many aggregators. ## Group by customer Click **Explore consumption** on any usage card to open a side panel. It ranks customers by their contribution to the aggregator over the selected period. The panel shows: * **Customer** — name and link to the customer's profile * **Value** — that customer's aggregated total for the period (compact format) Rows are ordered by total descending (top consumers first) and paginated 20 at a time. The date range and grouping are inherited from the parent page; you can refine the breakdown to a single [aggregator filter](./aggregators#aggregator-filters) using the filter selector. The explore panel allows you to compare contributions across multiple filters, switch the selected filter or open the panel from a different aggregator card. ## Aggregator details From the card's dropdown menu, you can open the aggregator's detail page to review its configuration (operation, event type, filters, thresholds) or edit it. See [Aggregators](./aggregators) for the full configuration reference. ## Permissions Access to the **Usage** section is gated by the `usages_read` permission. Manage permissions per role from **Settings > Roles**, under the **Usage** group. Existing roles that already had the `events_read` permission were granted `usages_read` automatically. New roles must opt in. ## Related * [Aggregators](./aggregators) — define how raw events become a billable metric * [Customer usage](./customer-usage) — same charts scoped to a single customer * [Explore your data usage](./explore-usage-consumption) — drill into raw events from a subscription or invoice # Import events with a CSV file Source: https://docs.hyperline.co/docs/usage/import-events-csv Import usage events into Hyperline in bulk by uploading a CSV file from Google Sheets, Excel, or any spreadsheet editor with required fields. You can import events in bulk by uploading a CSV file. You can create your CSV using tools like **Google Sheets**, **Excel**, or any spreadsheet editor.\ Writing the CSV manually is possible but **not recommended** due to the risk of formatting mistakes. ## Required fields Each event row must include: * **`timestamp`** — When the event occurred, in **ISO 8601** format. * **`event_type`** — The name of the event. This value is flexible and later used when configuring your products. * **`customer_id`** * **`record/id`** — A unique identifier for the event.\ Uploading another event with the same `record/id` will overwrite the previous one. ## Custom fields You can add as many custom fields as needed. All custom fields must start with the prefix **`record/`**.\ For example, to create a field named `count`, name the column **`record/count`**. ## Upload your file To begin, open the **[Events Explorer](https://app.hyperline.co/app/events/explore)** in Hyperline. Click **Import events from CSV** in the top-right corner to open the upload modal. You can also download a **CSV template** from the same modal.\ The template includes the correct header row and a sample event to help you get started. After selecting your file, click **Import CSV file** to start the upload.\ If the file contains no errors, your events will be imported and ready for analysis. ## Manually writing the CSV file When preparing your CSV file, make sure it follows these rules: * Use **commas** as field separators. * Wrap fields in **double quotes** if they contain commas or line breaks. * Always include a **header row** to describe each column. * Use the **ISO 8601** format for the `timestamp` field. * Use a consistent format for nested fields, such as `record/id` or `record/amount`. * All standard fields are required. `record/` fields are optional and as many as needed can be declared. ### Example Below is an example of a valid CSV file.\ (`record/type` and `record/is_live` are only examples—you can define your own fields.) ```csv theme={null} timestamp,event_type,record/id,record/type,record/is_live,customer_id "2023-11-07T13:59:40.536Z",api_call,1245,"paid",true,"cus_foXtwuyW7NsCH-" "2023-11-07T13:59:40.536Z",api_call,1152,"to_pay",true,"cus_foXtwuyW7NsCH-" "2023-11-07T13:59:40.536Z",api_call,8625,"pending",false,"cus_foXtwuyW7NsCH-" "2023-10-18T15:53:24.772Z",api_call,9752,"closed",true,"cus_foXtwuyW7NsCH-" "2023-10-18T15:53:24.772Z",api_call,7052,"open",true,"cus_foXtwuyW7NsCH-" ``` Notes: * `record/id` is numeric and does not require quotes. * String fields (such as `record/type`) must be enclosed in quotes. * Boolean fields (such as `record/is_live`) do not require quotes. # Connect with MongoDB Source: https://docs.hyperline.co/docs/usage/mongodb Connect a MongoDB database to Hyperline as a data loader to pull usage events automatically, without writing custom integrations or API code. This guide is specific to setting up a dataloader with [MongoDB](https://www.mongodb.com), to learn more about data loaders in general, you can read our [general article](./usage-data-with-connectors). ## Connect to your database To get started, just go to the [data loaders page](https://app.hyperline.co/app/events/loaders) in Hyperline, create a new Connection and select "MongoDB" in the dropdown list. To set up our MongoDB connector, you'll just need a valid database URL - you can also pass additional parameters within the URL if you need custom options. ## Load your data Create a new dataloader directly below the new connection, you'll be asked to prompt a JSON query. Your query needs to include a `collection` attribute pointing to your base collection, because, as opposed to traditional SQL providers, MongoDB doesn't allow direct aggregation queries without a default collection. A simple query to load 3 fields from a collection would typically look like this, with everything outside of "collection" being valid MongoDB query fields (you can use aggregate, lookups, filters...). Hyperline will parse the JSON from your input and transform it into a valid MongoDB query to run on the connected server. Make sure to include an `id`, `customerId` and `timestamp` field with the correct casing. # Connect with PostHog Source: https://docs.hyperline.co/docs/usage/posthog Connect a PostHog Cloud project to Hyperline and import product events into usage-based billing using a scheduled HogQL query data loader. You can connect a PostHog Cloud project to Hyperline and use its product events as usage data. Hyperline runs a [HogQL query](https://posthog.com/docs/sql) on a schedule and imports the results as events. Hyperline supports PostHog Cloud projects hosted in the EU or US. The connection uses read-only query access. ## Connect your PostHog project 1. Go to **Settings** > **Integrations** in Hyperline. 2. Find **PostHog** and select **Connect**. 3. Sign in to PostHog if prompted. 4. Select one PostHog project and authorize Hyperline. After authorization, Hyperline automatically creates a PostHog connection on the [data loaders page](https://app.hyperline.co/app/events/loaders). You do not need to copy an API key or project ID. ## Create a data loader 1. Go to the [data loaders page](https://app.hyperline.co/app/events/loaders). 2. Select **New data loader**. 3. Choose the PostHog connection created for your project. 4. Enter the event type that Hyperline should use for the imported records. 5. Choose how often Hyperline should refresh the data. 6. Enter a HogQL query and preview the results. Your query must return these fields with the exact casing: * `id` — a stable, unique identifier for the record * `customerId` — the Hyperline customer ID or external ID associated with the record * `timestamp` — when the event occurred For example, the following query imports PostHog events named `api_call`: ```sql theme={null} SELECT uuid AS id, distinct_id AS "customerId", timestamp, properties.endpoint AS endpoint FROM events WHERE event = 'api_call' ``` In this example, each PostHog `distinct_id` must match a Hyperline customer ID or external ID. You can select additional event properties when you need them for aggregation or pricing. Filter the query to include only billable events and properties. This keeps each refresh focused on the data Hyperline needs for billing. 7. Check that the preview contains the expected customers and records. 8. Save the data loader. Hyperline imports the query results on the selected schedule. For more information about customer matching, record updates, and required fields, see [Pull usage data with connectors](./usage-data-with-connectors). ## Next steps * [Configure aggregators](./aggregators) * [Explore usage consumption](./explore-usage-consumption) * [View customer usage](./customer-usage) # Send usage data Source: https://docs.hyperline.co/docs/usage/send-usage-data Send usage events to Hyperline through the API to drive usage-based billing, with guidance on event design, payload structure, and best practices. Sending usage data is the first thing to do to unlock Hyperline's potential when you have a usage-based model, but there are a few tips to make the most out of our system. First, **we're not an analytics API**, sending us page views, user logins or other non-critical events doesn't really make sense as you probably won't use them for your pricing and packaging anyway. This being said, you shouldn't refrain from sending data that you're not using yet. Hyperline is designed for you to iterate on your pricing & packaging and will allow you to run experiments and simulations from the data we have ingested. The best way to think about events to send us is to ask yourself if you'll use the data either * To price your product (ex: price per user or per API call) * Limit usage (ex: free up to 5GB of storage) * Orchestrate pricing-related workflows (ex: when a customer reaches X, show a paywall). When in doubt, just send it, once it's in the system, you'll be able to play with it and may discover some new opportunities. ## Ingestion basics Event payloads always follow the same structure and can be sent to the [POST `/events` endpoint](../../api-reference/endpoints/billable-events/ingest-billable-event). The `record` object can contain any additional properties of type `string`, `number`, `boolean`, and array of these types but arrays of objects will be rejected. Events are processed instantly, you can go to your [events page](https://app.hyperline.co/app/events/explore) and refresh it to see it. The events ingestion API is rate-limited to 1,000 requests per 10 seconds. When sending events in batch, each request can contain up to 5,000 events. See [rate limiting](/api-reference/docs/rate-limiting) for more details. Here's an example payload: ```json Event theme={null} { "customer_id": "cus_fh4585Jjrekkk", "timestamp": "2022-01-05 21:56:52", "event_type": "new_transaction", "record": { "id": 485, "amount": 2500 } } ``` ## Security and privacy Even though we make some basic security checks, we can't filter every piece of personal or confidential data from our systems automatically. Most of the time you don't need personal information in Hyperline so we recommend you remove or obfuscate (for instance, John becomes J\*\*\*). * People names * People's personal email addresses * Phone numbers * Payment information like card numbers or IBANs * Physical addresses * Anything that could help identify someone's identity or location In our systems, we're responsible for keeping your data safe, but you're in charge of the content itself, so be careful, your customer's safety is an important matter. ## Events or entities? Hyperline is designed to rely fully on events for data ingestion. We can then apply a variety of operators to configure how you want to aggregate data (count, sum), and filters (equals, "is null" check, greater/lower than comparators, etc.). In the first case, Hyperline will treat your events as *entities* or *models*, meaning that one event will represent one item in our database, independently of its timestamp. For instance, let's say you want your customer to pay 5€ per user, you'll send us the following *event* when a new user is registered. ```json Event theme={null} { "customer_id": "", // Hyperline ID or external ID of the existing customer "timestamp": "2023-11-12T00:00:00.000Z", // used to aggregate depending on the billing period "event_type": "users", // use the name you want "record": { "id": 258, "work_email": "l***.c***@yourcompany.com", "created_at": "2023-11-12T00:00:00.000Z", "deleted_at": null // we'll use this field later } } ``` Then you'll create a dynamic product that counts your users, and apply a volume pricing to it by defining an interval and the related pricing tiers. We offer you a preview of the evolution of this pricing to make it more visible regarding how it evolves with the increase of items. ## Update and delete events Now you may be thinking, what happens if I send an event that shouldn't be billed? Or if you need to make a change to an entity? Hyperline's API is an append-only system, meaning that except through our interface, we don't allow update or delete operations. But don't worry, we got you covered. ### Updating an event Each event is identified by a unique key composed of 2 parameters: * `event_type` * `record.id` When Hyperline detects a new event with the exact same 2 keys, it will consider that this new event overrides the previous one and therefore will replace it in the database. In other words, updating an event is just like creating one — resend the event with the same `event_type` and `record.id`, and the matching event will be replaced. To find out which event is the latest, we're using the `timestamp` value. Only the `record` (payload) and `timestamp` fields are updated when resending an event. The `customer_id` and `event_type` fields are **immutable** — they remain as set by the original event and are ignored on update. If you need to change the customer associated with an event, delete the original event and create a new one. Using our users again, here's an example where we add a "status" property: ```json theme={null} { "customer_id": "", "timestamp": "ACTIVE_DATE", "event_type": "users", "record": { "id": 258, "status": "premium", "work_email": "l***.c***@yourcompany.com", "created_at": "2022-01-01 10:00:00", "deleted_at": null } } ``` The event in the database will now have a `premium` status and the previous version will not exist anymore. If you need to keep both versions, you'll need to provide a different `record.id`. ### Deleting an event If you sent an event by mistake, you can delete it in the **Events** tab on the app. But this is not the way to manage *standard* deletions, for instance when a user is removed from an account. There are many ways to manage this, the first one is to use the `deleted_at` key we added earlier and set it to something different than `null`. Then update the usage product we created earlier to filter out records where `deleted_at` is not null like so. Another option is to use a state or a flag in the model, for instance, an `active` boolean field in the user entity that you can toggle to off. The principle stays the same, just set a property to the right value and filter out the elements you don't want. ## Retrieve events via API You can retrieve billable events programmatically using the [GET `/v1/events` endpoint](../../api-reference/endpoints/billable-events/get-events). This allows you to: * Query events by event type * Filter by customer, record IDs, or timestamp range * Sort results in ascending or descending order * Paginate through large result sets This is useful for building custom analytics, auditing usage data, or integrating event data into your own systems. ```bash Example request theme={null} curl -H "Authorization: Bearer " \ "https://ingest.hyperline.co/v1/events?event_type=api_call&customer_id=cus_xyz789×tamp_gte=2024-01-01T00:00:00Z" ``` ## Limitations In order to process massive numbers of events, Hyperline had to adopt a *rigid* structure for events. While quite permissive, there are 2 main limitations: * Record properties can't be nested (only one level of properties is allowed) * Records can't have more than 25 properties # Simulate usage data Source: https://docs.hyperline.co/docs/usage/simulate-usage-data Simulate usage events in Hyperline's sandbox without code to test usage-based subscriptions and explore billing behavior before going to production. Want to test Hyperline by creating your first usage-based subscription for a customer, but don’t have technical skills or simply want to move fast? This guide is for you. In the [sandbox (Test mode) environment](https://sandbox.app.hyperline.co), you can simulate usage data with fake events for any customer in just a few steps. 1. Go to one of your customers → ***Events*** tab 2. Click ***Simulate new events*** 3. Fill in the ***Event type*** field with the event name used to aggregate usage in your product configuration, along with the date and number of events to create. Optionally, you can add extra parameters using the JSON ***Payload*** field 4. Click ***Create new events*** Events may take a few seconds to be ingested. You’ll see them appear in your customer’s ***Events*** page — and you can easily delete them afterward if needed. You can also view the customer’s subscription usage details and updated next payment amount in the ***Subscription*** tab, and check the ***open*** invoice (the next invoice to be charged at the end of the billing period) in the ***Invoices*** tab. Note: it may take a few minutes for the invoice to appear. # Connect with Snowflake Source: https://docs.hyperline.co/docs/usage/snowflake Connect a Snowflake warehouse to Hyperline as a data loader to pull usage events automatically, with credentials and query configuration steps. This guide is specific to setting up a dataloader with [Snowflake](https://www.snowflake.com), to learn more about data loaders in general, you can read our [general article](./usage-data-with-connectors). ## Connect to your database To get started, just go to the [data loaders page](https://app.hyperline.co/app/events/loaders) in Hyperline, create a new Connection and select "Snowflake" in the dropdown list. Fill in the form with your connection details (account ID, username, warehouse, database, schema, role). Hyperline will only need read access to the tables you need to synchronise. ### Authentication Hyperline supports two authentication modes for Snowflake, selectable from the **Authentication** dropdown in the connection form: * **Password** — authenticate with the Snowflake user's password. * **Key pair (RSA)** — authenticate with an RSA private key that is registered on the Snowflake user. Snowflake is [deprecating single-factor password authentication on August 31, 2026](https://www.snowflake.com/en/blog/blocking-single-factor-password-authentification/). If your connection uses a password today, plan to migrate to key-pair authentication (or another supported method) before that date to avoid disruption. #### Password authentication Select **Password** and enter the user's password in the **Password** field. #### Key pair (RSA) authentication Select **Key pair (RSA)** and provide: * **Private key** — the RSA private key registered on the Snowflake user, in PEM format. Paste the full key including the `-----BEGIN PRIVATE KEY-----` and `-----END PRIVATE KEY-----` lines (or the encrypted equivalent). * **Private key passphrase** *(optional)* — the passphrase protecting the private key, if it is encrypted. Leave empty for unencrypted keys. Refer to Snowflake's [key-pair authentication guide](https://docs.snowflake.com/en/user-guide/key-pair-auth) for instructions on generating a key pair and assigning the public key to a Snowflake user. ## Load your data Snowflake is a standard SQL loader and you just need to write a Snowflake compatible SQL query. Hyperline will run it as the role/user that was used to connect to the database. As always, make sure to include `id`, `customerId` and `timestamp` fields with the correct casing. # Pull usage data with connectors Source: https://docs.hyperline.co/docs/usage/usage-data-with-connectors Pull usage data from your own database into Hyperline using connectors for PostgreSQL, BigQuery, Snowflake, and MongoDB without writing API code. If you don't fancy integrating our API, we have released a connector system allowing you to import data directly from your own database. ## Prerequisites * You need a Postgres database that can receive incoming traffic from our IPs `15.188.105.163`, `15.188.215.105` and `35.181.129.14` * The associated database URL (should look something like `postgres://username:password@host.com/database`) The best practice here is to use a read replica and create a limited user specifically for us that will only be able to access the needed subset in the database. ## Load your data To get started, just go to the [data loaders page](https://app.hyperline.co/app/events/loaders) in Hyperline. You should see an empty state. Let's add your first connection by clicking on "New connection". In the modal, * Select a provider * Give a name you'll remember to your connection * Enter the URL you got from the prerequisites When you click submit, we do a quick check to make sure your database is accessible by running a blank query. You should now see your connection live. Time to create your first loader by clicking on "New data loader" on the right side of the screen. This opens up a slightly longer modal but don't worry, it's really easy. * Select the connection you just created * Set an Event type for this query, it's the identifier we'll use later in the product to refer to the data from this query. It could be `api_calls` or `active_users` for instance * Select the refresh rate depending on your use case, to get started every hour is largely sufficient ## Getting the SQL right Now it's time to start typing your query. Hyperline will need a few things from you and expect a specific format as the query output. We'll need 3 fields to validate the query: * `timestamp` — The date used to determine whether a record falls within a billing period. For example, if you bill monthly API calls, only events with a timestamp within the current billing cycle are included. This field is less critical if your pricing does not rely on periodic metering. * `customerId` — The Hyperline ID or external ID of the customer. This field is used to associate each record with the corresponding customer. * `id` — A unique identifier for the record (can be an ID from your system). Hyperline uses this field to de-duplicate and update records, so ensure it uniquely represents each record. When importing records, Hyperline will try to match an existing customer or create a new one with a status `automatically_created` that won't be displayed by default in your customers list to avoid spam (but you can access them using the `pending customers` table). Optionally, you can also return a `customerName` property so we add a name to the customer when creating it, which will make it easier for you to find them later. To summarise, the minimum acceptable request looks like this ```sql theme={null} -- Make sure to use quotes in postgres to make the query case sensitive SELECT id, company_id as "customerId", created_at as timestamp from api_calls ``` Or to import the customer name ```sql theme={null} -- Adding customer name SELECT id, company_id as "customerId", companies.name as "customerName", created_at as timestamp FROM api_calls LEFT JOIN companies on companies.id=api_calls.company_id ``` That's the minimum for a query to be accepted and loaded into Hyperline. You can then add any other fields to your query, but please make sure you only include what's necessary to keep data sharing to the bare minimum. Then click preview query, we'll validate the presence of the required fields and display a preview of 5 records so you can make sure everything is in order. Save the data loader and go to your events page, after a few seconds, you should see a table with your newly ingested events. We're limiting exploration capabilities for now but will add more features later. See it as a debugger. ### Updating records Hyperline automatically updates existing records, we're using a combination of the supplied `id` and `customerId` and always keep the latest version. We don't update customer names in Hyperline even if the name has changed, you'll need to change it in the interface. ### Deleting records Hyperline doesn't delete records automatically to avoid any issue, we recommend that you add a `deletedAt` field in the query that you set to something when the record is deleted. You'll then be able to filter these records out in our pricing engine. ### Loading big tables Hyperline processes queries in batches, so you should be covered as long as your query is reasonable (we can process up to 120k rows per minute). If your table is bigger than this, consider importing only records that have been updated after the last refresh, or importing them less often. It's actually quite easy. ```sql theme={null} -- Adapt this to your refresh time SELECT xxx FROM table WHERE (updated_at + interval '60 minutes') > NOW() ``` # Manage wallet balance Source: https://docs.hyperline.co/docs/wallets/balance Top up Hyperline customer wallets via prepayment, offline payments, free funds, the customer portal, or the API, and track every wallet movement. ## Top up a wallet There are several ways funds can be added to a customer's wallet: 1. Initiate a prepayment from the customer's default automatic payment method 2. Record an offline payment received outside Hyperline 3. Add free funds 4. Let customers top up independently from the customer portal 5. Top up through the API **Paid top-ups** are funds your customer pays for, acting as a prepayment. **Free top-ups** are an offer you are making to the customer. ### Initiate a prepayment Use **Initiate prepayment** when the customer has a default automatic payment method, such as card or direct debit. Hyperline charges that payment method, adds the funds to the wallet, and generates a confirmation receipt. The receipt has no accounting impact. It confirms that Hyperline received a prepayment and credited the wallet. ### Record an offline payment Use **Record offline payment** when the customer has already paid outside Hyperline, for example by bank transfer. Hyperline adds the funds to the wallet and creates a payment advance document with no accounting value. When recording an offline payment, you can optionally attach: * A bank account * A bank transaction from an Open Banking-connected bank account * A payment reference * An internal comment Only bank accounts using the same currency as the wallet can be selected. ### Free top-ups Use **Add free funds** when you want to credit a wallet without collecting payment. Hyperline adds the funds to the wallet and creates a credit note for accounting purposes. You can create the credit note immediately or keep it as a draft first. Free wallet loads must be enabled in wallet settings before free funds can be added. ### API top-ups Wallets can also be topped up through the API. Use the API when wallet loads should be triggered by your own product, backend workflows, or internal tooling. ### From the customer portal You can let your customers top up independently through their portal. For this, you have to go to the [wallet settings](./overview) first. **Top-up limitations** It is currently not possible to add more than \$100 in one payment to a wallet, and the total balance of a wallet can't be more than \$500 for payments made through a customer portal. Paid top-ups added through Hyperline have no limitations. They will be required to add a credit card as a payment method to do so. Clicking on **Top-up** on this screen will trigger an immediate payment from the registered credit card and credit the wallets instantly. Invoices can be downloaded as PDF by the customer. ## Wallet debit Customer wallets are automatically debited when the feature is enabled in the wallet settings and the wallet has a positive balance. Wallet funds are used to pay subscriptions, related invoices, and one-time payments. A wallet cannot have a negative balance. Hyperline automatically deducts the maximum possible amount from the wallet when paying invoices. Any remaining amount is charged to the customer's default payment method. You can also charge a specific invoice from the customer's wallet manually. In that case, choose the amount to charge, up to the lower of the invoice amount due and the current wallet balance. An invoice can combine multiple payment sources (e.g. wallet + credit card), and this breakdown is displayed on the generated PDF invoice. ## Revert a wallet transaction You can revert wallet top-up transactions to remove funds that were previously added to a customer's wallet. Only top-up transactions (credit transactions) can be reverted. Debit transactions (consumption) cannot be reverted. ### How it works When you revert a wallet transaction: * The credited amount is deducted from the current wallet balance * If the transaction was a **free top-up**, the related credit note is voided * If the transaction was a **paid top-up**, the amount is deducted from the wallet balance. If you need to refund the initial banking transaction, this must be done outside of Hyperline ### Requirements A transaction can only be reverted if: * It is a top-up transaction (not a debit/consumption transaction) * It has not already been reverted * The wallet has sufficient balance to cover the reversal amount Make sure the wallet balance is sufficient before reverting a transaction. If the balance is too low, the revert action will fail. ## Wallet balance & projection Wallet balances are computed in real time in Hyperline. In addition to the wallet balance, we also compute and return a projected balance. This balance takes into account a projection of the future remaining money on the wallet after paying what will be due in the current period (subscription, usage). This is particularly useful for a pay-as-you-go use case when you want to restrict access to your product if the customer doesn't have enough funds in their wallet. # Wallets overview Source: https://docs.hyperline.co/docs/wallets/overview Manage customer prepaid balances in Hyperline wallets — top up funds, auto-apply to invoices, and support upfront billing or pay-as-you-go flows. Hyperline wallets let you manage customer balance: prepaid funds that you or your customers can add and automatically apply when invoices are paid. This feature is particularly useful for setting up upfront payments in pay-as-you-go flows or offering free funds to your customers. Each customer can have their own wallet in their preferred currency. A wallet cannot have a negative balance. ## Wallet settings Configured at the account level (in the **Settings** > **Wallets** page), these settings apply to all customer wallets. By default, the wallet feature is disabled. To activate it, navigate to your settings. ### Free top-up This option allows you to add funds directly to your customers' wallets at no additional cost. When adding free funds to the wallet, a corresponding credit note is generated for accounting purposes. ### Top-up from customer portal This option allows your customers to add funds using their current payment method directly through their portal. An active and valid payment method is required for the top-up to be successful. ### Eligible products You can select the products to which you want the wallets to apply when paying invoices. By default, the wallets apply to all products (i.e., the full invoice amount). ## Create a wallet for a customer Now that you have enabled wallets on the settings page, you can create wallets for your customers in Hyperline. To do this, go to the **Customers** page in Hyperline's main menu. Navigate to the **Wallet** tab and click **Create wallet**. ## Manage wallet You can decide to edit the configuration of a customer wallet. Go to a customer page > **Wallet** tab > **Actions** > **Edit wallet**. ### Update name Wallet name can be updated. This name is used to easily identify the wallet depending on your use case. This name will appear on the final invoice when the wallet is used as a payment method to pay the invoice. ### Auto top-up You can choose to set up an automatic top-up for a customer's wallet at a specified interval. Simply configure the amount, the interval, and the next top-up date for this automated fund addition. Funds are added to the existing wallet balance. ### Pause wallet You can choose to pause the use of a wallet for a specific customer. When paused, the wallet will no longer be used to pay future invoices. You can reactivate the wallet at any time. ## Pay-per-use If your customers are paying depending on their use of your services, you can provide them with a wallet so they have an upfront payment solution. **Example** One API call costs your customer 1 cent. If you activate the wallet, your customer will be able to top up their wallet in advance. They can then pay upfront for as much as they want and use your services until their wallet balance runs out. ## Managing zero balances If you allow your customers to top up their wallets, we recommend you think about a flow to warn them before their wallet balance reaches 0. This is especially relevant if reaching a zero balance interrupts their services. You can use [our webhooks](/api-reference/docs/webhooks) to monitor wallet activity. # Getting started Source: https://docs.hyperline.co/guides/ai Connect Claude, ChatGPT, Cursor, and other AI assistants to Hyperline using MCP, the CLI, and reusable skills for common billing workflows. AI assistants can help you explore Hyperline, build integrations, and automate billing workflows. Hyperline supports several AI-friendly entry points depending on where your assistant runs and what it needs to do. ## Choose how your AI assistant works with Hyperline Connect assistants such as Claude, ChatGPT, Cursor, and VS Code to your Hyperline account through MCP. Use the agent-first CLI for terminal-based assistants and scripts. ## Reusable skills Skills are reusable instructions that help an AI assistant perform a specific Hyperline workflow reliably. They combine the exact API shape, required inputs, and caveats the assistant should respect. This section collects practical skills you can copy into your own AI assistant or agent workspace. | Skill | Use it for | | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | | [Create a subscription from a template](/guides/ai/create-subscription-from-template) | Create a subscription from a template while preserving template configuration. | | [Create an invoice](/guides/ai/create-invoice) | Create draft or payable invoices with explicit line items and status. | | [Create a quote from a template](/guides/ai/create-quote-from-template) | Create a quote from a quote template and optionally set custom properties on the subscription created from that template. | | [Build an insights report](/guides/ai/build-insights-report) | Answer revenue, invoice, subscription, and usage reporting questions. | | [Investigate a customer balance](/guides/ai/investigate-customer-balance) | Reconcile customer balances, invoices, wallets, credits, and payments. | | [Answer a billing question](/guides/ai/answer-billing-question) | Answer Hyperline billing questions with docs and read-only account checks. | | [Bulk update subscriptions](/guides/ai/bulk-update-subscriptions) | Plan, confirm, apply, and verify bulk subscription changes safely. | ## Next steps * Use [Hyperline MCP](/api-reference/docs/ai/mcp) when your assistant supports MCP and needs to read or write Hyperline data. * Use [Hyperline CLI](/api-reference/docs/ai/cli) when your assistant can run shell commands. * Copy a skill into your agent instructions when you want repeatable behavior for a known workflow. # Answer a billing question with AI Source: https://docs.hyperline.co/guides/ai/answer-billing-question AI skill that answers Hyperline billing questions by combining product documentation with read-only checks against your live account data. Use this skill when an AI assistant needs to answer a question about a billing workflow, a customer account state, or how to use Hyperline. ## Skill ```md theme={null} --- name: answer-billing-question description: Answer a Hyperline billing question using documentation and read-only data checks. Use when an agent needs to explain subscriptions, invoices, payments, quotes, usage, credits, wallets, analytics, custom properties, or API behavior. --- # Answer Billing Question Start with documentation. Use account data only when the answer depends on the customer's current state. ## Inputs Collect: - The user's question. - Environment: production or sandbox if account data is needed. - Relevant entity IDs, names, or URLs if the question is about a specific customer, subscription, invoice, quote, or product. ## Workflow 1. Classify the domain: subscriptions, invoices, payments, quotes, usage, credits, wallets, analytics, custom properties, integrations, or API. 2. Read the most relevant Hyperline documentation or API reference. 3. If the question depends on live data, run read-only MCP, CLI, or API calls to inspect the relevant records. 4. Answer directly. 5. Include links to the most relevant docs when they help the user act. 6. Separate confirmed facts from assumptions. ## Output Return: - Short answer first. - Then the explanation or steps. - Then docs links or checked records. - Then any caveats. ## Safety - Do not change account data while answering a question unless the user explicitly asks and confirms the exact action. - Do not expose internal implementation details. - Do not invent IDs, statuses, or product names. - If data is ambiguous, say what is ambiguous and ask for the missing identifier. ``` ## Related documentation Use Hyperline's AI-friendly documentation entry points. Learn the API basics. # Build an insights report with AI Source: https://docs.hyperline.co/guides/ai/build-insights-report AI skill for building revenue, invoice, subscription, and usage insights reports by querying Hyperline analytics and billing data. Use this skill when an AI assistant needs to answer a reporting question such as MRR, ARR, revenue movement, invoice health, overdue invoices, or subscription trends. ## Skill ```md theme={null} --- name: build-insights-report description: Build a Hyperline billing or revenue insights report. Use when an agent needs to answer reporting questions with read-only API, MCP, or CLI calls across analytics, subscriptions, invoices, customers, and usage data. --- # Build Insights Report Default to read-only operations. ## Inputs Collect these values before querying data: - Report question: what the user wants to know. - Timeframe: e.g. current month, previous quarter, last 12 months. - Environment: production or sandbox. - Optional filters: customer, plan, product, currency, subscription status, invoice status, or segment. - Output format: short answer, table, CSV-ready data, or executive summary. If the timeframe is ambiguous, ask a short clarification before querying. ## Data sources Start with the narrowest source: - `GET /v1/analytics` for revenue metrics and high-level KPIs. - `GET /v2/subscriptions` for subscription lists, statuses, plans, renewal dates, and quote links. - `GET /v1/invoices` for invoice status, due dates, amounts, and payment health. - `GET /v2/customers/{id}` or `GET /v2/customers` for customer context. - Usage endpoints when the question is about usage-based billing or consumption. Use MCP or CLI equivalents when the user's agent environment already has them configured. ## Workflow 1. Restate the metric definition in one sentence. 2. Query only the data needed for that definition. 3. Use pagination for list endpoints. 4. Keep raw IDs in working notes, but present names and links when available. 5. Separate facts from interpretation. 6. Call out gaps, filters, or assumptions. ## Output Return: - Answer first. - Then a small table when it helps. - Then methodology: endpoints, filters, and timeframe. - Then caveats or recommended follow-up. ## Safety - Do not mutate data. - Do not infer cash collection from invoice issuance; check payment or transaction status when the question is about cash. - Do not mix sandbox and production data. - Do not compare periods with different currencies unless the user asked for a multi-currency view. ``` ## Related documentation Use analytics metrics for high-level reporting. Learn how Hyperline analytics are organized. # Bulk update subscriptions with AI Source: https://docs.hyperline.co/guides/ai/bulk-update-subscriptions AI skill for planning, confirming, applying, and verifying bulk subscription updates in Hyperline without breaking customer billing. Use this skill when an AI assistant needs to update many subscriptions with the same change, such as adding a product, changing pricing, or transitioning subscriptions to a new configuration. ## Skill ```md theme={null} --- name: bulk-update-subscriptions description: Plan and execute safe bulk subscription updates in Hyperline. Use when an agent needs to identify subscriptions, preview or apply transitions, update subscriptions, and verify results across many records. --- # Bulk Update Subscriptions Bulk updates can affect billing and invoices. Plan first, execute only after explicit confirmation. ## Inputs Collect these values before making changes: - Target cohort: filters, customer list, subscription IDs, plan, product, status, or segment. - Desired change: product, price, phase, template, billing behavior, or contract change. - Effective date: immediately or scheduled date. - Billing behavior: no charge, pro-rata charge, custom charge, or keep current billing cycle. - Dry-run requirement: default to preview or sample first. ## Workflow 1. List candidate subscriptions using read-only filters. 2. Show the count and a small sample. 3. Ask the user to confirm the exact cohort before mutation. 4. Choose the safest update method: - Use `PUT /v2/subscriptions/{id}` for simple full-subscription updates with no transition invoice. - Use `POST /v2/subscriptions/transitions` when billing behavior, schedule, or pro-rata handling matters. - Use template-based transition only when subscriptions still match the source template and the template has already been updated. 5. Preview where possible. 6. Apply in bounded batches. 7. Verify updated subscriptions and summarize successes and failures. ## Safety - Never run an unbounded update. - Never mutate before showing the matched cohort and receiving confirmation. - Do not use deprecated incremental update endpoints. - Do not assume no invoice will be generated; choose and document the billing behavior. - Stop on repeated failures and summarize the partial result. ## Output Return: - Cohort definition. - Update method. - Billing behavior. - Batch result summary. - Failed subscription IDs with errors. - Verification checks performed. ``` ## Related documentation Learn the supported bulk update patterns. Use transitions for controlled subscription changes. # Create an invoice with AI Source: https://docs.hyperline.co/guides/ai/create-invoice AI skill for creating draft or payable Hyperline invoices through the public API with explicit line items, customer, currency, and status. Use this skill when an AI assistant needs to create an invoice with one or more line items through the public API. ## Skill ````md theme={null} --- name: create-invoice description: Create a Hyperline invoice through the public API. Use when an agent needs to draft or execute a POST /v1/invoices payload with customer_id, explicit status, line_items, payment settings, and optional custom properties. --- # Create Invoice Use the public API endpoint `POST /v1/invoices`. ## Inputs Collect these values before calling the API: - `customer_id`: Hyperline customer ID. - `status`: usually `draft` or `to_pay`. - `line_items`: at least one line item. - Optional `currency`, `subscription_id`, `due_at`, `emitted_at`, `payment_method_strategy`, `custom_properties`, `purchase_order`, and invoice notes. If the user gives product names instead of IDs, resolve product IDs first. Do not guess. ## Payload Draft invoice with a catalog product: ```json { "customer_id": "cus_xxx", "status": "draft", "line_items": [ { "product_id": "prod_xxx", "units_count": 1, "unit_amount": 10000, "tax_rate": 20 } ] } ``` Draft invoice with an ad hoc line item: ```json { "customer_id": "cus_xxx", "status": "draft", "currency": "EUR", "line_items": [ { "name": "Implementation fee", "unit_amount": 50000, "units_count": 1, "tax_rate": 20 } ] } ``` Call shape: ```bash curl -X POST "https://api.hyperline.co/v1/invoices" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '' ``` ## Safety - Always set `status` explicitly. Use `draft` unless the user clearly wants the invoice issued. - Do not set `paid` unless the user explicitly says the invoice is already paid. - Use `payment_method_strategy: "external"` only when payment is handled outside Hyperline. - Include `subscription_id` only when the invoice should be linked to an existing subscription. ## Verify After creation: 1. Read `id`, `status`, `customer_id`, `amount_excluding_tax`, and `amount_including_tax` from the response. 2. Fetch `GET /v1/invoices/{id}` if you need to confirm line items. 3. If the invoice should be sent or charged, ask for explicit confirmation before taking the next action. ```` ## Related documentation See the public API endpoint for creating invoices. Learn how invoices work in Hyperline. # Create a quote from a template with AI Source: https://docs.hyperline.co/guides/ai/create-quote-from-template AI skill for creating a Hyperline quote from a template while preserving terms, attachments, contract documents, and optional draft subscription updates. Use this skill when an AI assistant needs to create a quote from an existing quote template through the public API. The quote template provides the quote defaults, terms, attachments, contract documents, and subscription configuration. You can optionally update the draft subscription created from the template after the quote has been created. ## Skill ````md theme={null} --- name: create-quote-from-template description: Create a Hyperline quote from a quote template through the public API while preserving template terms, attachments, and contract documents. Use when an agent needs to draft or execute a quote from template workflow, optionally updating subscription custom properties, dates, products, phases, coupons, discounts, prices, or seats on the draft subscription after creation. --- # Create Quote From Template Use the public API endpoint `POST /v1/quotes`. ## Inputs Collect these values before calling the API: - `customer_id`: Hyperline customer ID. - `template_id`: quote template ID. - Optional `custom_properties`: key/value map using custom property slugs as keys. - Optional subscription overrides such as contract dates, products, phases, coupons, discounts, prices, or seats. - Optional quote-level overrides such as `owner_email`, `expires_at`, `status`, display fields, or collection requirements. If the user gives custom property names instead of slugs, resolve or ask for the slug first. Do not guess. ## Payload Use one call only when the quote should stay exactly on the template subscription configuration, with at most subscription custom properties or trial values. Minimal quote from template: ```json { "customer_id": "cus_xxx", "template_id": "quot_xxx" } ``` Quote from template with subscription custom properties: ```json { "customer_id": "cus_xxx", "template_id": "quot_xxx", "subscription": { "custom_properties": { "sales_segment": "enterprise", "requires_procurement": true, "renewal_owner": "finance", "tags": ["strategic"], "legacy_ref": null } } } ``` Call shape: ```bash curl -X POST "https://api.hyperline.co/v1/quotes" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '' ``` ## Subscription overrides If the user needs subscription overrides such as contract dates, products, phases, coupons, discounts, prices, or seats, use two calls: 1. Create the quote from the template with `POST /v1/quotes`. ```json { "customer_id": "cus_xxx", "template_id": "quot_xxx" } ``` 2. Read `id` and `subscription_id` from the quote response, then update the draft quote subscription with `PATCH /v1/quotes/{id}`. ```json { "subscription": { "custom_properties": { "sales_segment": "enterprise" }, "contract_start": "2026-07-08T00:00:00Z", "phases": [ { "activation_strategy": "start_date", "starts_at": "2026-07-08T00:00:00Z", "end_strategy": "duration", "duration": { "period": "months", "count": 6 }, "billing_date_setting": "phase_start", "products": [], "coupons": [] } ] } } ``` Do not send `terms`, `comments`, or `contract_clause_ids` in the update unless the user explicitly wants to override template content. ## Behavior - `template_id` makes Hyperline create the quote from the quote template. - The quote template supplies the subscription configuration from its linked subscription template or plan. - `subscription.custom_properties` applies values to the draft subscription created from the template. - Provided custom property slugs are updated. Omitted custom properties are left as-is. `null` clears that specific custom property. - Custom property values belong to the subscription, not the quote. - Updating the draft quote with a subscription payload replaces the draft subscription configuration while keeping the quote-level template content created in the first call. ## Do not accidentally replace the template subscription Keep `subscription` limited to `custom_properties` and, if needed, `trial`. Never send `subscription.products` or `subscription.phases` together with `template_id` in the initial `POST /v1/quotes` call. Those fields switch the request into custom subscription mode instead of taking the subscription configuration from the template, which can skip template terms, contract clauses, or contract documents. Other subscription fields are not reliable overrides in pure template mode. If the user needs purchase order, contract dates, products, phases, coupons, discounts, prices, or seats changed, create from the template first, then update the draft quote subscription with `PATCH /v1/quotes/{id}`. ## Quote custom property collection Do not confuse these fields: - `subscription.custom_properties`: values to set on the created subscription. - `collect_custom_property_ids`: quote signature flow asks the customer to fill customer custom properties by ID. Use `collect_custom_property_ids` only when the user wants the signer to provide customer custom properties during signature. ## Verify After creation: 1. Read `id`, `subscription_id`, `terms`, and `attachments` from the quote response. 2. If subscription values were provided or changed, fetch `GET /v2/subscriptions/{subscription_id}`. 3. Confirm `custom_properties` contains the provided slug/value pairs when provided. 4. Confirm the quote still has the expected template terms and attachments before finalizing or sending. ```` ## Related documentation See the public API endpoint for creating quotes. Learn how quote templates work in Hyperline. # Create a subscription from a template with AI Source: https://docs.hyperline.co/guides/ai/create-subscription-from-template AI skill for creating a Hyperline subscription from a subscription template while preserving the template's billing configuration. Use this skill when an AI assistant needs to create a subscription from an existing subscription template through the public API. ## Skill ````md theme={null} --- name: create-subscription-from-template description: Create a Hyperline subscription from a subscription template through the public API. Use when an agent needs to draft or execute a POST /v2/subscriptions payload with customer_id and template_id while preserving the template configuration. --- # Create Subscription From Template Use the public API endpoint `POST /v2/subscriptions`. ## Inputs Collect these values before calling the API: - `customer_id`: Hyperline customer ID. - `template_id`: subscription template ID. - Optional `template_configuration_id`: use only when the user knows the exact template configuration to apply. - Optional `checkout_session`: use only when the user wants to send a checkout session. If the user gives customer or template names instead of IDs, resolve them first. Do not guess. ## Payload Minimal subscription from template: ```json { "customer_id": "cus_xxx", "template_id": "subt_xxx" } ``` With an explicit template configuration: ```json { "customer_id": "cus_xxx", "template_id": "subt_xxx", "template_configuration_id": "stc_xxx" } ``` Call shape: ```bash curl -X POST "https://api.hyperline.co/v2/subscriptions" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '' ``` ## Behavior - `template_id` without `products` or `phases` creates the subscription from the template. - If `template_configuration_id` is omitted, Hyperline resolves the applicable configuration from the customer details. - The created subscription inherits the template's products, phases, billing rules, and pricing. ## Do not accidentally create a custom subscription Do not send `products` or `phases` unless the user explicitly wants a custom subscription configuration. Those fields create a custom subscription and only reference the template for reporting. If the user wants to change prices, products, phases, coupons, or billing cadence, confirm whether they want to update the template first or create a custom subscription payload. ## Verify After creation: 1. Read `id`, `status`, `customer_id`, and `template_id` from the response. 2. Fetch `GET /v2/subscriptions/{id}` if you need to confirm products or phases. 3. Confirm the subscription belongs to the intended customer. ```` ## Related documentation See the public API endpoint for creating subscriptions. Learn how subscription templates work in Hyperline. # Investigate a customer balance with AI Source: https://docs.hyperline.co/guides/ai/investigate-customer-balance AI skill for reconciling a Hyperline customer's balance across their invoices, wallet, credits, payments, and outstanding transactions. Use this skill when an AI assistant needs to explain why a customer balance looks wrong or reconcile what a customer owes. ## Skill ```md theme={null} --- name: investigate-customer-balance description: Investigate a Hyperline customer balance with read-only checks. Use when an agent needs to reconcile customer balance, open invoices, wallet or credit balances, invoice payments, refunds, and recent transactions. --- # Investigate Customer Balance Default to read-only operations. ## Inputs Collect these values before querying data: - Customer ID, external ID, or customer name. - The balance question: outstanding amount, credit balance, wallet balance, payment mismatch, refund, or invoice status. - Timeframe if relevant. - Environment: production or sandbox. If the user gives a name, resolve the customer and confirm when multiple customers match. ## Workflow 1. Get the customer record. 2. List recent invoices for the customer. 3. Check invoice statuses, due dates, totals, outstanding amounts, and related transactions. 4. Check wallet balances and wallet transactions when the question mentions prepaid balance, wallet, top-up, or credit. 5. Check credit balances and credit transactions when the question mentions credits or usage credits. 6. Compare the expected balance against the sum of open invoices, payments, refunds, wallet movements, and credit movements. ## Useful endpoints - `GET /v2/customers/{id}` for customer context. - `GET /v1/invoices` filtered by customer for invoices and status. - `GET /v1/invoices/{id}` for invoice details. - Wallet endpoints for wallet balance and transactions. - Customer credit endpoints for credit products and credit transactions. Use MCP or CLI equivalents when available. ## Output Return: - Direct answer first. - Then a short reconciliation table. - Then the records checked. - Then unresolved gaps or next checks. ## Safety - Do not mark invoices paid, void invoices, issue refunds, or load wallets without explicit confirmation. - Do not assume an invoice is paid because a payment exists; verify final invoice and transaction status. - Do not assume usage credits and wallet balance are the same thing. ``` ## Related documentation Retrieve customer details. Learn how customer balances are represented in Hyperline. # Run Hyperline on autopilot Source: https://docs.hyperline.co/guides/autopilot Use Sentinel, customer intelligence, usage tracking, notifications, exports, and AI assistants to reduce manual checks across revenue operations. Use this guide when you want Hyperline to surface the work that needs attention instead of relying on manual checks across customers, invoices, payments, subscriptions, integrations, and usage. Hyperline has several automation layers. They work best together: Sentinel monitors operational issues, customer intelligence monitors customer signals, notifications route findings to the right teammates, and AI assistants help investigate or execute repeatable workflows when you need more context. ## Choose the right automation layer | Need | Use | Start here | | ---------------------------------------------------- | ------------------------------------ | ------------------------------------------------------------------------------------ | | Detect billing or integration issues | Sentinel | [Sentinel monitoring](../docs/sentinel/overview) | | Monitor customer health, risk, and expansion signals | Customer intelligence | [Customer intelligence](../docs/customer-intelligence/overview) | | Review a specific set of customers automatically | Customer monitoring agents | [Customer monitoring agent](../docs/customer-intelligence/customer-monitoring-agent) | | Route customer updates to the right people | Owners, followers, and notifications | [Owner and followers](../docs/customer-intelligence/owner-followers) | | Track adoption, consumption, and product milestones | Custom usage tracking | [Custom usage tracking](../docs/customer-intelligence/custom-usage-tracking) | | Prioritize collections follow-up | Late payment behavior | [Late payment behavior](../docs/customer-intelligence/late-payment-behavior) | | Answer questions or run assisted workflows | Hyperline AI tools | [AI assistant setup](./ai) | ## What each layer does Watches billing operations and creates tasks for issues such as failed payments, late invoices, disconnected integrations, and subscription errors. Reviews customer context across usage, billing, payments, ownership, support, and communication signals. Shows custom usage metrics on customer records so teams can monitor adoption, consumption, and plan limits. Connects Hyperline to AI assistants through MCP, the CLI, and reusable workflow skills. ## Recommended setup ### 1. Start with Sentinel Use [Sentinel monitoring](../docs/sentinel/overview) for operational issues that should not depend on someone checking lists manually. Sentinel is useful for: * Failed or late payments * Draft or overdue invoices * Disconnected payment providers or integrations * Subscription renewal issues * Electronic invoicing failures Give the right teammates access to Sentinel tasks so operational issues reach the people who can resolve them. ### 2. Add customer intelligence Use [customer intelligence](../docs/customer-intelligence/overview) when you want to prioritize accounts based on customer context, not only billing exceptions. Customer intelligence can help you monitor: * Customers with payment risk or late payment patterns * Accounts with declining or growing usage * Strategic customers approaching renewal * Expansion opportunities based on adoption or consumption * Customers with weak communication or unresolved support signals Create a [customer monitoring agent](../docs/customer-intelligence/customer-monitoring-agent) from **Customers > Monitoring**. Start with **Autopilot** when you want Hyperline to choose the schedule and signal weighting, or use **Advanced** mode when you want to focus the agent on a specific segment or workflow. ### 3. Route findings to owners and followers Assign [owners and followers](../docs/customer-intelligence/owner-followers) so customer findings have a clear audience. Use this when: * Account owners should receive customer health findings * Finance teammates should follow payment-risk segments * Customer success managers should follow strategic accounts * Managers need visibility without becoming the customer owner Each user can also manage notification channels from **Profile > Notifications**. ### 4. Expose usage signals Use [custom usage tracking](../docs/customer-intelligence/custom-usage-tracking) to display product-specific metrics on customer records. Good usage metrics include: * Seats used * API calls * Storage consumed * AI credits spent * Active workspaces * Feature adoption milestones These signals help teams spot adoption risk, upsell readiness, and customers approaching plan limits. ### 5. Connect AI assistants for deeper workflows Use [Hyperline AI tools](./ai) when an assistant needs to investigate, explain, or prepare repeatable revenue workflows. For example, an assistant can help: * Investigate a customer balance * Build an insights report * Answer a billing question * Draft a quote or invoice workflow * Plan a bulk subscription update Use [Hyperline MCP](../api-reference/docs/ai/mcp) when your assistant supports MCP, or [Hyperline CLI](../api-reference/docs/ai/cli) for terminal-based assistants and scripts. ## Example workflows | Workflow | Hyperline setup | | ------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | | A payment provider disconnects | Sentinel creates a task and links to the affected integration. | | A strategic customer has declining usage before renewal | A monitoring agent reviews the customer, combines usage and account context, and can notify the owner. | | A finance team wants to prioritize collections | Create a late payment behavior segment, follow the segment, and use Sentinel for invoice-level payment issues. | | A customer is approaching an AI credit limit | Display the credit or usage metric on the customer record and use customer intelligence to surface expansion context. | | A manager wants a weekly revenue review | Use analytics, exports, and AI assistant workflows to summarize subscriptions, invoices, payments, usage, and customer signals. | ## Next steps * Configure [Sentinel monitoring](../docs/sentinel/overview) for operational issue detection. * Create a [customer monitoring agent](../docs/customer-intelligence/customer-monitoring-agent) for strategic customer segments. * Set up [owners and followers](../docs/customer-intelligence/owner-followers) so findings reach the right teammates. * Connect [AI assistants](./ai) for assisted investigation and repeatable workflows. # Bulk update subscriptions Source: https://docs.hyperline.co/guides/bulk-update-subscriptions Bulk update Hyperline subscriptions through the API: add products, change prices, or adjust contracts on many subscriptions in a single workflow. When you need to apply the same change to multiple subscriptions—such as adding a new product to all customers—you have several options depending on your use case and requirements. ## Overview of methods | Method | Best for | Pros | Cons | | --------------------------------------------------------------------- | ------------------------------------------------ | ------------------------------------------------------ | ------------------------------- | | [Update full subscription](#update-full-subscription) | Simple bulk updates with no pro-rata invoicing | Versioning, no transition invoice, keeps billing cycle | — | | [Create a subscription transition](#create-a-subscription-transition) | Full control with versioning and billing options | Version history, flexible configuration | Advanced setup | | [Incremental update (deprecated)](#incremental-update-deprecated) | Legacy use cases | Simple | No versioning, not future-proof | ## Update full subscription **Recommended for most bulk update scenarios.** The `PUT /v2/subscriptions/:id` endpoint performs an immediate transition while keeping the billing cycle and waiving the transition invoice. This means no pro-rata invoice is generated. You want to add a new "Support" product to all active subscriptions. Using this method, the product is added immediately without generating pro-rata charges, and customers continue on their existing billing cycle. ### How it works 1. Fetch the subscription using `GET /v2/subscriptions/:id` to get its current configuration 2. Add the new product to the subscription phases 3. Call `PUT /v2/subscriptions/:id` with the full updated subscription payload The payload structure matches the response from `GET /v2/subscriptions/:id`, allowing you to retrieve a subscription, modify it, and update it using the same structure. ```sh theme={null} curl -X PUT "https://api.hyperline.co/v2/subscriptions/{subscription_id}" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "phases": [ { "id": "phase_xxx", "products": [ ... { "product_id": "prod_new_product_id", "price": { "type": "flat_fee", "amount": 1000, "interval": "month" } } ], ... } ], ... // Existing subscription payload }' ``` ### When to use * Adding a product to multiple subscriptions without pro-rata billing * Making simple configuration changes across subscriptions * When you want version history with minimal configuration ## Create a subscription transition Use the transition endpoint when you need full control over the update process, including billing options. ### Option A: Pass the full subscription configuration Call `POST /v2/subscriptions/transitions` with the source subscription and target subscription configuration including the new product. ```sh theme={null} curl -X POST "https://api.hyperline.co/v2/subscriptions/transitions" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "source_subscription_id": "sub_xxx", "application_schedule": "immediately", "billing_cycle_transition_method": "keep_current_billing_cycle", "calculation_method": "do_not_charge", "target_subscription": { "phases": [ { "products": [ ... ], ... } ], ... // Existing subscription payload } }' ``` ### Option B: Transition to an updated template/plan If the subscription was created from a template or plan and **has not been customized since**, and you've already updated that template/plan with the new product, you can transition the subscription to use the updated template. You have 100 customers on the "Pro Plan" template. You add a new "Analytics" product to the Pro Plan template. Instead of specifying the full subscription configuration for each customer, you transition each subscription to the updated Pro Plan template. ```sh theme={null} curl -X POST "https://api.hyperline.co/v2/subscriptions/transitions" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "source_subscription_id": "sub_xxx", "application_schedule": "immediately", "billing_cycle_transition_method": "keep_current_billing_cycle", "calculation_method": "do_not_charge", "target_subscription": { "subscription_template_id": "template_xxx" } }' ``` This approach is efficient when many subscriptions share the same template, as you only need to pass the template ID rather than the full subscription configuration. ### Transition options | Parameter | Description | | --------------------------------- | ------------------------------------------------------------------------------------------------- | | `application_schedule` | When to apply: `immediately` or `scheduled` (with `transition_date`) | | `billing_cycle_transition_method` | `keep_current_billing_cycle` to keep current billing dates, `align_to_new_billing_cycle` to reset | | `calculation_method` | `do_not_charge` to skip transition invoice, `pro_rata` to generate pro-rata invoice | ## Incremental update (deprecated) The `POST /v1/subscriptions/:id/update-many` endpoint is deprecated. It lacks versioning and is not future-proof. Use one of the methods above instead. This endpoint allows updating multiple aspects of a subscription in a single call but does not maintain version history. ## Scripting bulk updates To update multiple subscriptions, write a script that: 1. Lists all target subscriptions using `GET /v2/subscriptions` with appropriate filters 2. For each subscription, applies the update using your chosen method 3. Handles errors and retries as needed Use pagination and rate limiting in your script. See the [rate limiting documentation](/api-reference/docs/rate-limiting) for details. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Configure usage-based billing Source: https://docs.hyperline.co/guides/configure-usage-based-billing Step-by-step guide to set up your first usage-based subscription in Hyperline — events, aggregators, products, pricing tiers, and customer assignment. This guide walks you through setting up a complete usage-based billing workflow in Hyperline, from connecting your data to monitoring customer consumption. By the end, you'll have a working usage-based subscription with real-time usage tracking. ## Context You want to bill customers based on their actual consumption of your product or service—such as API calls, compute hours, storage, or any other measurable metric. This guide shows you how to configure this end-to-end using Hyperline's interface. ## Prerequisites Before you begin, make sure you have: * Access to your Hyperline account (we recommend using [test mode](../docs/getting-started/sandbox) for this setup) * Usage data ready to import, or the ability to generate simulated data for testing * A clear understanding of what metric you want to bill (e.g., API calls, GB stored, hours used) When signed up and landed on Hyperline, you can use the [test mode](../docs/getting-started/sandbox) to experiment before going live. ## Steps ### 1. Connect your usage data Hyperline needs usage data to calculate charges for usage-based products. You have three options to connect your data: Upload historical data from a CSV file Send events programmatically via API Connect directly to your database For testing purposes, you can skip this step initially and use [simulated events](../docs/usage/simulate-usage-data) directly in test mode. #### Using data loaders (recommended) Data loaders allow you to pull usage data directly from your database without writing code. This is ideal for connecting to existing data sources like PostgreSQL, BigQuery, MongoDB, or Snowflake. Go to the [data loaders page](https://app.hyperline.co/app/events/loaders) in Hyperline. Click **New connection** and select your database provider from the list. Fill in your database connection information: * Host and port * Database name * Authentication credentials * SSL settings (if required) After connecting, create a new data loader with a SQL query that returns: * `timestamp` - The date and time of the event * `customerId` - Your customer's unique identifier * `id` - The event's unique identifier * Any additional fields you want to track (e.g., `quantity`, `region`, `product_type`) Test your query to ensure data is flowing correctly, then activate the data loader. Learn more about configuring data loaders in our detailed guides: * [BigQuery](../docs/usage/bigquery) * [MongoDB](../docs/usage/mongodb) * [Snowflake](../docs/usage/snowflake) * [General data loaders](../docs/usage/usage-data-with-connectors) ### 2. Create a usage-based product Once your events are flowing into Hyperline, you can create a product that bills based on this usage. Go to [**Products**](https://app.hyperline.co/app/products) and click **New product**. Choose **Usage** as the product type. Fill in the basic product information: * **Name**: A descriptive name for your product (e.g., "API Calls", "Storage GB") * **Description**: Optional details about what this product represents Connect your product to the usage data you want to bill by selecting an [aggregator](../docs/usage/aggregators). If you haven't created one yet, head to **Usage > Aggregators** first. For billing, you link the aggregator to the product and then add that product to a subscription. You do not need to assign the aggregator directly to the customer in its **Visibility** settings. Direct assignment without a subscription is a separate monitoring workflow available with the Customer Intelligence module, and it does not generate charges. The aggregator defines: * **Event type**: Which events to aggregate * **Operation**: How to calculate usage: * **Count**: Count the number of events * **Sum**: Add up a specific numeric property * **Filters**: Optional conditions to narrow eligible events Set up your pricing model: * **Pricing model**: Choose between: * **Volume pricing**: Price per unit changes based on total usage * **Bulk pricing**: All units charged at the rate of the tier reached * **Basis points**: Percentage-based pricing * **Price tiers**: Define your pricing tiers and amounts * Example: $0.10 per unit for 0-1,000 units, $0.08 per unit for 1,001-10,000 units * **Billing interval**: Set when this product should be billed (monthly, quarterly, yearly) Make sure to configure at least one recurring price before moving to the next step. Click **Save** to add the product to your catalog. You want to charge for API calls with volume pricing: * 0-10,000 calls: \$0.01 per call * 10,001-100,000 calls: \$0.008 per call * 100,001+ calls: \$0.005 per call Create a "Count" aggregator on your API event type, link it to your usage product, then set up three pricing tiers with these rates. For detailed information on metering configuration options, see our [usage-based products guide](../docs/subscriptions/metering). ### 3. Create a customer Before assigning a subscription, you need a customer in Hyperline. Navigate to [**Customers**](https://app.hyperline.co/app/customers) and click **New Customer**. Enter the required information: * **Name**: Customer or company name * **Currency**: The currency for billing this customer * **Country**: Customer's country (used for tax calculations) You can add additional details like email, address, and tax information, or update them later. Click **Save customer** to create the customer record. Learn more about customer management in our [customer creation guide](../docs/customers/overview). ### 4. Configure a subscription with the usage product Now you'll create a subscription that includes your usage-based product. From your customer's page, click **Actions** → **Assign new subscription**. Alternatively, go to [**Subscriptions**](https://app.hyperline.co/app/subscriptions/create) and select your customer. Configure when the subscription starts: * **Immediately**: Start billing right away * **In the future**: Schedule for a specific date * **On checkout completion**: Wait for customer to complete checkout Click **Add product** and select the usage-based product you created earlier. Configure the product settings: * **Pricing**: Select or customize the pricing tier * **Metering period**: Choose when usage is measured: * **Same as payment interval**: Usage resets each billing cycle * **Current contract period**: Usage measured over the entire contract * **Custom**: Define a specific metering window * **Min/max amounts**: Optionally set spending limits per billing period * **Committed units**: Set minimum usage commitments if needed (customer pays for at least X units) Click **Next** to access payment settings. For testing purposes, select **Manually later** to create the subscription without immediate payment. For production, choose: * **Checkout page**: Customer completes payment via Hyperline checkout * **Immediately**: Charge the customer's default payment method Click **Assign subscription** to activate it. You'll be redirected to the customer page where you can see the subscription and current usage. A customer subscribes to your API product with monthly billing. They have a committed minimum of 5,000 API calls per month (they'll be charged for at least 5,000 calls even if they use fewer), and a maximum spending cap of \$500 per month to prevent unexpected bills. For more details on subscription configuration options, see our [subscription setup guide](../docs/subscriptions/create). ### 5. Simulate usage (optional, for testing) If you're in [test mode](../docs/getting-started/sandbox), you can simulate usage events to see how billing works without real data. From your customer's page, click the **Events** tab. Look for the **Simulate new events** button at the top of the events list. Fill in the details: * **Event type**: Use the same event type configured in your product * **Date**: Choose when the events occurred (must be within the current billing period) * **Number of events**: How many events to create * **Payload** (optional): Add custom event properties in JSON format ```json theme={null} { "quantity": 100, "region": "us-east-1" } ``` Click **Create new events**. The events will appear in the customer's event list after a few seconds. You can delete simulated events at any time if you need to reset your test data. This is only available in test mode. Learn more about simulating usage in our [simulate usage data guide](../docs/usage/simulate-usage-data). ### 6. Monitor usage and understand open invoices After creating usage events, you can track consumption and preview upcoming charges. #### View current usage From the customer's **Subscriptions** tab, you'll see the current usage displayed next to each usage-based product. Click the eye icon next to the unit count to open the consumption details modal, which shows: * Total usage for the current billing period * Individual events contributing to the usage * Calculated amount based on your pricing tiers * Breakdown by time period or event properties For detailed usage analysis and exports, see our [explore usage consumption guide](../docs/usage/explore-usage-consumption). #### Understanding open invoices An **open invoice** is a live preview of the invoice that will be charged at the end of the billing period. For usage-based subscriptions, this invoice updates automatically in real-time as new usage events are recorded. **Key characteristics of open invoices:** * **No invoice number yet**: Open invoices don't have a final invoice number because they're still being calculated * **Cannot be paid**: Customers cannot pay an open invoice—it's for preview purposes only * **Updates in real-time**: As usage accumulates, the invoice amount increases automatically * **Visible to customers**: Customers can see their open invoice in the [customer portal](../docs/customers/portal) to track their current charges **To view an open invoice:** 1. Go to the customer's **Invoices** tab 2. Look for the invoice with status `open` 3. Click on the invoice to see the current charges and line items A customer subscribes on January 1st with monthly billing. An open invoice is immediately created for the January 1-31 period. As they make API calls throughout the month, the invoice updates: * January 5: 2,500 calls → Invoice shows \$25 * January 15: 8,000 calls → Invoice shows \$80 * January 31: 15,000 calls → Invoice shows \$138 (with tiered pricing) On February 1st, the invoice enters the grace period for final review. #### Invoice lifecycle for usage-based billing Usage-based invoices follow this lifecycle: 1. **Open**: Invoice is created at the start of the billing period and updates as usage accumulates 2. **Grace period**: At the end of the billing period, the invoice enters a grace period (default: 3 days) where you can review and make manual adjustments if needed 3. **To pay**: After the grace period, the invoice is finalized with an invoice number and sent for payment 4. **Paid**: Payment is collected and the invoice is settled During the grace period, you can still make adjustments to the invoice (add credits, apply discounts, etc.). Once the grace period ends, the invoice is locked and cannot be modified. You can configure the grace period duration in **Settings** → **Invoicing**. Learn more about [invoice terms and grace periods](../docs/invoices/term). ## Next steps You've successfully set up a usage-based subscription! Here are some ways to expand your implementation: View detailed usage reports and export data Learn about advanced metering configurations Update, pause, or cancel subscriptions Customize invoice templates and settings Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Set up credit-based billing for an AI platform Source: https://docs.hyperline.co/guides/credit-based-billing-ai Implement credit-based billing for an AI platform: configure credit products, weighted consumption across multiple models, and customer top-ups. This guide walks you through setting up a complete credit-based billing system in Hyperline, where customers purchase credits and consume them at different rates depending on which AI model they use. ## Context You run an AI platform that offers access to multiple LLM models with different capabilities and costs. Rather than billing per token for each model separately, you want to sell credit packs that customers can spend across all models — with more powerful models consuming more credits per usage. Your platform offers three model tiers: | Model | Use case | Credits per 1,000 tokens | | ------------ | ------------------------ | ------------------------ | | `nova-fast` | Quick tasks, high volume | 1 | | `nova-pro` | Balanced performance | 4 | | `nova-ultra` | Complex reasoning | 15 | A customer with 10,000 credits could use them flexibly: heavy usage of the budget model, occasional use of the premium model, or any combination. ## Prerequisites Before you begin, make sure you have: * Access to your Hyperline account (we recommend using [test mode](../docs/getting-started/sandbox) for this setup) * An [API key](../api-reference/docs/authentication) to send usage events * A clear understanding of the models you want to bill and their relative cost ratios When signed up and landed on Hyperline, you can use the [test mode](../docs/getting-started/sandbox) to experiment before going live. ## Steps ### 1. Send usage events via the API Every time a customer uses one of your models, your backend should send a billable event to Hyperline with the model name and the number of tokens consumed. ```sh theme={null} curl -X POST https://ingest.hyperline.co/v1/events \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "events": [ { "customer_id": "cus_xxxxxxxxxxxxx", "event_type": "llm_token_usage", "timestamp": "2026-03-25T14:30:00Z", "properties": { "model": "nova-pro", "tokens": 1500 } } ] }' ``` Each event should include: * `customer_id`: the Hyperline customer ID (or `external_id` if you've mapped your internal IDs) * `event_type`: a consistent name for your token usage events (e.g., `llm_token_usage`) * `properties.model`: the model identifier used for the request * `properties.tokens`: the total number of tokens consumed (input + output) For testing, you can skip this step and use [simulated events](../docs/usage/simulate-usage-data) directly in test mode to generate fake usage data. Learn more about event ingestion in our [send usage data guide](../docs/usage/send-usage-data). ### 2. Create one aggregator per model Each model tier needs its own [aggregator](../docs/usage/aggregators) so that Hyperline can track consumption separately and apply a different credit weight to each. Go to [**Usage > Aggregators**](https://app.hyperline.co/app/events/aggregators) and create three aggregators: | Aggregator name | Event type | Operation | Property | Filter | | ------------------- | ----------------- | --------- | -------- | ---------------------- | | `nova-fast tokens` | `llm_token_usage` | Sum | `tokens` | `model` = `nova-fast` | | `nova-pro tokens` | `llm_token_usage` | Sum | `tokens` | `model` = `nova-pro` | | `nova-ultra tokens` | `llm_token_usage` | Sum | `tokens` | `model` = `nova-ultra` | All three aggregators listen to the same `llm_token_usage` event type but use a filter on the `model` property to isolate each model's consumption. The **Sum** operation on `tokens` gives you the total number of tokens consumed per model. When a customer sends 3 requests to `nova-pro` consuming 1,200, 800, and 2,000 tokens respectively, the `nova-pro tokens` aggregator reports a total of 4,000 tokens for that period. ### 3. Create a credit product with weighted aggregators Now create a credit product that ties all three aggregators together with their respective weights. Go to [**Products**](https://app.hyperline.co/app/products), click **New product**, and select **Credit**. In the **Aggregators** section, add the three aggregators you just created and set the weight for each: | Aggregator | Weight | | ------------------- | ------ | | `nova-fast tokens` | 1 | | `nova-pro tokens` | 4 | | `nova-ultra tokens` | 15 | The weight determines how many credits are consumed per unit of usage. With these weights, 1,000 tokens on `nova-ultra` consumes 15 credits, while the same 1,000 tokens on `nova-fast` consumes only 1 credit. In the **Prices** section, configure your credit packs. For example: | Bundle size | Price | | --------------- | ------- | | 10,000 credits | \$100 | | 50,000 credits | \$400 | | 200,000 credits | \$1,200 | These bundles will be available for purchase via the customer portal and auto-topup. Click **Save** to add the credit product to your catalog. For more details on multi-aggregator credit products, see the [credits overview](../docs/credits/overview#multiple-aggregators-with-weights). ### 4. Set up a credit balance on a customer With your credit product ready, enable a credit balance on a customer. Go to [**Customers**](https://app.hyperline.co/app/customers), select a customer, and click the **Credits** tab. Click **Add credit balance** and select the credit product you created. Configure the initial settings: * **Starting balance**: the number of credits to grant immediately (e.g., 10,000) * **Warning limit**: the threshold at which a low-balance warning appears on the customer portal (e.g., 1,000 credits) ### 5. Add the credit product to a subscription To automate credit replenishment and invoicing, add the credit product to a subscription. From the customer's page, click **Actions** > **Assign new subscription**, or open an existing subscription. Click **Add product**, select your credit product, and choose a bundle pricing tier. To ensure your customer never runs out of credits, configure auto-topup on their credit balance: * **Threshold**: when the balance drops below this number, auto-topup triggers (e.g., 500 credits) * **Amount**: how many credits to add (e.g., 10,000) * **Pricing**: select a bundle price or set a custom amount Auto-topup automatically creates an invoice, charges the customer's payment method, and adds credits to their balance. Auto-topup requires the customer to have a valid payment method on file. If the payment fails, the topup will not be processed. ### 6. Monitor consumption Once the customer starts using your models, you can track credit consumption from the customer's **Credits** tab. The **credits chart** shows balance evolution over time. Use the date range and granularity controls (day, week, month) to analyze consumption patterns. Click **All transactions** to view the full **transactions table**, which lists every credit movement — top-ups, usage deductions, and expirations. For multi-aggregator products, an **Aggregator** column shows which model triggered each usage transaction. Click **Explore** on any usage transaction to inspect and export the underlying consumption events. A customer starts the month with 10,000 credits. They make: * 2,000 `nova-fast` calls averaging 1,000 tokens each → 2,000 x 1 = **2,000 credits** * 300 `nova-pro` calls averaging 1,500 tokens each → 450 x 4 = **1,800 credits** * 50 `nova-ultra` calls averaging 2,000 tokens each → 100 x 15 = **1,500 credits** Total consumption: **5,300 credits**. Remaining balance: **4,700 credits**. The transactions table shows each deduction tagged with the corresponding aggregator, so you can see exactly which model is driving consumption. ## Next steps Learn more about credit products and configuration options Configure credits to expire after a set period or at the end of each billing cycle Let customers view their balance and purchase credits from the portal Manage credits programmatically via the API Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Implement Hyperline for a self-serve product Source: https://docs.hyperline.co/guides/implement-self-serve Implement Hyperline for a self-serve SaaS product: signups, checkout, subscription lifecycle, and customer portal integration with your application. In this guide, we will see how to implement Hyperline subscriptions in the context of a self-served product. ## Context You have a pricing page on your marketing website and want your customer to subscribe when clicking on an offer. ## Prerequisites 1. [Create a Hyperline account](https://app.hyperline.co/auth/signup) 2. Follow the steps to [configure your account](../docs/getting-started/configure-account) 3. A clear idea of the plans you want to sell and their associated prices 4. An [API key](../api-reference/docs/authentication) to use the Hyperline API When signed up and landed on Hyperline, you can use the [Test mode](../docs/getting-started/sandbox) to experiment before going live. ## Steps ### 1. Model your products and templates in Hyperline The first thing you need to do is to create your [products](../docs/products/overview) and (optionally) [subscription templates](../docs/subscriptions/templates) in Hyperline. You'll need to do this operation once, but you can easily iterate on your pricing to experiment and adjust later. If you need any assistance in representing the best way your offer or need advice, you can contact support using the 'Help' chat. ### 2. Implement a subscription flow Below is a suggested example of the flow to initiate a prospect's subscription to your product. Of course, this may vary based on your specific use case and product and can be adjusted to suit your requirements. For this example, the prospect initially signs up for your product by creating an account on your side. When the prospect signs up, your backend [creates a customer](../api-reference/endpoints/customers/create-customer) on Hyperline related to the newly signed up customer on your system. ```sh theme={null} curl --request POST \ --url https://api.hyperline.co/v1/customers \ --header 'Authorization: ' \ --header 'Content-Type: application/json' \ --data '{ "name": "My customer", "currency": "EUR", "external_id": <(optional) ID of the customer in your system>, "available_payment_methods": <(optional) list of authorized payment methods> }' ``` Then you can [assign a subscription](../api-reference/endpoints/subscriptions/create-subscription) from the template (representing your plans/offers) selected by the customer. You need to use the ID corresponding to the template previously created, which can be found in Hyperline [templates](https://app.hyperline.co/app/subscriptions/templates) (next to the template name). This example creates a **dedicated checkout page** for your customer to fill in their billing details, add their payment method and subscribe. The subscription starts from the current date, and the customer is redirected to a specific URL on your side (`https://myservice.com/api/callback`) after completing the checkout. Use `checkout_session.redirect_url` to set the URL where the customer should be redirected after checkout completion. ```sh theme={null} curl --request POST \ --url https://api.hyperline.co/v2/subscriptions \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "customer_id": , "template_id": "subt_ji3uPodOneXk6R", "starts_at": "2025-12-20T00:00:00Z", "activation_strategy": "checkout", "checkout_session": { "redirect_url": "https://myservice.com/api/callback" } }' ``` If you want to customize the quantity of products, you can use an additional parameter in the request body. ```json theme={null} { "products": [ { "id": "itm_4vea8Gj0a5HZr9", "count": 23 } ] } ``` After creating the subscription, you'll receive the hosted checkout page URL in `checkout_session.url` in the response payload. ```json theme={null} "checkout_session": { "status": "opened", "url": "https://billing.hyperline.co/checkout/che_hEUPdVG7IgjpW1" } ``` Redirect your customer to `checkout_session.url` for them to subscribe. When completed, the customer will be redirected to the final URL on your side (previously configured when creating the subscription). The customer is now successfully **subscribed to your service**. You have the option to store this information on your end or entirely rely on Hyperline and retrieve the subscription status for the customer at any time. ```sh theme={null} curl --request GET \ --url https://api.hyperline.co/v1/customers/ \ --header 'Authorization: Bearer ' ``` ```json theme={null} { "id": "cus_Typ0px2W0aiEtl", "name": "My customer", "currency": "EUR", "subscriptions": [ { "id": "sub_0kIc7jrF7gV00V", "status": "active" } ] } ``` If you want to retrieve the quantity of the subscription products or the full details, you can use the subscriptions API. ```sh theme={null} curl --request GET \ --url https://api.hyperline.co/v2/subscriptions/ \ --header 'Authorization: Bearer ' ``` ```json theme={null} { "status": "active", "products": [ { "id": "itm_4vea8Gj0a5HZr9", "type": "seat", "count": 23 } ] // ... } ``` **That's it!** You can then proceed with your desired product flow. Your customer will be automatically invoiced and their payment method charged according to the configuration of the created subscription. ### 3. Follow the subscription You're able to retrieve at any time a unique portal link for your customer to follow their subscription, edit their payment method, or download their invoices. We recommend adding a button in your product redirecting to this page for your customer to "manage billing". ```sh theme={null} curl --request GET \ --url https://api.hyperline.co/v1/customers//portal \ --header 'Authorization: Bearer ' ``` ```json theme={null} { "url": "https://..." } ``` You can also [follow and manage](https://app.hyperline.co/app/customers) your customers' subscriptions on Hyperline. # Importing historical data Source: https://docs.hyperline.co/guides/importing-historical-data Import customers, subscriptions, and invoices from another billing system into Hyperline, with API endpoints and best practices for migrations. When migrating to Hyperline from another billing system, you can import your historical data using batch API endpoints. This allows you to maintain continuity in your billing records, reporting, and customer history. **Dedicated import service available** This guide explains how to import historical data autonomously using our API. However, we also provide a dedicated service to help you migrate data from your existing billing system. If you'd prefer assistance with your migration, please contact us via the in-app chat or discuss this option with your sales contact. ## What can be imported You can import the following data types: * **Customers**: Customer profiles with all associated metadata * **Subscriptions**: Active and historical subscriptions with their configuration * **Invoices**: Invoice records including PDF documents ## Prerequisites Before importing subscriptions and invoices, you must configure your product catalog in Hyperline. Products referenced in subscription and invoice imports must already exist in your Hyperline account. **Configure products first** Subscriptions and invoices might require valid Hyperline product identifiers in their import payloads. Create all necessary products in Hyperline before starting your data import, or the API will reject requests with unknown product references. You can create products through: * The Hyperline web application under **Catalog > Products** * The [Products API endpoints](/api-reference/endpoints/products/create-product) ## Import process overview The recommended import sequence is: 1. Configure your product catalog (required for subscriptions and invoices) 2. Import customers (required for subscriptions and invoices) 3. Import subscriptions with historical start dates 4. Import invoices with their PDF documents **Test in sandbox first** Always test your import process in the sandbox environment before importing production data. This allows you to validate your data mapping and identify any issues without affecting live operations. Note that sandbox is not a clone of production — you'll need to seed it with a representative slice of customers and products to make the dry run meaningful. ## Importing customers Use the batch customer creation endpoint to import multiple customers at once (up to 50 per request). ```sh theme={null} curl -X POST https://api.hyperline.co/v1/customers/batch \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "customers": [ { "batch_customer_id": "batch_001", "name": "Acme Corporation", "billing_email": "billing@acme.com", "external_id": "cust_123_from_old_system" } ] }' ``` The `batch_customer_id` is required for batch operations to track each customer in the batch. **Look up customers by your old IDs** Set the `external_id` field to your previous system's customer ID, and you can resolve customers later via the API without maintaining a separate mapping table: ```sh theme={null} GET /v1/customers?external_id=cust_123_from_old_system ``` For detailed parameters and response format, see the [Create customers batch](/api-reference/endpoints/customers/create-customers-batch) endpoint documentation. ## Importing subscriptions Subscriptions can be created with start dates in the past, allowing you to preserve historical subscription data. ### Key considerations for subscription imports * **Start date**: Set `starts_at` to the original subscription start date from your previous system * **Initial billing date**: Set `initial_billing_at` to the first or next date when Hyperline should start billing. This should typically be the next renewal date or the date when you want Hyperline to take over billing operations * **Activation strategy**: Use `start_date` to activate the subscription based on the `starts_at` date * **Contract terms**: Define contract duration and renewal settings * **Inactive subscriptions**: Import already-ended subscriptions only if you need them for historical reporting; otherwise skip them since they won't bill ```sh theme={null} curl -X POST https://api.hyperline.co/v2/subscriptions \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "customer_id": "cust_hyperline_id", "activation_strategy": "start_date", "starts_at": "2023-01-15T00:00:00Z", "initial_billing_at": "2026-02-15T00:00:00Z", "contract_terms": { "activation_strategy": "start_date", "end_strategy": "duration", "duration": { "period": "years", "count": 1 }, "renew_automatically": true }, "products": [ { "id": "prod_hyperline_id", "payment_interval": { "period": "years", "count": 1 }, "payment_schedule": "start" } ] }' ``` The product `id` must reference a product that already exists in your Hyperline product catalog. Map your old system's products to Hyperline product IDs before importing subscriptions. A customer subscribed to your service on January 15, 2023, with annual billing. You're migrating to Hyperline in January 2026. Set `starts_at` to `2023-01-15` (preserving the original subscription start) and `initial_billing_at` to `2026-02-15` (the next renewal date when Hyperline should generate the invoice). For detailed parameters, see the [Create subscription](/api-reference/endpoints/subscriptions/create-subscription) endpoint documentation. ## Importing invoices Import historical invoices to maintain complete billing records and enable accurate reporting. ### Batch invoice creation Create multiple invoices at once (up to 50 per request): ```sh theme={null} curl -X POST https://api.hyperline.co/v2/invoices/batch \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "batch_id": "import_batch_2025_01", "invoices": [ { "batch_invoice_id": "inv_123_from_old_system", "customer_id": "cust_hyperline_id", "status": "paid", "emitted_at": "2025-01-15T00:00:00Z", "due_at": "2025-02-15T00:00:00Z", "settled_at": "2025-01-20T00:00:00Z", "line_items": [ { "product_id": "prod_hyperline_id", "name": "Annual subscription", "unit_amount": 12000, "units_count": 1 } ] } ] }' ``` The endpoint returns a `202 Accepted` response with a `batch_id` that you can use to track the batch processing: ```json theme={null} { "batch_id": "import_batch_2025_01" } ``` The batch invoice creation endpoint processes invoices asynchronously — see [Tracking batch invoice creation](#tracking-batch-invoice-creation) below for the webhook events you can listen to. The `batch_invoice_id` is required to track each invoice in the batch. Each line item should reference a `product_id` from your product catalog. For paid invoices, include the `settled_at` date to record when payment was received. For detailed parameters, see the [Create invoices](/api-reference/endpoints/invoices/create-invoices) endpoint documentation. Imported historical invoices do **not** generate [journal entries](/docs/accounting/entries) or [recognition schedules](/docs/accounting/revenue-recognition) on their own — the accounting module only posts for activity that happens after a ledger is created. If you need these invoices in your books, [contact our team](mailto:support@hyperline.co) once the import is complete and we can replay them into the ledger. ### Tracking batch invoice creation Since batch invoice creation is asynchronous, you should set up webhook listeners to track the success or failure of each invoice: * **`invoice.batch.creation_succeeded`**: Triggered when an invoice in the batch is successfully created * **`invoice.batch.creation_failed`**: Triggered when an invoice in the batch fails to be created Each webhook event includes the `batch_id` and `batch_invoice_id` to help you track which invoices were processed successfully. See the [Webhooks documentation](/api-reference/docs/webhooks) for more details on setting up webhook endpoints. ### Importing invoice PDFs After creating an invoice record, you can upload the original PDF document from your previous system: ```sh theme={null} curl -X POST https://api.hyperline.co/v1/invoices/{invoice_id}/upload \ -H "Authorization: Bearer " \ -H "Content-Type: multipart/form-data" \ -F "file=@/path/to/invoice.pdf" ``` This preserves the original invoice formatting and branding from your previous system, which can be important for customer records and compliance. For detailed parameters, see the [Upload PDF to invoice](/api-reference/endpoints/invoices/upload-pdf-to-invoice) endpoint documentation. ## Best practices ### Data validation * Validate all data before importing to ensure it meets Hyperline's requirements * Check for required fields and data format compliance * Test with a small batch first to identify any mapping issues ### Batch size management * Process imports in batches of 50 items or fewer (API limit) * Implement retry logic for failed batches * Monitor API rate limits to avoid throttling ### Data mapping * Create a mapping document between your old system's data structure and Hyperline's * **Map products first**: Create a mapping between your old system's product IDs and Hyperline `product_id` values before importing subscriptions or invoices * Use `external_id` and `metadata` fields to maintain references to original system IDs * Document any data transformations or business logic applied during import ### Timing considerations * Schedule imports during low-traffic periods to minimize impact * Import customers before subscriptions and invoices (dependency order) * Allow time for data validation and reconciliation after import ### Date and timezone handling * All timestamps are interpreted as UTC — pass dates in ISO 8601 with an explicit offset (e.g. `2026-02-15T00:00:00Z`) * A bare date or local-time string can shift the billing day by ±1 in customer-facing invoices when your timezone differs from UTC * This matters most for `starts_at`, `initial_billing_at`, and the invoice `emitted_at` / `due_at` / `settled_at` fields — pick the same calendar day your old system used and append `T00:00:00Z` ### Reconciliation After importing: * Verify customer counts match between systems * Reconcile subscription statuses and billing dates * Confirm invoice totals and payment statuses * Review reporting data to ensure accuracy **Irreversible operation** Data imports cannot be automatically reversed. Always test thoroughly in the sandbox environment before importing production data. Consider keeping backups of your original data until you've fully validated the import. # Keyboard shortcuts Source: https://docs.hyperline.co/guides/keyboard-shortcuts Move around Hyperline with keyboard shortcuts — search, create records, pull data from tables, and run operations without touching the mouse. Hyperline ships with keyboard shortcuts across navigation, search, record creation, and data tables. Most are wired in globally and work from anywhere in the app — except while typing inside an input or editor, where the focused field captures the keys. On Mac, the modifier is `⌘`. On Windows and Linux, it's `Ctrl`. Sequence shortcuts (e.g. `G` then `H`) are typed in quick succession with no modifier. ## Command palette The fastest way to do almost anything. | Shortcut | Action | | ---------------- | -------------------------- | | `⌘ K` / `Ctrl K` | Open the command palette | | `Esc` | Close | | `↑` `↓` | Move between items | | `Enter` | Run the selected item | | `→` | Open a sub-menu | | `←` | Leave the current sub-menu | Paste any Hyperline entity ID (customer, subscription, invoice, product) into the palette to jump straight to its page. Useful when an ID lands in your inbox or in a Slack thread. ## Navigate — `G` then a letter Type `G`, then the destination letter(s), in quick succession. | Shortcut | Page | | ----------- | ------------ | | `G` `H` | Home | | `G` `C` `U` | Customers | | `G` `I` | Invoicing | | `G` `Q` | Quoting | | `G` `T` | Transactions | | `G` `R` | Reports | | `G` `E` | Events | | `G` `A` | Audit log | | `G` `C` `A` | Catalog | | `G` `S` | Settings | ## Create — `N` then a letter | Shortcut | Action | | -------- | ---------------- | | `N` `C` | New customer | | `N` `S` | New subscription | | `N` `Q` | New quote | Each shortcut opens the matching creation form as a modal — no page reload, no lost context. ## Tables The new generation of Hyperline tables — currently Insights and Revenue recognition — supports spreadsheet-style selection. Select a few cells, copy, and paste straight into Excel, Google Sheets, or Notion. | Shortcut | Action | | ------------------------ | -------------------------------------------------------- | | Click | Select a cell | | `Shift` Click | Extend selection to clicked cell | | `⌘` Click / `Ctrl` Click | Toggle a single cell in or out of the selection | | Click + drag | Drag-select a range | | `⌘ C` / `Ctrl C` | Copy selection as TSV | | `⌘ A` / `Ctrl A` | Select every cell in the table (after a first selection) | | `Esc` | Clear selection | The footer shows live stats — sum, average, count — for the current selection when amounts or numbers are selected. ## Discoverability Most shortcuts also appear: * as a tag next to the action inside the command palette * as a hint in the tooltip when hovering sidebar items If a shortcut is documented here but doesn't seem to fire, check that the focus isn't trapped inside a text input — click outside the field first, then trigger the shortcut. # Retroactive subscription update Source: https://docs.hyperline.co/guides/retroactive-subscription-update Apply a Hyperline subscription change retroactively after the current period is already invoiced, using the advanced update flow with transition invoice. Sometimes you need to update a subscription after the current billing period has already been invoiced — for example, you forgot to apply a price increase at renewal, a contract amendment was signed late, or an extra product should have been added at the start of the period. This guide walks you through how to apply a subscription change retroactively using the [advanced update](/docs/subscriptions/update#advanced-update) flow, with either **At last renewal** or **At selected date**, and explains how each transition invoice mode (**Generate transition invoice** vs **Refund and re-invoice**) impacts the customer's invoices. ## When to use a retroactive update Use a retroactive update when: * The change should have taken effect earlier in the current billing period (or in a past period) * The invoice for the current period has already been issued and you want to correct it * You need a clean audit trail and version history of the change If the change can simply apply going forward, use **Next renewal** or **Immediately** instead — there's no need for a retroactive update. ## Choose when to apply the update In the advanced update flow, the **When to apply the update** step controls the effective date of the change: * **At last renewal** — Applies the update retroactively as of the start of the current billing period. This is the most common option when you want the change to look as if it had been configured from the beginning of the period. * **At selected date** — Applies the update at a specific date you pick. Choose a **date in the past** to make the change retroactive to that exact day (for example, mid-period when a contract amendment was signed). A subscription renewed on **March 1st** with a monthly plan at €100. On **March 20th** you realize a new add-on should have been included since March 1st. * Select **At last renewal** to apply the add-on as of March 1st — the full period is recalculated as if the add-on had always been there. * Select **At selected date** and pick **March 10th** if the add-on should only apply from that day onward — the period is split, and only the portion after March 10th includes the add-on. ## Choose the transition invoice mode Once you've picked the retroactive effective date and the new subscription configuration, the **Configure transition options** step lets you decide how the already-issued invoice should be corrected. Two modes are available for retroactive updates: ### Generate transition invoice A single **transition invoice** is issued on top of the existing invoice to settle the difference between what was originally billed and what should have been billed for the period. * The original invoice for the current period is **kept as-is** (not refunded) * A new invoice is generated for the **delta** — either a charge (if the customer owes more) or a credit note (if the customer was overcharged) * Best when you want a lightweight correction and to preserve the original invoice for accounting continuity Original invoice for March: **€100** (already paid). You apply a retroactive update **At last renewal** to add a €30/month add-on. With **Generate transition invoice**, Hyperline issues an additional invoice of **€30** for March. The customer keeps their original €100 invoice and receives a second €30 invoice covering the add-on for the same period. ### Refund and re-invoice The original invoice for the current period is **fully refunded** (via a credit note), and a brand new invoice is issued reflecting the updated subscription configuration. * The customer ends up with one credit note cancelling the original invoice, plus a new invoice for the corrected amount * Best when the original invoice is materially wrong and you want the final billing to look as if the new configuration had been in place from the start of the period * Only available for updates **At last renewal** Original invoice for March: **€100** (already paid). You apply a retroactive update **At last renewal** to swap the plan from €100/month to €150/month. With **Refund and re-invoice**, Hyperline issues a **credit note of €100** cancelling the original invoice, and a new **€150 invoice** for March reflecting the new plan. The customer's net balance for the period is now €150 instead of €100. **Refund and re-invoice** is only available when applying the update **At last renewal**. For updates **At selected date** in the past, use **Generate transition invoice** to settle the delta. ## Step-by-step instructions Navigate to the customer's subscription details page, click the **Actions** dropdown, then select **Update subscription**. Choose **Advanced update** to access the full transition configuration. Select either: * **At last renewal** to apply the change retroactively from the start of the current billing period * **At selected date** and pick a date in the past for a mid-period retroactive change Select **Update current subscription** to edit the existing configuration, or **Update to a template or a plan** to reset the configuration from a template or plan. Make the changes that should have been in place as of the effective date (add a product, change a price, swap the plan...). Under **Transition invoice**, choose how to correct the already-issued invoice: * **Generate transition invoice** — issues an additional invoice for the delta, keeping the original invoice intact * **Refund and re-invoice** — refunds the original invoice and issues a new one reflecting the updated configuration (only with **At last renewal**) Use the invoice preview at this step to review both the transition invoice (or refund and new invoice) and the following invoice. This is the safest way to confirm the financial impact before applying the change. Review the update summary, then confirm. The subscription is updated retroactively and the corresponding invoices (transition invoice, or credit note and new invoice) are generated immediately. ## What happens after the update * The subscription configuration reflects the change as of the effective date * The corrective invoices (transition invoice or credit note + new invoice) are issued and follow your usual collection rules * The change is recorded in the [versions tab](/docs/subscriptions/update#subscription-versions), preserving a full audit trail of what changed and when Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Subscription billing cycles Source: https://docs.hyperline.co/guides/subscription-billing-cycles Change the billing cycle alignment of a Hyperline subscription using the advanced update feature, with prorations, anchors, and timing examples. When a subscription is created, its billing cycle is determined by its start date or initial billing date. For example, a monthly subscription starting on March 10th renews on the 10th of each month. In some cases, you may need to realign the billing cycle—for instance, to have all your subscriptions renew on the 1st of the month. This guide walks you through how to change the billing cycle alignment of a subscription using the [advanced update (transition)](/docs/subscriptions/update#advanced-update) feature. ## Change the billing cycle alignment Use this when you want to shift a subscription's renewal date to a different day. For example, moving a monthly subscription that renews on the 10th to renew on the 1st instead. ### Step-by-step instructions Navigate to the customer's subscription details page, click the **Actions** dropdown, then select **Update subscription**. Choose **Advanced update** to access the full transition configuration. Select **Scheduled date** and pick the date you want the new billing cycle to start on. This date should correspond to your desired new anchor date—either: * **A past date** matching the new anchor (e.g., the 1st of the current month if you want the subscription to renew on the 1st going forward) * **A future date** matching the new anchor (e.g., the 1st of the next month) If today is January 15th and the subscription currently renews on the 10th, you could select: * **January 1st** (past) to retroactively realign the billing cycle from the beginning of the current month * **February 1st** (future) to realign starting from the next month In the update source step, select **Update current subscription**. Since you only want to change the billing cycle alignment and not modify the products or pricing, keep the subscription configuration as-is. This step is key to realigning the billing cycle: 1. Under **Billing cycle alignment**, select **Start new period**. This resets the subscription billing dates to start a fresh cycle from the selected transition date, effectively making that date the new anchor for all future renewals. 2. Under **Transition invoice**, choose the option that fits your use case: * **Generate transition invoice** to settle the period between the last renewal and the transition date * **Waive transition invoice** to skip billing for the partial period Use the invoice preview at this step to review both the transition invoice and the following invoice. This helps you verify that the new billing cycle alignment is correct before confirming. Review the update summary to verify that: * The transition date matches your desired new anchor date * **Start new period** is selected * The transition invoice setting is correct Confirm the update. The subscription will now follow the new billing cycle, renewing on the selected anchor date going forward. ### What happens after the update Once the transition is applied: * The subscription's billing cycle resets to start from the transition date * All future renewals align to this new date (e.g., the 1st of each month) * If a transition invoice was generated, it covers the partial period between the previous renewal and the new anchor date * The subscription version history records this change in the [versions tab](/docs/subscriptions/update#subscription-versions) A monthly subscription renewing on the 10th is transitioned on February 1st with **Start new period** selected: * A transition invoice covers January 10th–January 31st (if not waived) * The new billing period runs from February 1st to February 28th * All future renewals happen on the 1st of each month Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Upsell and downsell a subscription Source: https://docs.hyperline.co/guides/upsell-downsell-subscriptions Upsell or downsell a Hyperline subscription with the advanced update flow, or send a quote for subscription update that the customer signs. Upsells (adding products, increasing quantities, moving to a higher plan) and downsells (removing products, decreasing quantities, moving to a lower plan) are common changes on active subscriptions. Hyperline provides two ways to apply them, depending on whether the change needs customer approval: * **Advanced update** — apply the change directly from the subscription details page, with full control over the effective date and the transition invoice. * **Quote for subscription update** — send the customer a quote for signature; the change only takes effect once the quote is signed, or at the specified date after quote signature. This guide walks you through both flows, then explains how the effective date (**Next renewal**, **At last renewal**, **Immediately**, **Scheduled date**) and the transition invoice mode (**Waive**, **Generate transition invoice**, **Refund and re-invoice**) drive the pro-rata logic on the resulting invoices. ## Choose the right flow Best when you're applying the change on your side — no customer signature required. Use it for internal amendments, corrections, or upsells and downsells agreed on outside of a quote. Best when the customer must approve the change. The upsell or downsell is materialised in a signed document, and only applied once the quote is signed. Both flows expose the same transition settings (effective date, billing cycle alignment, transition invoice mode) — so the pro-rata logic described below applies identically to both. ## Upsell or downsell with the advanced update flow The **advanced update** flow gives you a multi-step process to configure exactly when and how the upsell or downsell is applied. From the customer's subscription details page, click **Actions** then **Update subscription**, and choose **Advanced update**. Pick the effective date of the change: * **Next renewal** — Applied when the current billing cycle ends. Recommended for upsells or downsells that should only impact future periods, with no pro-rata on the current one. * **Immediately** — Applied right now, mid-period. Recommended for a live upsell or downsell that must take effect today, with a pro-rated transition invoice for the remainder of the period. * **At last renewal** — Applied retroactively as of the start of the current period. Recommended when the change should have been in place from the start of the current period (see [Retroactive subscription update](/guides/retroactive-subscription-update)). * **Scheduled date** — Applied at a specific date in the future. Select **Update current subscription** to edit the existing configuration (add or remove products, adjust quantities, change prices), or **Update to a template or a plan** to move the customer to a pre-configured upsell or downsell plan. Under **Billing cycle alignment**, choose whether to **Keep current period** or **Start new period** from the update date. Then, under **Transition invoice**, pick how the current period should be settled: * **Waive transition invoice** — No transition invoice is issued. * **Generate transition invoice** — A transition invoice settles the current period based on the pro-rata logic described below. * **Refund and re-invoice** — The current period's invoice is refunded and re-issued to reflect the new configuration (only available with **At last renewal**). Use the invoice preview at this step to review both the **transition invoice** and the **following invoice** before confirming — this is the safest way to validate the financial impact of the upsell or downsell. Review the update summary and confirm. The subscription is updated according to your effective date, and the corresponding invoices are generated. ## Upsell or downsell with a quote for subscription update Use a [quote for subscription update](/docs/quotes/subscription-update) when the customer needs to approve the upsell or downsell before it takes effect. The transition settings you configure on the quote (effective date and transition invoice mode) behave identically to the advanced update flow — the only difference is that the change is applied on quote signature (or on the scheduled date after signature) rather than immediately. From the subscription details page, click **Actions** then **Create update quote**. Alternatively, from the **Quotes** page, click **New quote** and select **Quote for subscription update**. Choose between: * **On quote signature** — The upsell or downsell is applied when the customer signs the quote. * **On selected date** — The upsell or downsell is applied on a future date, provided the quote is signed by then. Keep the current configuration and adjust it (add or remove products, edit quantities and prices, add or remove coupons or phases), or start from a template for pre-configured upsell and downsell scenarios. Click **Revise transition** to choose the billing cycle alignment (**Keep current period** or **Start new period**) and the transition invoice mode (**Waive transition invoice** or **Generate transition invoice**). The pro-rata logic on the transition invoice is the same as with the advanced update flow. Finalise, review and send the quote. Once signed, Hyperline applies the change automatically — either immediately or on the scheduled date — and generates the transition invoice according to your settings. While a quote for subscription update is pending signature, the source subscription cannot be edited directly. You can still create additional open quotes on the same subscription — useful when negotiating several upsell scenarios in parallel. ## Effective date and pro-rata logic on the transition invoice The effective date you pick controls both **when** the new configuration starts and **what** the transition invoice looks like. Below is how each option impacts the transition invoice for a typical upsell or downsell. ### Next renewal * The current period runs to its scheduled end date, invoiced as originally configured. * The new configuration starts at the next renewal — the first invoice under the new pricing is the regular period invoice. * **No transition invoice is generated** (no pro-rata is needed). * Best for upsells and downsells that shouldn't disturb the current period. A customer is on a monthly plan at €100, renewing on the 1st of each month. On **March 15th**, you upsell them to a €150/month plan with **Next renewal** as the effective date. * March 1st–31st: invoiced €100 as originally scheduled. * April 1st: the new plan starts and the customer is invoiced €150 for April. * No transition invoice. ### Immediately * The new configuration takes effect on the update date, mid-period. * The transition invoice settles the current period on a **pro-rata basis**: * The **removed** or **downgraded** products are credited for the unused portion of the period (elapsed days are billed at the old price, remaining days are credited). * The **added** or **upgraded** products are charged for the remaining portion of the period. * Best for live upsells and downsells that should apply from today. Same customer on a €100/month plan renewing on March 1st. On **March 16th** (half of a 30-day period elapsed), you upsell them to a €150/month plan **Immediately** with **Generate transition invoice**. * The old plan is billed for the first 15 days: €100 × 15/30 = **€50**. * The new plan is billed for the remaining 15 days: €150 × 15/30 = **€75**. * The €100 already invoiced on March 1st is offset. The transition invoice charges **€25** (€75 for the new plan minus the €25 credit for the unused half of the old plan). * On April 1st, the customer is invoiced €150 for the full April period. If it were a downsell to a €60/month plan instead, the transition would produce a **credit** on the transition invoice (unused portion of the old plan is worth more than the pro-rated new plan). ### At last renewal * The new configuration is applied retroactively, as if it had been in place from the start of the current period. * Two transition invoice modes are available: * **Generate transition invoice** — The original invoice for the current period is kept as-is. A transition invoice is issued for the **delta** between what was originally billed and what should have been billed for the full period under the new configuration. * **Refund and re-invoice** — The original invoice for the current period is fully refunded via a credit note, and a new invoice is issued reflecting the new configuration for the full period. * Best when the upsell or downsell was agreed on retroactively and should cover the current period entirely. See [Retroactive subscription update](/guides/retroactive-subscription-update) for the full walkthrough. Customer on a €100/month plan, March invoice of €100 already issued and paid. On **March 20th**, you upsell them to €150/month **At last renewal**. * With **Generate transition invoice**: the €100 March invoice is kept, and a second invoice of **€50** is issued to cover the delta for March. * With **Refund and re-invoice**: a **credit note of €100** cancels the original invoice, and a new **€150 invoice** is issued for March. ### Scheduled date * The upsell or downsell is applied on a specific future date. * Between now and the scheduled date, the subscription continues under the current configuration and is invoiced normally. * On the scheduled date, the transition follows the same pro-rata logic as **Immediately** if the date falls mid-period, or as **Next renewal** if it aligns with a renewal. * Best for planned upsells (for example, a customer confirms today that they'll expand on the 1st of next quarter). Customer on a €100/month monthly plan renewing on the 1st. You schedule an upsell to €150/month on **April 15th**. * March and early April: invoiced normally on the €100 plan. * April 1st: invoiced €100 for the April period as usual. * April 15th: the upsell takes effect, and a pro-rated transition invoice is generated for the second half of April (charging the delta between the new and old plan for the remaining days). * May 1st: invoiced €150 for the full May period. ## Billing cycle alignment Alongside the effective date, the **billing cycle alignment** on the transition options step controls whether the customer's renewal date changes after the upsell or downsell: * **Keep current period** — The renewal date stays the same. The transition invoice covers the remainder of the existing period (if applicable), and the next invoice lands on the original renewal date. * **Start new period** — A fresh billing cycle starts on the effective date. The customer's future renewal date shifts to align with the update. Customer renews monthly on the 1st. On **March 16th**, you apply an upsell **Immediately**. * With **Keep current period**: April 1st stays the next renewal date, and the customer is invoiced for the second half of March on the transition invoice. * With **Start new period**: a new monthly period starts on March 16th, and the next renewal is April 16th. ## Choosing the right combination | Scenario | Effective date | Transition invoice | | ---------------------------------------------------------------- | --------------- | --------------------------- | | Upsell that should apply from the next renewal | Next renewal | Not applicable | | Live upsell in the middle of the period | Immediately | Generate transition invoice | | Live downsell mid-period, refund unused portion | Immediately | Generate transition invoice | | Upsell agreed on last week, should cover the current period | At last renewal | Generate transition invoice | | Correction where the current period invoice was materially wrong | At last renewal | Refund and re-invoice | | Upsell confirmed today, effective on a future date | Scheduled date | Generate transition invoice | | Cosmetic change (relabelling, custom properties) with no billing | Immediately | Waive transition invoice | Whenever you're unsure, use the invoice preview at the **Configure transition options** step (advanced update) or the **Revise transition** modal (quote for subscription update) to confirm the transition invoice matches what you expect before confirming or sending the quote. ## What happens after the upsell or downsell * The subscription reflects the new configuration from the effective date. * Any transition invoice, credit note, or refund follows your usual payment collection rules. * Previous configurations are preserved on the **Versions** tab of the subscription details page, providing a full audit trail of the upsell or downsell. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. # Adyen Source: https://docs.hyperline.co/integrations/adyen Collect card and local payments through Adyen on Hyperline with one-click connection, payment orchestration, and automatic reconciliation. ## Prerequisites You need to have an [Adyen](https://www.adyen.com) account, finished Adyen's onboarding flow, and admin rights on Hyperline. ## Setup If [Adyen](https://www.adyen.com) is your preferred Payment Service Provider, connecting it with Hyperline is a straightforward process: 1. In the menu, select **Settings** 2. Select **Payment** 3. Click on **Connect payment provider**, then Adyen This will redirect you to the Adyen login page where you will have to enter your account credentials and click **Continue**. Once the process is completed, you will see Adyen appearing as **Active** in the Payment page. You can connect multiple Adyen accounts to Hyperline so that payments are routed based on your invoicing entities and preferences. ## Payment methods Adyen through Hyperline supports: * **Card** payments from major card schemes such as Visa, Mastercard, American Express, Discover & Diners, JCB and more, depending on country and locality * **Direct Debit** payments including SEPA (EU) and Bacs (UK) ## Customer information Each time you bill a customer in Hyperline, the corresponding payment details (including payment methods and mandates) are automatically created and managed by Hyperline in your Adyen account. Additionally, Hyperline integrates payment method collection forms into our hosted pages (checkout, customer portal, invoice page, and quote page), requiring no technical effort on your part. This seamless integration ensures that customer data and payments remain synchronized between Hyperline and Adyen, streamlining transaction management and customer information handling. # Airwallex Source: https://docs.hyperline.co/integrations/airwallex Collect card and bank transfer payments through Airwallex on Hyperline, with automatic customer sync, payment routing, and reconciliation. ## Prerequisites You need to have an [Airwallex](https://www.airwallex.com) account, finished Airwallex's onboarding flow, and admin rights on Hyperline. ## Setup If [Airwallex](https://www.airwallex.com) is your preferred Payment Service Provider, connecting it with Hyperline is a straightforward process: 1. In the menu, select **Settings** 2. Select **Payment** 3. Click on **Connect payment provider**, then Airwallex This will redirect you to the Airwallex login page where you will have to enter your account credentials and click **Continue**. Once the process is completed, you will see Airwallex appearing as **Active** in the Payment page. You can connect multiple Airwallex accounts to Hyperline so that payments are routed based on your invoicing entities and preferences. ## Payment methods Airwallex through Hyperline supports: * **Card** payments from major card schemes such as Visa, Mastercard, American Express, JCB, UnionPay, Discover and Diners Club, depending on country and locality * **Direct Debit** payments including SEPA (EU), Bacs (UK), or ACH (US) ## Customer information Each time you bill a customer in Hyperline, the corresponding customer profile and payment details (including payment methods and mandates) are automatically created and managed by Hyperline in your Airwallex account. Additionally, Hyperline integrates payment method collection forms into our hosted pages (checkout, customer portal, invoice page, and quote page), requiring no technical effort on your part. This seamless integration ensures that customer data and payments remain synchronized between Hyperline and Airwallex, streamlining transaction management and customer information handling. If you already have an Airwallex account with existing customers and payment methods, you have the possibility **to import them in Hyperline**. It is particularly useful when you configure your account. Please contact support if you are interested. # Anrok Source: https://docs.hyperline.co/integrations/anrok Use Anrok as the tax engine for Hyperline: automate sales tax calculation, product mapping, and compliance for US transactions and beyond. ## Prerequisites You need to have an [Anrok account](https://anrok.com). You need to know that Hyperline is able to connect only one tax engine at a time per invoicing entity, so if you want to use Anrok, you'll need to configure all your products and jurisdictions in Anrok. ## Setup If [Anrok](https://www.anrok.com) is your preferred tax engine, you need to ask us for a connection, and we'll do the setup for you inside Hyperline. ### Get Anrok API key But first, you'll need to provide us an Anrok API key that you can get from your Anrok account. 1. In the menu, select **Settings** 2. Then, at the bottom, **Manage API keys** 3. Click on **Create API key** 4. Copy the API key. Once Hyperline has activated the feature for you, you'll be able to click **Connect** in the **Integrations** page. ### Configure Anrok accounting timezone You need to configure the timezone of your Anrok account in the **Settings** page otherwise you'll get errors when you try to create an invoice. 1. In the menu, select **Settings**, and in the **Accounting** section, select **Timezone**. ### Configure Anrok as tax engine Click on **Taxes** in the settings menu and select **Anrok** as tax engine. ### Configure products Then, to make the mapping between your Hyperline products and Anrok products, you need to go to the **Products** page. 1. Click on **Products** in the menu 2. Click on **Add product** 3. Fill the form with the following information: The **Product ID** is a product ID that you'll need to fill in the Hyperline product page. (It can be shared across multiple products in Hyperline afterwards.) Here is an article from Anrok that explains the tax categories: [Anrok Tax Categories](https://help-center.anrok.com/hc/en-us/articles/4412669541907-Available-tax-categories-for-product-IDs) 4. As a recommendation from Anrok, we strongly encourage you to create a product that will be used as default when Hyperline doesn't have any mapping saved for a product. Name it **default\_hyperline\_product\_anrok** and set the **Product ID** to **default\_hyperline\_product\_anrok** with the default tax categories that will be used. If you don't do this, we'll take a product from your mapped products and use it as default. 5. Click on **Save** Then, as the last step, you'll need to update all the products in Hyperline with the Anrok product ID, on each product of the **Products** page in the accounting section. # Attio Source: https://docs.hyperline.co/integrations/attio Connect Attio CRM with Hyperline to sync customers, subscriptions, and revenue data, and surface billing details on Attio records and lists. The Hyperline-Attio integration provides a seamless connection between your Attio workspace and Hyperline. With this integration, you can access dedicated widgets and actions directly from your Attio record pages, allowing you to create and manage Hyperline quotes, subscriptions, and customers without leaving your CRM. These features embed the full Hyperline interface inside Attio, ensuring smooth and efficient flows. In addition, the integration enables optional and automatic data synchronization between Hyperline entities—such as quotes, subscriptions, and invoice details—and Attio's custom objects. This ensures you always have the most up-to-date information at your fingertips, allowing this data to be used for internal automations, workflows, and reporting within Attio. ## Prerequisites You must have a valid [Attio account](https://attio.com) with admin rights as well as access to the settings of your Hyperline account. We recommend creating a dedicated Attio test workspace before going live, and using the [test mode](../docs/getting-started/sandbox) of your Hyperline account during setup and experimentation. ## Embedded Hyperline UIs in Attio ### Installation Upon connecting your Attio account to Hyperline, the Hyperline app is automatically installed in your Attio workspace. You'll then need to configure a **Workspace Connection**: 1. In Attio, navigate to Workspace settings > Apps > Hyperline > Workspace Connection > Connect 2. Enter an [API key created in your Hyperline settings](../api-reference/docs/authentication#how-to-generate-an-api-key) with **read access** #### Sandbox To use the Hyperline Attio app with your Hyperline **sandbox (test mode)** account, go to Workspace settings > Apps > Hyperline > Settings in Attio, and select "Sandbox" as the environment. In this case, please use an API key created in your Hyperline **sandbox** account for the Attio app Workspace Connection. ### Record actions Once the integration is set up, new Hyperline actions become available directly from your Attio company and deal records. These actions allow you to: * create Hyperline quotes * create Hyperline subscriptions * manage the related Hyperline customer Each action opens a dedicated Hyperline interface embedded directly within Attio, giving you access to the full Hyperline experience without leaving your CRM—and ensuring seamless interoperability between both systems. ### Widgets In addition to record actions, the integration provides dedicated Hyperline widgets that can be embedded directly into your Attio company and deal record pages. * **Subscription widget**: Displays a preview of the customer's active subscription along with its associated ARR. Clicking the widget opens the corresponding Hyperline subscription page. * **Quote widget**: Displays a preview of the currently open quote and its associated value. Clicking the widget opens the corresponding Hyperline quote page. If multiple subscriptions or quotes are linked to the Attio record, the widget will instead display the number of related items. Clicking it will open a list of all associated subscriptions or quotes. ### User access Attio users do not need an existing Hyperline account. When a user triggers a Hyperline action for the first time, a corresponding Hyperline user is automatically created using their Attio email address and assigned to your default Hyperline role (the ['Account manager' role](../docs/getting-started/configure-account#account-manager-role) if not changed). When Hyperline interfaces are opened inside Attio, the user's Hyperline role is applied to ensure the correct view and edit permissions. These permissions are managed directly in Hyperline under Settings > Team. ### Data reconciliation When retrieving Hyperline customer data from an Attio company or deal record, the following lookup mechanism is applied: 1. If it's a deal record, use the associated company record for the lookup. 2. If the company record is already linked to a Hyperline customer (via the Integrations section on the Hyperline customer page), that customer is used. 3. If the company record has a value in the Hyperline customer ID custom field, we attempt to resolve the corresponding Hyperline customer. 4. If the company record has a value in the Hyperline external ID custom field, we attempt to resolve the Hyperline customer whose ID or external ID matches that value. If the Attio company and the Hyperline customer were not previously linked, the link is automatically created—provided the integration settings allow it (customer sync enabled, sync direction including Attio → Hyperline, and the company flagged for sync). If a customer is found but the settings do not allow automatic linking, Hyperline will surface the suggested customer in Attio, along with an action to manually trigger the link. If no customer is found but the “Allow creating new customer” setting is enabled, the Attio user will be able to create a new related Hyperline customer and proceed with the desired action. ## Data synchronization In addition to the fully built-in embedded UIs, the integration can also synchronize data from Hyperline to Attio custom objects. This synchronization is optional and can be configured afterward. When you connect your Attio workspace and select which entities you want to synchronize in the Hyperline settings, Hyperline automatically creates the required custom objects and their associated fields in Attio (if they do not already exist) and sets up the synchronization mechanisms. Deleting or manually modifying Hyperline custom objects and custom fields in Attio may break the integration and lead to unexpected behavior. Changing the data you choose to synchronize requires reconfiguring the integration. This process may take a few minutes to complete. ### Customers sync When enabled, Hyperline customers are synchronized with Attio companies. You can choose the synchronization direction (one-way or bidirectional). During the integration setup, Hyperline creates a “(Hyperline) Synchronize” checkbox custom field (`hyperline_sync` slug) on the Company object. An Attio company is imported and synchronized into Hyperline only when this checkbox is enabled; companies without it checked are ignored. ### Customer custom properties You can synchronize customer custom properties in two ways: * **As Attio company attributes** — create an attribute on the Attio Company object whose slug exactly matches the Hyperline custom property `slug`. Hyperline then synchronizes its value with the linked company according to the customer synchronization direction you selected. * **As custom property value records** — enable **Custom property values** in the integration settings. Hyperline creates one record for each value in its dedicated custom property value object and links customer values to the related Attio company. This option also keeps each property's name, type, and value available as separate attributes. If a Hyperline customer custom property uses the `customer_tier` slug, create an Attio company attribute with the `customer_tier` slug to keep the value directly on the company record. The matching Attio company attribute must already exist and be writable. Hyperline does not create it automatically. When you use the custom object option, Hyperline creates the required object and attributes during integration setup. ### Mapping Below are the object mappings between Hyperline entities and Attio custom objects. Object and field mappings between Hyperline entities and Attio custom objects ### Manually trigger a sync You can also manually trigger customer data synchronization from the Hyperline customer page. In the Integrations dropdown, click “Sync with Attio” to push (or pull, depending on the sync direction) the customer's data and send all associated quotes, subscriptions, and invoices to Attio. ## Troubleshooting If you encounter any issues with the integration (missing data, failed entity synchronization, etc.), we recommend checking the Hyperline issues page for more details: Settings > Integrations > Attio > View issues. ### Common issues **Embedded Hyperline views don't load, or an action loads forever** This happens when your browser blocks third-party cookies, which Hyperline needs to authenticate the embedded view inside your CRM. Allow third-party cookies for `[*.]hyperline.co`, then reload the page: * **Chrome / Arc**: open [chrome://settings/cookies](chrome://settings/cookies), then under "Sites allowed to use third-party cookies" add `[*.]hyperline.co` (or select "Allow all cookies"). See [Google's guide](https://support.google.com/chrome/answer/95647). * **Edge**: open `edge://settings/content/cookies` and add `[*.]hyperline.co` under "Allow". See [Microsoft's guide](https://support.microsoft.com/microsoft-edge/temporarily-allow-cookies-and-site-data-in-microsoft-edge-597f04f2-c0ce-f08c-7c2b-541086362182). * **Safari**: open Settings > Privacy and uncheck "Prevent cross-site tracking". See [Apple's guide](https://support.apple.com/guide/safari/manage-cookies-sfri11471). * **Firefox**: click the shield icon in the address bar and turn off "Enhanced Tracking Protection" for this site, or add an exception under Settings > Privacy & Security. See [Mozilla's guide](https://support.mozilla.org/kb/enhanced-tracking-protection-firefox-desktop). Also disable any browser extension that blocks cookies or trackers for this site. ## Disconnect At any time, you can disconnect the integration by clicking the Disconnect button located in the top-right corner of the Attio integration settings page. Disconnecting the integration will stop all synchronization, but the custom objects, custom fields, and any previously pushed data in Attio will remain intact—they will not be deleted. # Exact Online Source: https://docs.hyperline.co/integrations/exact-online Push invoices, credit notes, and customers from Hyperline into Exact Online accounting for Belgian, French, German, and Dutch bookkeeping. [Exact](https://www.exact.com) is a Dutch technology company that provides software for small and medium enterprises. Exact Online is its cloud-based accounting software. ## Prerequisites You need to have a valid [Exact Online account](https://www.exact.com/fr/software/exact-online) and admin rights on Hyperline. ## Setup If your Exact Online user has access to several companies (divisions), make sure you are logged into Exact Online and have switched to the division you want to connect to Hyperline **before** starting the connection flow. This also applies when reauthorizing or reconnecting an existing integration. Hyperline connects to whichever division is active in Exact Online at the moment of the OAuth flow. Choose the Exact Online region that matches your account: **Belgium**, **France**, **Germany**, or **Netherlands**. You will be redirected to the corresponding Exact Online login page. If you are not already logged into Exact Online, enter your credentials to proceed. Hyperline detects and configures your division automatically when Exact Online redirects you back. Configure the required codes and select your invoice push mode. See the [Invoice push mode](#invoice-push-mode) and [Settings](#settings) sections below for details. Your Hyperline account is ready to send invoices and credit notes. ## Connect multiple Exact Online accounts You can connect more than one Exact Online account to the same Hyperline workspace. This is useful if you operate several legal entities across regions (for example, one Belgian and one German subsidiary) and need to route each to its own Exact Online environment. To add another account, go to **Settings > Integrations**, click **Connect** on the Exact Online card again, and select the region for the new account. Each connection is tied to its own region and can be reauthorized independently from its provider page in Hyperline. ## Reconcile Hyperline and Exact Online customers If you already have existing customers in Exact Online, we'll need to link them with the corresponding customers in Hyperline. Our support team is available to assist you with this process during onboarding. ## Synchronization When you connect your Exact Online account, Hyperline **automatically sends invoices** with their complete details (including line items and PDF file). By default, only invoices and customers created after the connection date will sync. If you need to push older data to Exact Online, please contact our support team. ### Invoice PDF synchronization Invoice PDFs are automatically attached to invoices in Exact Online when they are first synced. If you need to re-attach or update PDFs for existing invoices (for example, if the initial attachment failed), please contact our support team. ### Customer synchronization Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not synchronized with Exact Online. * **from Hyperline to Exact Online**: customers created in Hyperline are automatically created in Exact Online with their details. ### Payment synchronization Hyperline supports 3 modes of synchronization for payments: * **no synchronization**: payments are not synchronized with Exact Online. * **from Exact Online to Hyperline**: payments created in Exact Online are automatically created in Hyperline, and the status of the related invoice is updated accordingly. * **from Hyperline to Exact Online**: payments created in Hyperline are automatically created in Exact Online as bank journal entries. The synchronization delay is 1 hour maximum. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration). ## Invoice push mode Hyperline can push invoices to Exact Online in two different ways: * **Sales Invoices** (default): Invoices are created as sales invoices in Exact Online. This mode is useful if you need to manage invoices directly in Exact Online's invoice module. * **Sales Entries**: Invoices are created as sales entries (journal entries) in Exact Online. Enable the **Create sales journal entry instead of sales invoice** flag in your integration settings to use this mode. The push mode applies to both invoices and credit notes. ## Settings You can configure the following codes on the **Settings > Integrations > Exact Online** page: * **Invoice account code**: General Ledger (GL) account code used for invoices. * **Credit note account code**: GL account code used for credit notes. * **Payment account code**: GL account code used for payments created in Exact Online. * **Invoice sales journal code**: Sales journal used when pushing invoices as sales entries. By default, invoices will be created with the sales journal code *70*. * **Credit note sales journal code**: Sales journal used when pushing credit notes as sales entries. By default, credit notes will be created with the sales journal code *70*. * **Bank journal code**: Bank journal used when creating payments in Exact Online. * **Tax code**: Default tax code used when no tax code is matched for the line items products. ### Product, tax and account codes Exact Online requires a **product code** for every invoice line item only when using the **Sales Invoices** mode. When using the **Sales Entries** mode, product codes are not required. Tax codes can be configured in two different ways: * **At the product level**: Define a specific tax code for each product in Hyperline. This tax code will be used when the product is invoiced. * **At the invoicing entity level**: Configure tax codes with automatic computation of tax rates in the tax settings of the relevant invoicing entity. When configured this way, tax codes are automatically resolved according to what is configured in Hyperline and pushed to Exact Online. You can also define a General Ledger **account code** for every product. If no account code is defined, the default invoice or credit note account code will be used. # GoCardless Source: https://docs.hyperline.co/integrations/gocardless Collect SEPA, BACS, and ACH direct debit payments through GoCardless on Hyperline with one-click setup, mandate management, and reconciliation. ## Prerequisites You need to have a [GoCardless](https://gocardless.com) account, finished GoCardless's onboarding flow, and admin rights on Hyperline. ## Setup If [GoCardless](https://gocardless.com) is your preferred Payment Service Provider, integrating it with Hyperline is a straightforward process: 1. In the menu, select **Settings** 2. Select **Payment** 3. Click on **Connect payment provider**, then GoCardless This will direct you to the GoCardless login page, where you will need to enter your account credentials and click **Connect Account**. Once the process is completed, you will see GoCardless appearing as **Active** in the Payment page. You can connect multiple GoCardless accounts to Hyperline so that payments are routed based on your invoicing entities and preferences. ## Payment methods GoCardless through Hyperline supports: * **Direct Debit** payments including SEPA (EU), Bacs (UK), or ACH (US) ## Customer information Each time you bill a customer in Hyperline, the corresponding customer profile and payment details (including payment methods and mandates) are automatically created and managed by Hyperline in your GoCardless account. Additionally, Hyperline integrates payment method collection forms into our hosted pages (checkout, customer portal, invoice page, and quote page), requiring no technical effort on your part. This seamless integration ensures that customer data and payments remain synchronized between Hyperline and GoCardless, streamlining transaction management and customer information handling. If you already have a GoCardless account with existing customers and payment methods, you have the possibility **to import them in Hyperline**. It is particularly useful when you configure your account. Please contact support if you are interested. ## Refund conditions Refunding payments via GoCardless is a user-friendly process, applicable for full or partial amounts through the dashboard or API. A concise timeline outlines the steps, with refunds typically processed 7 days after the payment charge date, unless users choose to opt-out. Timely customer notifications and swift fund receipt—usually within one to two business days—characterize the process. The significance of the default 7-day refund delay is underscored for refund safety. Payments via the bank debit network may not settle immediately, posing a risk of late failure payments. It is strongly advised not to refund within 7 days to ensure sufficient settling time and minimize the potential for refunding unreceived funds. Users seeking more flexibility can opt-out of this default restriction, as explained in the [official documentation](https://hub.gocardless.com/s/article/Refunding-payments?language=en_GB), providing a balance between user control and risk management. # Hightouch Source: https://docs.hyperline.co/integrations/hightouch Sync customer and revenue data from Hightouch into Hyperline reverse-ETL pipelines to power billing automation and finance workflows. ## What is Hightouch? [Hightouch](https://hightouch.com) is a platform that enables businesses to sync data between different systems, databases, or applications, often associated with data integration and synchronization. It facilitates the movement of data between various sources and destinations, allowing companies to streamline their operations, automate processes, and ensure that different tools or databases remain up-to-date with the most recent information. All this data can be easily sent to Hyperline to collect your customer's usage and automate usage-based billing and invoicing. ## Send usage from Hightouch to Hyperline ### Configure a data source The first thing you need to create in Hightouch is a `source`. The source can be of any type (spreadsheet, database, warehouse, etc). ### Create an HTTP Request destination Hyperline uses HTTP requests to ingest usage. Setting up this `destination` in Hightouch takes only a few clicks: You need to add two headers: * `Authorization` with `Bearer ` as a **secret** value * `Content-Type` with `application/json` as value ### Create a model After saving the destination, you need to create a `model` representing the entity you want to sync (represented as `event` in Hyperline). Put a name and select a primary key from the source fields. After finishing the model, you can also configure more settings on it like column types, descriptions, etc. ### Create a sync The last step you need to configure is a `sync`. Syncs declare how you want query results from a model to appear in your destination (Hyperline). Put a name and select a primary key from the source fields. Select **Row added** and **Row updated** triggers, **POST** HTTP request method, don't change the URL, **JSON** as type of payload with **Use JSON editor**. Here is an example of JSON payload that can be sent to the Hyperline ingest API. ```json theme={null} { "customer_id": "{{ row.customerId }}", "event_type": "{{ row.eventType }}", "timestamp": "{{ row.timestamp }}", "record": { "id": "{{ row.eventId }}", "my_property": "{{ row.customProperty }}", // add any custom properties you want to ingest in Hyperline }, } ``` Hightouch supports Liquid template language to insert variables from your source to your JSON payload. These variables are created following this syntax: `{{ row.variable }}`, `variable` being the column name of your source. Verify your synchronization by using a data sample. A new event should appear on your events [explore](https://app.hyperline.co/app/events/explore) page within Hyperline. When you're ready, activate this sync and specify a periodic trigger. # HubSpot Source: https://docs.hyperline.co/integrations/hubspot Connect HubSpot with Hyperline to sync deals, customers, contracts, and subscription data between your CRM and your billing platform. The Hyperline-HubSpot integration provides a seamless connection between your HubSpot instance and Hyperline. With this integration, you can access a dedicated widget directly from HubSpot, allowing you to create and manage Hyperline quotes, subscriptions, and customers without leaving your CRM. This feature embeds the full Hyperline interface inside HubSpot, ensuring smooth and efficient flows. In addition, the integration enables optional and automatic data synchronization between Hyperline entities—such as quotes, subscriptions, and invoice details—and HubSpot's custom objects. This ensures you always have the most up-to-date information at your fingertips, allowing this data to be used for internal automations, workflows, and reporting within HubSpot. ## Prerequisites You must have a valid [HubSpot account](https://hubspot.com) and access to the settings of your Hyperline account. We recommend **experimenting with a test account** before going live. You can create a free [HubSpot account](https://app.hubspot.com/signup-hubspot/crm) and use the [test mode](../docs/getting-started/sandbox) of your Hyperline account during setup and testing. ## Embedded Hyperline UIs in HubSpot ### Installation Upon connecting your HubSpot account to Hyperline, Hyperline automatically adds a HubSpot card to your HubSpot account. This card will appear on your company and deal pages, allowing your revenue teams to keep using HubSpot while seamlessly accessing all Hyperline functionalities. If the card isn't added automatically, you can add it manually. Open a company or deal record page and go to **Customize** > **Default view** (or any view) > **Edit layout**. In the right panel, hover over an existing card to reveal the option to add a new one. Select Hyperline and save your changes. ### Card Once installed, this card can be used on **company**, **contact**, and **deal** pages (right side panel). It provides several available actions, allowing you to: * create Hyperline quotes * create Hyperline subscriptions * manage the related Hyperline customer Each action opens a dedicated Hyperline interface embedded directly within HubSpot, giving you access to the full Hyperline experience without leaving your CRM—ensuring seamless interoperability between both systems. ### Settings The card's behavior can be fine-tuned from **Settings** > **Integrations** > **HubSpot**. #### Root object Controls which HubSpot object the widget treats as the source of truth when displaying Hyperline billing data (quotes and subscriptions). Two modes are available: * **Company** — All quotes and subscriptions of a company are displayed on both the company card and the cards of its related deals. Choose this option if your revenue team thinks about billing at the customer level and wants the full billing picture available from any deal tied to that customer. * **Deal** — Only the quotes and subscriptions attached to a specific deal are displayed on that deal's card. The company card still shows all of the company's quotes and subscriptions. Choose this option if you want each deal to surface only its own billing items, with no cross-deal bleed. This setting only affects what's displayed in the embedded widget; it does not change how data is synchronized with HubSpot custom objects. #### Allow creating new customer When enabled, a HubSpot user triggering an action from a company or deal that isn't yet linked to a Hyperline customer can create the corresponding Hyperline customer on the fly and proceed with the action. When disabled, actions are blocked until a matching Hyperline customer exists and is linked to the HubSpot record. #### Display customers' children's data When enabled, the widget also displays quotes and subscriptions belonging to the customer's children (in Hyperline's parent–child customer hierarchy), in addition to the customer's own. Useful when you bill parent accounts but want visibility into activity across their subsidiaries from the parent's HubSpot record. ### User access HubSpot users do not need an existing Hyperline account. When a user triggers a Hyperline action for the first time, a corresponding Hyperline user is automatically created using their HubSpot email address and assigned to your default Hyperline role (the ['Account manager' role](../docs/getting-started/configure-account#account-manager-role) if not changed). When Hyperline interfaces are opened inside HubSpot, the user's Hyperline role is applied to ensure the correct view and edit permissions. These permissions are managed directly in Hyperline under Settings > Team. ### Data reconciliation Hyperline first determines which HubSpot record represents the customer. It then reconciles that record with a Hyperline customer. | Where you open the Hyperline card | Record used for reconciliation | | ----------------------------------------------------- | ------------------------------ | | Company | The company itself | | Contact associated with a company | The associated company | | Contact without an associated company | The contact itself | | Deal associated with a company | The associated company | | Deal without a company, but associated with a contact | The associated contact | For deals, Hyperline checks for an associated company first. It uses an associated contact only when no company is available. The deal identifies the sales opportunity but is not reconciled directly with a Hyperline customer. The **Root object** setting does not change this lookup order. It controls which quotes and subscriptions the card displays after Hyperline identifies the customer. After selecting the company or contact, Hyperline applies the following lookup mechanism: 1. If the HubSpot record is already linked to a Hyperline customer through the **Integrations** section of the customer page, Hyperline uses that customer. 2. If the record has a value in the Hyperline customer ID property, Hyperline looks for the corresponding customer. 3. If the record has a value in the Hyperline external ID property, Hyperline looks for a customer whose ID or external ID matches that value. Company and contact links are separate. Even if a contact belongs to a company, linking the contact does not link the company automatically. For B2B customers, associate the contact or deal with the correct company so Hyperline reconciles through the company. Use direct contact reconciliation for B2C customers without an associated company. If the HubSpot record and the Hyperline customer were not previously linked, the link is automatically created—provided the integration settings allow it. For companies, customer synchronization must be enabled, the direction must include HubSpot → Hyperline, and the company must be flagged for synchronization. If a customer is found but the settings do not allow automatic linking, Hyperline will surface the suggested customer in HubSpot, along with an action to manually trigger the link. If no customer is found but the “Allow creating new customer” setting is enabled, the HubSpot user will be able to create a new related Hyperline customer and proceed with the desired action. ## Data synchronization In addition to the fully built-in embedded UIs, the integration can also synchronize data from Hyperline to HubSpot custom objects. This synchronization is optional and can be configured afterward. Data synchronization with custom objects is only available for HubSpot **companies** and **not for contacts**. When you connect your HubSpot account and select which entities you want to synchronize in the Hyperline settings, Hyperline automatically creates the required custom objects and their associated fields in HubSpot (if they do not already exist) and sets up the synchronization mechanisms. Deleting or manually modifying Hyperline custom objects and custom fields in HubSpot may break the integration and lead to unexpected behavior. Changing the data you choose to synchronize requires reconfiguring the integration. This process may take a few minutes to complete. ### Prerequisites To synchronize data, Hyperline requires specific custom objects to exist in your HubSpot account. Hyperline does not have permission to automatically create custom objects in your HubSpot account. You must create them manually using the object internal names listed below. If a required custom object does not exist, you will be unable to activate synchronization for that entity, and no data will be pushed to HubSpot. Custom objects are available only on the HubSpot **Enterprise** plan. For more details, see the [HubSpot documentation](https://knowledge.hubspot.com/object-settings/create-custom-objects). | Entity | HubSpot object internal name | | --------------------- | ---------------------------------- | | Quote | `hyperline_quotes` | | Quote line item | `hyperline_quote_line_items` | | Quote coupon | `hyperline_quote_coupons` | | Quote phase | `hyperline_quote_phases` | | Quote file | `hyperline_quote_files` | | Subscription | `hyperline_subscriptions` | | Subscription product | `hyperline_subscription_products` | | Subscription coupon | `hyperline_subscription_coupons` | | Subscription phase | `hyperline_subscription_phases` | | Invoice | `hyperline_invoices` | | Invoice line item | `hyperline_invoice_line_items` | | Custom property value | `hyperline_custom_property_values` | To create the required custom objects: 1. Click the **Gear** icon (top-right corner). 2. Navigate to **Data Management** → **Objects** → **Custom Objects**. 3. Click the **Create Custom Object** button. 4. Enter the object details. Hyperline requires the **Internal name** to match one of the names listed in the table above. You may customize the display name as you prefer. 5. Repeat this process for each object you want to synchronize. Object `Internal name` **must match the required name** (HubSpot object internal name) listed above. Each custom object **must include a mandatory `name` field** of type `text`. The red sections must match the requirements; otherwise, the integration will fail. We recommend creating only the custom objects required for the specific entities you wish to sync. ### Customers sync When enabled, Hyperline customers are synchronized with HubSpot companies. You can choose the synchronization direction (one-way or bidirectional). During the integration setup, Hyperline creates a “(Hyperline) Synchronize” checkbox custom field (`hyperline_sync` slug) on the Company object. A HubSpot company is imported and synchronized into Hyperline only when this checkbox is enabled; companies without it checked are ignored. ### Customer custom properties You can synchronize customer custom properties in two ways: * **As HubSpot company properties** — create a property on the HubSpot Company object whose internal name exactly matches the Hyperline custom property `slug`. Hyperline then synchronizes its value with the linked company according to the customer synchronization direction you selected. * **As custom property value records** — enable **Custom property values** in the integration settings. Hyperline creates one record in the `hyperline_custom_property_values` custom object for each value and associates customer values with the related HubSpot company. This option also keeps each property's name, type, and value available as separate fields. If a Hyperline customer custom property uses the `customer_tier` slug, create a HubSpot company property with `customer_tier` as its internal name to keep the value directly on the company record. The matching HubSpot company property must already exist and be writable. Hyperline does not create it automatically. Synchronizing values through the custom object requires HubSpot Enterprise and the `hyperline_custom_property_values` object described above. ### Mapping Below are the default field mappings between Hyperline entities and HubSpot objects. Field mappings between Hyperline entities and HubSpot objects ### Manually trigger a sync You can also manually trigger customer data synchronization from the Hyperline customer page. In the Integrations dropdown, click “Sync with HubSpot” to push (or pull, depending on the sync direction) the customer's data and send all associated quotes, subscriptions, and invoices to HubSpot. ## Custom workflows Beyond the built-in synchronization, you can build your own automations in HubSpot by reacting to Hyperline [webhooks](../api-reference/docs/webhooks). A few examples of what this unlocks: * Update HubSpot deal fields (stage, close date, amount, custom properties) when a Hyperline quote is signed or voided. * Compute and write custom metrics (ARR, MRR, committed amount, contract length) on the company or deal once a subscription is activated or renewed. * Trigger HubSpot tasks, internal notifications, or Slack alerts when an invoice becomes late or a subscription is cancelled. * Move deals along your pipeline when subscription contracts start, renew, or expire. ### How it works 1. In Hyperline, create a webhook endpoint in **Settings** > **Webhooks** and subscribe to the events you care about (e.g. `quote.signed`, `subscription.activated`, `subscription.contract_renewed`, `invoice.settled`). See the full list in the [Webhooks](../api-reference/docs/webhooks) reference. 2. In HubSpot, expose an endpoint that receives the Hyperline payload. The most common patterns are: * A HubSpot workflow webhook trigger — use the Hyperline event to start a workflow that updates fields, sends notifications, or branches based on payload data. * A custom-coded action (HubSpot Operations Hub) or an external service (Zapier, n8n, your own backend) that calls the HubSpot API to update the relevant company or deal. 3. Use the Hyperline customer ID or HubSpot company ID from the webhook payload to resolve the correct HubSpot record, then apply your business logic. Hyperline webhooks are signed — verify the signature before acting on a payload. Details are in the [Webhooks](../api-reference/docs/webhooks) reference. ## Troubleshooting If you encounter any issues with the integration (missing data, failed entity synchronization, etc.), we recommend checking the Hyperline issues page for more details: Settings > Integrations > HubSpot > View issues. ### Common issues **Embedded Hyperline views don't load, or an action loads forever** This happens when your browser blocks third-party cookies, which Hyperline needs to authenticate the embedded view inside your CRM. Allow third-party cookies for `[*.]hyperline.co`, then reload the page: * **Chrome / Arc**: open [chrome://settings/cookies](chrome://settings/cookies), then under "Sites allowed to use third-party cookies" add `[*.]hyperline.co` (or select "Allow all cookies"). See [Google's guide](https://support.google.com/chrome/answer/95647). * **Edge**: open `edge://settings/content/cookies` and add `[*.]hyperline.co` under "Allow". See [Microsoft's guide](https://support.microsoft.com/microsoft-edge/temporarily-allow-cookies-and-site-data-in-microsoft-edge-597f04f2-c0ce-f08c-7c2b-541086362182). * **Safari**: open Settings > Privacy and uncheck "Prevent cross-site tracking". See [Apple's guide](https://support.apple.com/guide/safari/manage-cookies-sfri11471). * **Firefox**: click the shield icon in the address bar and turn off "Enhanced Tracking Protection" for this site, or add an exception under Settings > Privacy & Security. See [Mozilla's guide](https://support.mozilla.org/kb/enhanced-tracking-protection-firefox-desktop). Also disable any browser extension that blocks cookies or trackers for this site. **The HubSpot card is empty (only the buttons appear, with no data)** This issue usually occurs when the same HubSpot ID is assigned to multiple customers in Hyperline. Hyperline uses the first matching customer it finds, but that customer may not contain any data. Ensure that the HubSpot ID is assigned to only one customer in Hyperline — the correct one. ## Disconnect At any time, you can disconnect the integration by clicking the Disconnect button located in the top-right corner of the HubSpot integration settings page. Disconnecting the integration will stop all synchronization, but the custom objects, custom fields, and any previously pushed data in HubSpot will remain intact—they will not be deleted. # Mollie Source: https://docs.hyperline.co/integrations/mollie Collect card and local payment method transactions through Mollie on Hyperline with one-click connection and automatic invoice reconciliation. ## Prerequisites You need to have a [Mollie account](https://my.mollie.com/dashboard), finished Mollie's onboarding flow, and admin rights on Hyperline. ## Setup If [Mollie](https://www.mollie.com) is your preferred Payment Service Provider, connecting it with Hyperline is a straightforward process: 1. In the menu, select **Settings** 2. Select **Payment** 3. Click on **Connect payment provider**, then Mollie This will redirect you to the Mollie login page where you will have to enter your account credentials and click **Continue**. By default, we use the first [Mollie profile](https://my.mollie.com/dashboard/settings/profiles) available on your Mollie account. If you have multiple profiles and want to use a specific one, please contact our support. Once the process is completed, you will see Mollie appearing as **Active** in the Payment page. You can connect multiple Mollie accounts to Hyperline so that payments are routed based on your invoicing entities and preferences. ## Payment methods Mollie through Hyperline supports: * **Card** payments * **Direct Debit** payments with SEPA (EU) ## Customer information Each time you bill a customer in Hyperline, the corresponding customer profile and payment details (including payment methods and mandates) are automatically created and managed by Hyperline in your Mollie account. Additionally, Hyperline integrates payment method collection forms into our hosted pages (checkout, customer portal, invoice page, and quote page), requiring no technical effort on your part. This seamless integration ensures that customer data and payments remain synchronized between Hyperline and Mollie, streamlining transaction management and customer information handling. If you already have a Mollie account with existing customers and payment methods, you have the possibility **to import them in Hyperline**. It is particularly useful when you configure your account. Please contact support if you are interested. # NetSuite Source: https://docs.hyperline.co/integrations/netsuite Connect NetSuite to synchronize customers, invoices, credit notes, payments, refunds, chargebacks, and wallet activity from Hyperline. [NetSuite](https://www.netsuite.com) is Oracle's cloud-based ERP and accounting platform. Hyperline connects to NetSuite so your finance team can send billing data from Hyperline to NetSuite without manually recreating customers, invoices, credit notes, payments, refunds, or chargebacks. ## What Hyperline synchronizes The NetSuite integration is a one-way accounting synchronization from Hyperline to NetSuite. Hyperline also reads NetSuite metadata, such as subsidiaries, items, accounts, tax codes, and custom fields, so you can configure mappings from the Hyperline interface. | Hyperline data | What happens in NetSuite | | --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Customers | Customers can be linked manually or created automatically when needed, depending on your customer synchronization setting. | | Invoices | Eligible Hyperline invoices are created as NetSuite **Invoice** records with the invoice currency and exchange rate when available. | | Credit notes | Hyperline credit notes are created as NetSuite **Credit Memo** records with the credit note currency and exchange rate when available. They can be applied to the original invoice when the credit note is linked to one. | | Invoice write-offs | When uncollectible invoice synchronization is enabled, Hyperline creates a NetSuite **Credit Memo** for the write-off and applies it to the original NetSuite Invoice. The Credit Memo uses the **Bad Debt Expense** account from the matching invoice sync rule. | | Payments | Settled payments are created as NetSuite **Customer Payment** records when the payment method is configured to synchronize. | | Refunds | Settled refunds are created as NetSuite **Customer Refund** records when the payment method is configured to synchronize. | | Chargebacks | Chargebacks are created as NetSuite **Customer Refund** records applied to the original Customer Payment when the payment method is configured to synchronize. | | Wallet top-ups and wallet refunds | Paid wallet top-ups are synchronized as customer payments. Credit notes refunded to the wallet are applied to the original invoice and reflected in NetSuite by adjusting the related Customer Payment applications. Free wallet credits are not synchronized as payments. | NetSuite does not send accounting changes back to Hyperline through this integration. Keep Hyperline as the source for billing documents and payments that should be synchronized. ## Prerequisites Before connecting NetSuite, make sure you have: * A NetSuite account with **SuiteTalk REST Web Services** and **Token-Based Authentication** enabled. * A NetSuite **Integration record** and access token for the user or role used by Hyperline. * Admin rights in Hyperline. * NetSuite subsidiaries, items, accounts, and tax codes ready for the Hyperline entities you plan to synchronize. * Hyperline products, sync rules, tax settings, and invoicing entities configured. ## Setup In NetSuite, go to **Setup > Company > Enable Features > SuiteCloud** and enable **Token-Based Authentication** and **SuiteTalk (REST Web Services)**. In NetSuite, go to **Setup > Integrations > Manage Integrations > New**, create an enabled integration record for Hyperline, and enable **Token-Based Authentication**. NetSuite shows the **Consumer Key** and **Consumer Secret** only once. Copy both values and store them securely. In NetSuite, go to **Setup > Users/Roles > Access Tokens > New** and create a token for the Hyperline integration record, user, and role. NetSuite shows the **Token ID** and **Token Secret** only once. Copy both values and store them securely. In Hyperline, open **Settings > Integrations**, select **NetSuite**, then enter your **Account ID**, **Consumer Key**, **Consumer Secret**, **Token ID**, and **Token Secret**. On **Settings > Integrations > NetSuite**, link each Hyperline invoicing entity to the matching NetSuite subsidiary. Map customers, products, accounts, tax codes, payment behavior, and optional custom fields. See [Configure mappings](#configure-mappings). ## Configure mappings ### Subsidiaries NetSuite requires a subsidiary on every customer and transaction. Map each Hyperline invoicing entity to a NetSuite subsidiary on **Settings > Integrations > NetSuite**. In OneWorld accounts, subsidiary mapping also controls which NetSuite items, accounts, and tax codes are available when you configure the rest of the integration. ### Customers If a customer already exists in NetSuite, you can link it to the matching Hyperline customer: 1. Open the customer in Hyperline. 2. Go to the **Integrations** section. 3. Click **Edit**. 4. Enter the NetSuite customer internal ID. 5. Click **Save**. For bulk linking during onboarding, contact our support team or use the [bulk provider mapping API](../api-reference/endpoints/customers/bulk-update-providerscustomers-mapping.mdx). You can choose whether Hyperline should create missing NetSuite customers automatically: * **No synchronization**: the customer must be linked manually before its invoices can be pushed. * **From Hyperline to NetSuite**: Hyperline creates the NetSuite customer the first time it is needed by an invoice, credit note, payment, refund, or chargeback. ### Products and items Every synchronized invoice line must have a NetSuite item. For each Hyperline product, open the product page, go to the **Accounting** section, and select the matching NetSuite item. Hyperline fetches items from NetSuite and filters the list based on the subsidiary mapped to the invoicing entity. If a product is missing an item mapping, the invoice synchronization stops with an issue you can fix and retry. If your NetSuite account uses revenue recognition rules, you can also select the relevant rule from the product **Accounting** section after choosing the NetSuite item. #### Coupon discount lines When an invoice or credit note includes coupons, Hyperline sends each coupon discount to NetSuite as a separate line below the impacted product line. This makes discounts easier to trace in NetSuite reports, revenue recognition, and journals. Each coupon discount line uses: * The same NetSuite item as the impacted product line. * The same account, tax code, and revenue recognition rule as the impacted product line. * A negative amount that offsets the gross product line amount. * A description that includes the coupon name, product name, and service period when available. When a coupon applies to multiple invoice lines, Hyperline splits the discount across the impacted lines and creates one discount line for each allocated share. #### Rounding product NetSuite can recalculate invoice and credit memo totals after Hyperline sends the record, for example when NetSuite applies its own tax or line rounding. To reconcile small differences, configure a dedicated rounding item from **Settings > Integrations > NetSuite > Default codes > Rounding product**. When the NetSuite total differs from the Hyperline total by one currency minor unit, such as EUR 0.01 or USD 0.01, Hyperline adds a non-taxable **Round Off** line using the selected item. The rounding item is only used for this adjustment line; regular invoice lines still use the product item mappings configured on each Hyperline product. If the difference is larger than one minor unit, Hyperline records an integration issue instead of adjusting the NetSuite record. If no rounding product is configured, Hyperline does not add a rounding adjustment line. #### Bulk update product mappings During implementation, you can update NetSuite product mappings for several products from the product catalog: 1. Go to **Catalog** > **Products**. 2. Select the products you want to update. 3. Click **Bulk update**. 4. In the accounting fields, update the NetSuite item or product code mapping. 5. If you use NetSuite revenue recognition, select the matching **Revenue recognition rule**. 6. Click **Save**. Complete product mappings before your first invoice synchronization. Missing NetSuite item mappings stop invoice synchronization until the affected products are corrected and retried. ### Accounts Configure NetSuite account mappings from **Settings > Integrations > NetSuite > Sync rules**. Only accounts that can be used for posting are available in rules. Non-posting and statistical accounts are filtered out. If a NetSuite account does not appear in sync rules, check that the account is active, available to the relevant subsidiary, postable, and visible to the NetSuite role used by Hyperline. Review your sync rules before go-live so each invoice line, payment, refund, chargeback, and invoice write-off can resolve to the expected NetSuite account. Coupon discount lines use the same account as the product line they discount. To route discounts differently, configure account sync rule criteria so the impacted invoice line resolves to the expected account. If you synchronize invoices marked `uncollectible`, configure **Bad Debt Expense** on the matching invoice sync rule. NetSuite write-offs are created as Credit Memos applied to the original invoice, and Hyperline uses this account on the write-off lines. If no matching rule provides a bad debt expense account, the write-off synchronization stops with an issue you can fix and retry. #### Accounting sync rule criteria NetSuite account mapping is resolved from Hyperline sync rules. When a record is synchronized, Hyperline evaluates the matching rules, applies the highest-priority account mapping, then sends the matching NetSuite account on the invoice line, payment, refund, or chargeback record. Use rule criteria to control when a mapping applies: | Criterion | Use it when | | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | | **Products** | A specific product should post to a specific NetSuite account. | | **Product types** | A whole product category should share the same NetSuite account mapping. | | **Customers** | A customer needs a dedicated account override. | | **Coupons** | Discounts or revenue should be mapped differently when a coupon is used. | | **Currencies** | Transactions in one currency should post to a different account. | | **Countries** | Billing from a country or jurisdiction needs a specific mapping. | | **Billing interval** | Monthly, quarterly, annual, or one-off charges need different account treatment. | | **Accounting provider accounts** | A rule should apply only to this NetSuite connection when you have multiple accounting integrations or provider accounts. | | **Payment providers** | Settlements need different accounts depending on the payment provider. | | **Payment methods** | Settlements need different accounts depending on the method, such as card, SEPA direct debit, ACH, BACS, or bank transfer. | | **Bank accounts** | Payments received on different bank accounts should post to different cash accounts. | An empty criterion matches everything, which makes the rule a default. When multiple rules match, the highest priority wins for each mapped account role. ### Tax codes Configure tax codes at the Hyperline invoicing entity level. Hyperline resolves the tax code from the invoice tax settings and sends it to NetSuite for taxable invoice lines. See [Tax management](../docs/invoices/tax-management) for the Hyperline tax setup. ### Payment synchronization Payment, refund, and chargeback synchronization is configured per payment method, such as card, direct debit, bank transfer, external payments, and other payment sources. Each payment method can be set to: * **No synchronization**: payments, refunds, and chargebacks using this method are not sent to NetSuite. * **From Hyperline to NetSuite**: settled payments, settled refunds, and chargebacks are sent to NetSuite for the corresponding invoice or payment. For invoice overpayments, Hyperline creates the NetSuite Customer Payment for the full amount received. It applies only the remaining NetSuite invoice balance and leaves the excess amount unapplied on the Customer Payment. Invoice overpayments are not automatically treated as wallet top-ups. ### Optional field mappings You can map Hyperline customer fields, invoice custom properties, and invoice line fields to NetSuite fields from **Settings > Integrations > NetSuite**. This is useful for reporting dimensions such as location, department, class, contract references, or service periods. Create the relevant [custom properties](../docs/properties/overview) in Hyperline before mapping them to NetSuite fields. ## Synchronization behavior Hyperline sends eligible records to NetSuite automatically after they are created or updated. The synchronization delay is 5 minutes maximum. By default, only data created after the connection date is synchronized. To send older data, contact our support team or use **Resync** when the option is available from the integration actions menu. ### Daily catch-up synchronization Hyperline runs an additional NetSuite catch-up synchronization every day at **05:00 UTC**. This complements the regular synchronization and helps recover records that could not be sent during an earlier attempt. The daily run processes records in this order: 1. Retry eligible customer and invoice issues from previous runs, with customer issues first. 2. Synchronize customers changed since the previous daily run. 3. Synchronize invoices changed since the previous daily run. Hyperline automatically retries transient issues, such as temporary NetSuite or network errors, once per daily run for up to three automatic attempts. Configuration and validation issues, such as a missing item or account mapping, are not retried automatically because they require a correction first. Fix these issues, then retry them from **Settings > Integrations > NetSuite > View issues**. An automatically retried issue temporarily appears as retrying. After a successful synchronization, Hyperline removes the related issue from the open issues list. If the retry fails, the issue remains open with the latest error. Hyperline prevents two daily catch-up runs from overlapping. If a manual resync and the daily run target the same customer or invoice at the same time, Hyperline deduplicates the work so the record is not synchronized twice concurrently. ### Locked accounting periods For invoices, credit notes, and customer payment creation or updates, Hyperline checks the NetSuite accounting period for the transaction date. If that period is closed, fully locked, or A/R locked, Hyperline keeps the original transaction date and sends the record to the nearest open NetSuite posting period. Customer Payment deletion is stricter. If the NetSuite Customer Payment belongs to a closed, fully locked, or A/R locked period, Hyperline does not delete it and records an integration issue. An administrator can adjust or remove the payment in NetSuite, then resolve or ignore the issue in Hyperline when the accounting state is correct. For creation and updates, you do not need to reopen the locked period or change the financial date in Hyperline. The following invoice statuses are not pushed to NetSuite: * **draft** * **open** * **charged on parent** * **pending parent concatenation** * **closed** * **archived** ## Refunds, chargebacks, and wallet activity Credit notes are synchronized as NetSuite **Credit Memo** records. When a credit note is linked to an invoice in Hyperline, Hyperline applies the NetSuite credit memo to the matching NetSuite invoice. Settled refunds are synchronized as NetSuite **Customer Refund** records when the payment method is configured to synchronize. Chargebacks are also synchronized as NetSuite **Customer Refund** records, applied to the original Customer Payment. The related Customer Refund is removed and the Customer Payment application is restored when the chargeback is cleared or the transaction is deleted in Hyperline. When a credit note is refunded to the customer's wallet, Hyperline does not create a NetSuite Customer Refund because no cash refund is sent back to the customer. Instead, Hyperline applies the NetSuite Credit Memo to the original invoice and keeps the customer value available as wallet balance in Hyperline. If the original NetSuite invoice was already closed by payments, Hyperline first opens the invoice balance for the credit memo: * For wallet-paid invoices, Hyperline reduces or removes the wallet top-up Customer Payment application. * For card, direct debit, bank transfer, or other Hyperline-synchronized payments, Hyperline reduces the matching Customer Payment application for the credited amount. * For invoices paid by both wallet and another payment method, Hyperline adjusts the wallet payment first, then reduces the other synchronized payment only for the remaining amount. Hyperline does not change manual or unknown NetSuite payments when preparing a wallet-refunded credit note. If such a payment blocks the credit memo application, Hyperline records an integration issue so the payment can be reviewed in NetSuite. If NetSuite has locked a Customer Payment because it is deposited, Hyperline cannot change which invoices that payment is applied to. If the payment is included in a NetSuite Deposit, remove it from that Deposit. If the payment is posted directly to a bank account and shows as deposited, edit the Customer Payment and move it to Undeposited Funds. Then retry the failed synchronization from Hyperline. Hyperline will then reopen the original invoice balance and apply the Credit Memo. Paid wallet top-ups are handled separately from regular invoices: * The wallet top-up document generated by Hyperline is not pushed as a NetSuite Invoice. * Paid top-ups are synchronized as NetSuite Customer Payments when eligible. * Wallet payments are applied to the NetSuite invoices paid with wallet balance. * When a paid top-up is reverted, Hyperline unapplies the related NetSuite Customer Payment and creates a Customer Refund. If the original Customer Payment was not synchronized, Hyperline records an integration issue instead. * Free wallet credits are not pushed as Customer Payments. ## Guides ### Record an offline payment Choose the payment action based on how the payment should be applied. #### Payment for a specific invoice Use **Mark as paid** when the payment received is for one specific invoice and you want to apply it directly to that invoice. 1. Open the invoice in Hyperline. 2. Click **Actions** > **Mark as paid**. 3. Enter the payment details, such as the amount paid, settlement date, bank account, payment reference, or internal comment. 4. Click **Save**. When the payment method is configured to synchronize, Hyperline sends the settled payment to NetSuite as a **Customer Payment** applied to the matching NetSuite Invoice. #### Customer-level payment or prepayment Use **Record offline payment** from the customer's wallet when you receive one payment that should cover several invoices, or when part of the amount should remain available for future invoices. 1. Open the customer in Hyperline. 2. Go to the **Wallet** tab. 3. Click **Actions** > **Record offline payment**. 4. Enter the payment details, such as the amount received, bank account, payment reference, or internal comment. 5. Open the invoice you want to settle. 6. Click **Actions** > **Pay with wallet**. 7. Select the amount to allocate from the wallet to the invoice. 8. Repeat the wallet payment action on any other invoice that should use part of the same payment. Any unused amount remains in the customer's wallet. When the related payment method is configured to synchronize, Hyperline sends the full context to NetSuite: the customer payment, the invoices paid with wallet balance, the payment applications, and any remaining unapplied amount. ## Monitor and recover If NetSuite rejects a record or a mapping is missing, Hyperline records an integration issue. Open **Settings > Integrations > NetSuite > View issues** to review the error, fix the configuration or source data, then retry the synchronization. Use **Resync** from the integration actions menu after changing mappings, reconnecting NetSuite, or correcting issues that affected existing records. For accounting integrations, **Resync** can send missing invoices, update existing provider invoices, and update linked customers. See [Manage connected integrations](./manage-integration) for details about reauthorization, reconfiguration, resync, and disconnection actions. Is something still unclear? Don't hesitate to reach out to our team via the in-app chat if you need additional support. ## Next steps * Review sync rules on **Settings > Integrations > NetSuite** before mapping NetSuite accounts. * Configure [tax settings](../docs/invoices/tax-management) for each invoicing entity. # Integrations overview Source: https://docs.hyperline.co/integrations/overview Browse Hyperline integrations for payment gateways, accounting systems, CRMs, tax engines, and automation platforms to connect your billing stack. ## Payment gateway } href="./stripe" > Use Stripe's global payment processing platform as a payment gateway. } href="./mollie" > Use Europe-based Mollie payment processor as payment gateway. } href="./gocardless" > Use GoCardless direct debit as payment gateway. } href="./airwallex"> Use Airwallex payment processor as payment gateway. } href="./adyen" > Use Adyen payment platform as payment gateway. ## CRM } href="./salesforce" > Bi-directionally sync your Hyperline data with your Salesforce instance, and fully manage your quotes and subscriptions directly from your CRM. } href="./hubspot" > Bi-directionally sync your Hyperline data with your HubSpot account, and fully manage your quotes and subscriptions directly from your CRM. } href="./attio" > Bi-directionally sync your Hyperline data with your Attio account, and fully manage your quotes and subscriptions directly from your CRM. ## Accounting software } href="./pennylane" > Push your Hyperline invoicing data and reconcile easily with Pennylane. } href="./xero" > Push your Hyperline invoicing data and reconcile easily with Xero. } href="./quickbooks" > Push your Hyperline invoicing data and reconcile easily with QuickBooks. } href="./netsuite" > Push your Hyperline invoicing data and reconcile easily with NetSuite. } href="./rillet" > Push your Hyperline invoicing data and reconcile easily with Rillet. } href="./exact-online" > Push your Hyperline invoicing data and reconcile easily with Exact Online. } href="./zoho-books" > Push your Hyperline invoicing data and reconcile easily with Zoho Books. } > Push your Hyperline invoicing data to DATEV. ## Tax engine } > Compute taxes with Hyperline, only available in the EU. } > Connect and use your Anrok account as tax engine on Hyperline. ## Signature } > Native and embedded electronic signature flow. } > Connect and use your DocuSign account as signature provider on Hyperline. } > Connect and use your Yousign account as signature provider on Hyperline. ## AI } href="https://chatgpt.com/apps/hyperline/asdk_app_6a1da415f0908191b74b5b89f9546b4f" > Access Hyperline from ChatGPT to answer questions and manage revenue operations. } href="../api-reference/docs/ai/mcp" > Connect Claude to Hyperline through MCP. } href="../api-reference/docs/ai/mcp" > Connect Cursor to Hyperline through MCP. ## Support platform } href="../docs/customer-intelligence/overview" > Bring Intercom support conversations into customer intelligence. } href="../docs/customer-intelligence/overview" > Bring Front support conversations into customer intelligence. } href="../docs/customer-intelligence/overview" > Bring Plain support conversations into customer intelligence. } href="../docs/customer-intelligence/overview" > Bring Pylon support conversations into customer intelligence. } href="../docs/customer-intelligence/overview" > Bring Zendesk support conversations into customer intelligence. ## Email } href="../docs/customer-intelligence/overview" > Use Gmail messages as context in customer intelligence. ## Call recording } href="../docs/customer-intelligence/overview" > Use Google Meet call recordings and Gemini meeting notes in customer intelligence. } href="../docs/customer-intelligence/overview" > Use Claap call recordings and meeting notes in customer intelligence. } href="../docs/customer-intelligence/overview" > Use Attio call recordings and meeting notes in customer intelligence. } href="../docs/customer-intelligence/overview" > Use Grain call recordings and meeting notes in customer intelligence. ## Usage data } href="../docs/usage/usage-data-with-connectors" > Automatically pull usage data from your MySQL database. } href="../docs/usage/usage-data-with-connectors" > Automatically pull usage data from your PostgreSQL database. } href="../docs/usage/mongodb" > Automatically pull usage data from your MongoDB database. } href="../docs/usage/bigquery" > Automatically pull usage data from your BigQuery database. } href="../docs/usage/snowflake" > Automatically pull usage data from your Snowflake database. } href="../docs/usage/posthog" > Automatically pull usage data from your PostHog project. } href="./segment" > Push events collected by Segment to Hyperline. } href="./hightouch" > Sync data from databases, warehouses, spreadsheets, and more to Hyperline. ## Automation } href="./zapier" > Create any custom workflow with no-code using the native Hyperline Zapier app. } href="./slack" > Send messages to Slack in reaction to events in Hyperline. ## Analytics } href="../docs/analytics/insights" > Explore financial and revenue metrics with interactive charts, drill-down tables, and custom filters. } href="https://www.fincome.co?utm_source=hyperline"> Monitor and analyze Hyperline subscription revenue with Fincome. } href="https://www.chartmogul.com?utm_source=hyperline" > Monitor and analyze Hyperline subscription revenue with ChartMogul. # Pennylane Source: https://docs.hyperline.co/integrations/pennylane Push invoices, credit notes, and customer data from Hyperline to Pennylane accounting for French SMBs with automatic ledger synchronization. [Pennylane](https://www.pennylane.com) is a French financial and accounting management solution, available as SaaS. ## Prerequisites You need to have a valid [Pennylane account](https://www.pennylane.com) and admin rights on Hyperline. ## Setup If you are not already logged into Pennylane, enter your Pennylane credentials to proceed. Select and authorize the company you want to use. Your Hyperline account is ready to send invoices and credit notes. ## Reconcile Hyperline and Pennylane customers If you already have existing customers in Pennylane, we'll need to link them with the corresponding customers in Hyperline. Our support team is available to assist you with this process during onboarding. ## Synchronization When you connect your Pennylane account, Hyperline **automatically sends invoices** with their complete details (including line items and PDF file). Hyperline only exports invoices created in Hyperline to Pennylane. Invoices imported from Pennylane into Hyperline (or linked to Hyperline-managed subscriptions) are not re-exported to avoid duplication and data conflicts. If you use Stripe Payments or GoCardless with Hyperline, you also must connect them directly to your Pennylane account to ensure proper enrichment and reconciliation flow in Pennylane. By default, only invoices and customers created after the connection date will sync. If you need to push older data to Pennylane, please contact our support team. ### Customer synchronization Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not synchronized with Pennylane. * **from Hyperline to Pennylane**: customers created in Hyperline are automatically created in Pennylane with their details. Alternatively, you can manually link a Pennylane customer to a Hyperline customer. On the Hyperline customer page, click the `Edit` button in the `Integrations` section, then paste either the Pennylane customer ID or the URL to the Pennylane customer page. ### Payment synchronization Hyperline supports 3 modes of synchronization for payments: * **no synchronization**: payments are not synchronized with Pennylane. * **from Hyperline to Pennylane**: payments created in Hyperline are automatically created in Pennylane and associated to the corresponding invoice. Due to a Pennylane API limitation, only payments done using Stripe or GoCardless can be synced. * **from Pennylane to Hyperline**: payments created in Pennylane are automatically created in Hyperline, and the status of the invoice is updated accordingly. The synchronization delay is 5 minutes maximum. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration). ### Product and account codes Account codes set on products in Hyperline must be configured **without trailing zeros**. For example, if your Pennylane account code is `7010301000`, you should enter `7010301` in Hyperline. Pennylane may display account codes with trailing zeros, but these should be removed when configuring them in Hyperline to ensure proper synchronization. ## Troubleshooting sync errors If a Pennylane sync fails, open the Pennylane integration issues page in Hyperline to review the latest error and retry once the data has been corrected. Common causes include: | Error | What to check | | -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Duplicate payment | The payment may already exist in Pennylane, often because it was created manually or synced from the payment provider. Remove the duplicate or adjust the reconciliation in Pennylane before retrying. | | Line total or VAT mismatch | Pennylane rejected the invoice because the line totals, tax rates, or VAT amounts do not match its expected calculation. Check the invoice lines, tax codes, and rounding before retrying. | | Missing customer or account code | The linked customer, product account code, or ledger mapping is missing or invalid. Complete the mapping in Hyperline, then retry the sync. | By default, only invoices, customers, and payments created after the Pennylane connection date are synchronized. If you need to push older data, contact support to request a backfill. During some migrations, Pennylane can display an imported invoice as partially paid even when the invoice total is fully covered by payments. This usually comes from a header-total or reconciliation mismatch. Contact support with the invoice ID so the team can review the Pennylane response. # QuickBooks Source: https://docs.hyperline.co/integrations/quickbooks Push invoices, credit notes, customers, and payments from Hyperline to QuickBooks Online accounting with chart of accounts and tax mapping. [QuickBooks](https://www.quickbooks.com) is a US accounting software developed by Intuit. ## Prerequisites You need to have a valid [QuickBooks account](https://www.quickbooks.com) and admin rights on Hyperline. ## Setup If you are not already logged into QuickBooks, enter your QuickBooks credentials to proceed. Your Hyperline account is ready to send invoices and credit notes. ## Reconciling data ### Customers To link an existing QuickBooks customer to a Hyperline customer, navigate to the customer details page, click the "Edit" button in the "Integrations" section, and enter the QuickBooks customer ID. For bulk operations during initial setup, contact our support team or use [this API endpoint](../api-reference/endpoints/customers/bulk-update-providerscustomers-mapping.mdx). ### Products You can map your QuickBooks products (items) to your Hyperline product catalog. For each product in Hyperline, go to the Accounting section and enter the corresponding QuickBooks item name in the "Product code" field. When specified, Hyperline automatically attaches each invoice line item to the corresponding item in QuickBooks. ### Taxes When pushing an invoice with taxable line items, QuickBooks requires a tax code to be associated with each line. You can provide it in two ways: * **At the product level**: Define a specific tax code on each product in Hyperline (Catalog → Products → Accounting → Tax code). This code is used when the product appears on an invoice. * **At the invoicing entity level**: Configure tax codes on the default tax rates of the invoicing entity, in **Settings > Invoicing entities > Taxes**. Hyperline resolves the right tax code based on the invoice's tax rate before pushing it to QuickBooks. See [Default tax rates](../docs/invoices/tax-management#default-tax-rates) for details. As a fallback, you can set a **Default tax code** in **Settings > Integrations > QuickBooks**. It is used whenever a taxable line item has no resolved tax code. For US QuickBooks accounts, only the built-in `TAX` and `NON` tax codes are supported on line items. The Default tax code is still required to push invoices with non-zero tax, as QuickBooks uses it to override the computed sales tax. ## Synchronization When you connect your QuickBooks account, Hyperline **automatically sends invoices** with their complete details (including line item details). By default, only invoices and customers created after the connection date will sync. If you need to push older data to QuickBooks, please contact our support team. ### Customers Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not synchronized with QuickBooks. * **from Hyperline to QuickBooks**: customers created in Hyperline are automatically created in QuickBooks with their details. ### Payments Hyperline supports 3 modes of synchronization for payments: * **no synchronization**: payments are not synchronized with QuickBooks. * **from Hyperline to QuickBooks**: payments created in Hyperline are automatically created in QuickBooks and associated to the corresponding invoice. * **from QuickBooks to Hyperline**: payments created in QuickBooks are automatically created in Hyperline, and the status of the invoice is updated accordingly. Synchronization occurs within 5 minutes. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration). ## Troubleshooting If you encounter any issues with the integration (missing data, failed entity synchronization, etc.), we recommend checking the Hyperline issues page for more details: Settings > Integrations > QuickBooks > View issues. ### Common issues **Invoice has taxable line items but no product tax code defined and no default tax code ref provided** This error is raised when Hyperline tries to push an invoice with taxable line items but cannot resolve a tax code for at least one line, and no Default tax code is configured on the integration. To fix it, set a tax code on the affected product(s), set tax codes on the default tax rates in **Settings > Invoicing entities > Taxes**, or set a **Default tax code** in **Settings > Integrations > QuickBooks**. See the [Taxes](#taxes) section for details. # Rillet Source: https://docs.hyperline.co/integrations/rillet Push invoices, credit notes, customers, payments, and subscription contracts from Hyperline to Rillet accounting with per-entity subsidiary mapping. [Rillet](https://www.rillet.com) is a modern AI-native ERP and accounting platform built for software companies. ## Prerequisites You need to have a valid [Rillet account](https://www.rillet.com), an API key issued from Rillet, and admin rights on Hyperline. ## Setup Hyperline uses the API key to authenticate every call to your Rillet account. The key can be revoked from Rillet at any time. On the **Settings > Integrations > Rillet** page, link each Hyperline invoicing entity to a Rillet subsidiary. The subsidiary drives the currency, accounts and tax codes available in the rest of the configuration. Pick **Revenue recognition only** or **Full accounting sync**, configure your products and (optionally) enable subscription contract sync. See [Settings](#settings) and [Mapping](#mapping) below. Your Hyperline account is ready to send invoices, credit notes, payments and contracts to Rillet. ## Settings You can configure the following options on the **Settings > Integrations > Rillet** page: * **Invoicing entity mapping**: per-entity table linking each Hyperline invoicing entity to a Rillet subsidiary. A subsidiary must be mapped for each entity that issues invoices — invoice push fails for any entity without a mapping. * **Revenue recognition mode**: see [Revenue recognition mode](#revenue-recognition-mode) below. * **Bank account**: cash account used to post payments in Rillet. Required when **Full accounting sync** is selected. The list is pulled from your Rillet chart of accounts. * **Sync subscriptions as contracts**: when enabled, Hyperline pushes each subscription to Rillet as a contract so Rillet can schedule revenue automatically. See [Contract sync](#contract-sync). ### Revenue recognition mode Hyperline can push invoices to Rillet in two different ways: * **Revenue recognition only** (default): Hyperline sends invoices so Rillet can recognise revenue. Rillet automatically settles payments on its side, so payments are not pushed from Hyperline. * **Full accounting sync**: Hyperline sends invoices and the matching payments to Rillet, including accounts receivable tracking. Requires a bank account to be configured. The mode applies to both invoices and credit notes. ## Mapping ### Customers To link an existing Rillet customer to a Hyperline customer, open the Hyperline customer page, click **Edit** in the **Integrations** section, and paste the Rillet customer ID. For bulk linking during initial onboarding, contact our support team or use [this API endpoint](../api-reference/endpoints/customers/bulk-update-providerscustomers-mapping.mdx). If a Hyperline customer is not linked to any Rillet customer, the behavior depends on the **Customer sync mode** configured in Settings: * **no synchronization** — the customer must be linked manually before any invoice can be pushed; otherwise the invoice push fails. * **from Hyperline to Rillet** — the customer is automatically created in Rillet the first time it is needed (typically on the first invoice push). ### Products Every invoice line item must be mapped to a Rillet product. For each product in Hyperline, go to the **Accounting** section of the product page and enter the corresponding Rillet product identifier in the **Product code** field. If a line item is missing a product mapping, the invoice push fails with a clear error listing the affected products so you can fix the mapping and retry. ### Tax codes Tax codes are configured **at the invoicing entity level** — set up tax codes with automatic computation in the tax settings of the relevant invoicing entity. Tax codes are then resolved according to what is configured in Hyperline and pushed to Rillet on each invoice line. ## Synchronization When you connect your Rillet account, Hyperline **automatically sends invoices, credit notes, customers, payments and (optionally) contracts** with their complete details. By default, only data created after the connection date is synced. To push older data, please contact our support team. Synchronization is **one-way: Hyperline → Rillet**. Rillet is queried read-only to fetch metadata (subsidiaries and chart of accounts). ### Customer synchronization Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not automatically created — they must be linked manually before any invoice can be pushed. * **from Hyperline to Rillet**: customers created in Hyperline are automatically created in Rillet with their details. ### Invoice and credit note synchronization Invoices and credit notes are pushed as native Rillet **invoices** and **credit memos**. Updates made to an invoice in Hyperline are propagated to the matching Rillet record automatically. ### Payment synchronization In **Revenue recognition only** mode, payments are not pushed to Rillet — Rillet automatically marks invoices as settled on its side once they are recognised. In **Full accounting sync** mode, Hyperline supports a **per-payment-method sync setting** (card, SEPA / ACH / BACS direct debit, bank transfer, Apple Pay, Google Pay, Stripe Link, external, other). Each can be set independently to: * **no synchronization**: payments are not synchronized. * **from Hyperline to Rillet**: payments settled in Hyperline are pushed to Rillet against the corresponding invoice using the configured bank account. The synchronization delay is 5 minutes maximum. ### Contract sync When **Sync subscriptions as contracts** is enabled, Hyperline pushes each Hyperline subscription to Rillet as a contract. Rillet uses the contract to schedule revenue recognition automatically over the subscription term. Contracts are kept in sync as the subscription evolves: changes are pushed as updates, and when a subscription is cancelled the matching Rillet contract is ended on the cancellation date. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration). # Salesforce Source: https://docs.hyperline.co/integrations/salesforce Connect Salesforce with Hyperline to sync accounts, opportunities, contracts, and subscription data between your CRM and billing platform. The Hyperline-Salesforce integration provides a seamless connection between your Salesforce instance and Hyperline. With this integration, you can access a dedicated widget directly from Salesforce, allowing you to create and manage Hyperline quotes, subscriptions, and customers without leaving your CRM. This feature embeds the full Hyperline interface inside Salesforce, ensuring smooth and efficient flows. In addition, the integration enables optional and automatic data synchronization between Hyperline entities—such as quotes, subscriptions, and invoice details—and Salesforce's custom objects. This ensures you always have the most up-to-date information at your fingertips, allowing this data to be used for internal automations, workflows, and reporting within Salesforce. ## Prerequisites You must have a valid [Salesforce account](https://salesforce.com) and access to the settings of your Hyperline account. We recommend **experimenting with a Salesforce Developer Account** before going live. You can create a free [Salesforce Developer instance](https://developer.salesforce.com/signup) and use the [test mode](../docs/getting-started/sandbox) of your Hyperline account during setup and testing. ### Permissions Hyperline automatically sets up the required technical components in your Salesforce instance upon connection to enable notifications and real-time synchronization. For this reason, we recommend using a user with the **System Administrator** profile when connecting your Salesforce instance. Otherwise, the user must manually be granted specific permissions. The user must have the following permissions: * **API Enabled** — Allows the user to execute API calls. * **Author Apex** — Allows the user to create and edit Apex classes and triggers. * **Customize Application** or **Modify All Data** — Allows the user to create or edit remote site settings. These permissions can be updated as follows: 1. Click the **Gear** icon (top-right corner) and select **Setup**. 2. In the **Quick Find** box, type “Profiles” and select **Profiles**. 3. Click **Edit** next to the profile you want to update. 4. Enable the required permission checkboxes and click **Save**. ## Embedded Hyperline UIs in Salesforce ### Installation Upon connecting your Salesforce instance to Hyperline, a Hyperline Salesforce package is automatically installed. This package includes a **native Salesforce component** that can be easily **added to your page layouts**, allowing your revenue teams to keep using Salesforce while seamlessly accessing all Hyperline functionalities. To add the component to an Account or Opportunity page: 1. Navigate to any Account or Opportunity page. 2. Click the menu in the top-right corner and select **Edit Page**. 3. Search for the **Hyperline** component and drag-and-drop it into the page layout. 4. Click **Save**. If this is your first time editing this layout, Salesforce will prompt you to **Activate** the updated view. ### Component Once installed, this component can be used on both **Account** and **Opportunity** pages. It provides several available actions, allowing you to: * create Hyperline quotes * create Hyperline subscriptions * manage the related Hyperline customer Each action opens a dedicated Hyperline interface embedded directly within Salesforce, giving you access to the full Hyperline experience without leaving your CRM—ensuring seamless interoperability between both systems. ### Settings The component's behavior can be fine-tuned from **Settings** > **Integrations** > **Salesforce**. #### Root object Controls which Salesforce object the component treats as the source of truth when displaying Hyperline billing data (quotes and subscriptions). Two modes are available: * **Account** — All quotes and subscriptions of an account are displayed on both the account component and the components of its related opportunities. Choose this option if your revenue team thinks about billing at the customer level and wants the full billing picture available from any opportunity tied to that customer. * **Opportunity** — Only the quotes and subscriptions attached to a specific opportunity are displayed on that opportunity's component. The account component still shows all of the account's quotes and subscriptions. Choose this option if you want each opportunity to surface only its own billing items, with no cross-opportunity bleed. This setting only affects what's displayed in the embedded component; it does not change how data is synchronized with Salesforce custom objects. #### Allow creating new customer When enabled, a Salesforce user triggering an action from an account or opportunity that isn't yet linked to a Hyperline customer can create the corresponding Hyperline customer on the fly and proceed with the action. When disabled, actions are blocked until a matching Hyperline customer exists and is linked to the Salesforce record. #### Display customers' children's data When enabled, the component also displays quotes and subscriptions belonging to the customer's children (in Hyperline's parent–child customer hierarchy), in addition to the customer's own. Useful when you bill parent accounts but want visibility into activity across their subsidiaries from the parent's Salesforce record. ### User access Salesforce users do not need an existing Hyperline account. When a user triggers a Hyperline action for the first time, a corresponding Hyperline user is automatically created using their Salesforce email address and assigned to your default Hyperline role (the ['Account manager' role](../docs/getting-started/configure-account#account-manager-role) if not changed). When Hyperline interfaces are opened inside Salesforce, the user's Hyperline role is applied to ensure the correct view and edit permissions. These permissions are managed directly in Hyperline under Settings > Team. ### Data reconciliation When retrieving Hyperline customer data from a Salesforce account or opportunity record, the following lookup mechanism is applied: 1. If it's an opportunity record, use the associated account record for the lookup. 2. If the account record is already linked to a Hyperline customer (via the Integrations section on the Hyperline customer page), that customer is used. 3. If the account record has a value in the Hyperline customer ID custom field, we attempt to resolve the corresponding Hyperline customer. 4. If the account record has a value in the Hyperline external ID custom field, we attempt to resolve the Hyperline customer whose ID or external ID matches that value. If the Salesforce account and the Hyperline customer were not previously linked, the link is automatically created—provided the integration settings allow it (customer sync enabled, sync direction including Salesforce → Hyperline, and the account flagged for sync). If a customer is found but the settings do not allow automatic linking, Hyperline will surface the suggested customer in Salesforce, along with an action to manually trigger the link. If no customer is found but the “Allow creating new customer” setting is enabled, the Salesforce user will be able to create a new related Hyperline customer and proceed with the desired action. ## Data synchronization In addition to the fully built-in embedded UIs, the integration can also synchronize data from Hyperline to Salesforce custom objects. This synchronization is optional and can be configured afterward. When you connect your Salesforce workspace and select which entities you want to synchronize in the Hyperline settings, Hyperline automatically creates the required custom objects and their associated fields in Salesforce (if they do not already exist) and sets up the synchronization mechanisms. Deleting or manually modifying Hyperline custom objects and custom fields in Salesforce may break the integration and lead to unexpected behavior. Changing the data you choose to synchronize requires reconfiguring the integration. This process may take a few minutes to complete. ### Prerequisites To synchronize data, Hyperline requires specific custom objects to exist in your Salesforce instance. Hyperline does not have permission to automatically create custom objects in your Salesforce instance. You must create them manually using the object names listed below. If a required custom object does not exist, you will be unable to activate synchronization for that entity, and no data will be pushed to Salesforce. | Entity | Salesforce Object Name | | --------------------- | ------------------------------ | | Quote | `HyperlineQuote` | | Quote line item | `HyperlineQuoteLineItem` | | Quote coupon | `HyperlineQuoteCoupon` | | Quote phase | `HyperlineQuotePhase` | | Quote file | `HyperlineQuoteFile` | | Subscription | `HyperlineSubscription` | | Subscription product | `HyperlineSubscriptionProduct` | | Subscription coupon | `HyperlineSubscriptionCoupon` | | Subscription phase | `HyperlineSubscriptionPhase` | | Invoice | `HyperlineInvoice` | | Invoice line item | `HyperlineInvoiceLineItem` | | Custom property value | `HyperlineCustomPropertyValue` | To create the required custom objects: 1. Click the **Gear** icon (top-right corner) and select **Setup**. 2. In the **Quick Find** box, type “Object Manager” and select **Object Manager**. 3. Click the **Create** dropdown and choose **Custom Object**. 4. Fill in the **Label**, **Object Name**, and **Record Name** fields. The **Object Name** must exactly match the required names listed above. Other fields may be configured according to your needs. 5. Repeat this process for each entity you want to synchronize. We recommend creating only the custom objects required for the specific entities you wish to sync. ### Customers sync When enabled, Hyperline customers are synchronized with Salesforce accounts. You can choose the synchronization direction (one-way or bidirectional). During the integration setup, Hyperline creates a “(Hyperline) Synchronize” checkbox custom field (`HyperlineSync__c` slug) on the Account object. A Salesforce account is imported and synchronized into Hyperline only when this checkbox is enabled; accounts without it checked are ignored. ### Customer custom properties You can synchronize customer custom properties in two ways: * **As Salesforce account fields** — create a custom field on the Salesforce Account object whose API name matches the Hyperline custom property `slug`, followed by `__c`. Hyperline then synchronizes its value with the linked account according to the customer synchronization direction you selected. * **As custom property value records** — enable **Custom property values** in the integration settings. Hyperline creates one record in the `HyperlineCustomPropertyValue` custom object for each value and links customer values to the related Salesforce account. This option also keeps each property's name, type, and value available as separate fields. If a Hyperline customer custom property uses the `customer_tier` slug, create the `customer_tier__c` custom field on the Salesforce Account object to keep the value directly on the account record. The matching Salesforce account field must already exist and be writable. Hyperline does not create it automatically. Synchronizing values through the custom object requires the `HyperlineCustomPropertyValue` object described above. ### Mapping Below are the default field mappings between Hyperline entities and Salesforce objects. Field mappings between Hyperline entities and Salesforce objects ### Manually trigger a sync You can also manually trigger customer data synchronization from the Hyperline customer page. In the Integrations dropdown, click “Sync with Salesforce” to push (or pull, depending on the sync direction) the customer's data and send all associated quotes, subscriptions, and invoices to Salesforce. ## Troubleshooting If you encounter any issues with the integration (missing data, failed entity synchronization, etc.), we recommend checking the Hyperline issues page for more details: Settings > Integrations > Salesforce > View issues. ### Common issues **The component is empty with "Nothing yet" display and no button** This issue usually occurs when the Salesforce instance is not connected to the correct Hyperline environment (production vs. sandbox). In Salesforce, go to Setup > Custom Code > Custom Settings, click Manage for Hyperline Settings, then Edit. Make sure the Environment field matches either `Production` or `Sandbox`, depending on your setup. **Embedded Hyperline views don't load, or an action loads forever** This happens when your browser blocks third-party cookies, which Hyperline needs to authenticate the embedded view inside your CRM. Allow third-party cookies for `[*.]hyperline.co`, then reload the page: * **Chrome / Arc**: open [chrome://settings/cookies](chrome://settings/cookies), then under "Sites allowed to use third-party cookies" add `[*.]hyperline.co` (or select "Allow all cookies"). See [Google's guide](https://support.google.com/chrome/answer/95647). * **Edge**: open `edge://settings/content/cookies` and add `[*.]hyperline.co` under "Allow". See [Microsoft's guide](https://support.microsoft.com/microsoft-edge/temporarily-allow-cookies-and-site-data-in-microsoft-edge-597f04f2-c0ce-f08c-7c2b-541086362182). * **Safari**: open Settings > Privacy and uncheck "Prevent cross-site tracking". See [Apple's guide](https://support.apple.com/guide/safari/manage-cookies-sfri11471). * **Firefox**: click the shield icon in the address bar and turn off "Enhanced Tracking Protection" for this site, or add an exception under Settings > Privacy & Security. See [Mozilla's guide](https://support.mozilla.org/kb/enhanced-tracking-protection-firefox-desktop). Also disable any browser extension that blocks cookies or trackers for this site. **The Salesforce component is empty (only the buttons appear, with no data)** This issue usually occurs when the same Salesforce ID is assigned to multiple customers in Hyperline. Hyperline uses the first matching customer it finds, but that customer may not contain any data. Ensure that the Salesforce ID is assigned to only one customer in Hyperline — the correct one. ## Disconnect At any time, you can disconnect the integration by clicking the Disconnect button located in the top-right corner of the Salesforce integration settings page. Disconnecting the integration will stop all synchronization, but the custom objects, custom fields, and any previously pushed data in Salesforce will remain intact—they will not be deleted. # Segment Source: https://docs.hyperline.co/integrations/segment Ingest usage events from Segment directly into Hyperline to drive usage-based billing without writing custom event-forwarding integrations. ## What is Segment? [Segment](https://segment.com) is a Customer Data Platform (CDP). It simplifies collecting and using data from the users of your digital properties (websites, apps, etc.). It allows you to collect, transform, send, and archive your first-party customer data. You can also enrich the customer data you collect by connecting data from your other tools, and then aggregate it to monitor performance, inform decision-making processes, and create uniquely customized user experiences. All this data can be easily sent to Hyperline to collect your customer's usage and automate usage-based billing and invoicing. ## Send usage from Segment to Hyperline To facilitate the transmission of usage data to Hyperline, we will generate and use a custom Function within Segment. Learn more about functions in [Segment's documentation](https://segment.com/docs/connections/functions). Replace the pre-written `onTrack` function in the code editor with the following code. The provided code will catch a Track event from Segment, and post it on Hyperline with the required properties picked from the Segment event. You can add any properties (with a value of type string, number, boolean, or array of the same types) you want to ingest in Hyperline by adding them in the `record` object. The field `my_property` is an example of an additional property pushed to Hyperline. ```javascript theme={null} async function onTrack(event, settings) { const endpoint = "https://ingest.hyperline.co/v1/events"; // https://docs.hyperline.co/api-reference/endpoints/billable-events/create-billable-event const event = { customer_id: event.userId, event_type: event.event, timestamp: event.timestamp, record: { id: event.messageId, my_property: event.properties.customProperty, // add any custom properties you want to ingest in Hyperline }, }; try { // Post request const response = await fetch(endpoint, { method: "POST", headers: { Authorization: `Bearer ${settings.apiKey}`, "Content-Type": "application/json", }, body: JSON.stringify(event), }); // Retry on 5xx (server errors) and 429s (rate limits) if (response.status >= 500 || response.status === 429) { throw new RetryError(`Failed with ${response.status}`); } return response.json(); } catch (error) { // Retry on connection error throw new RetryError(error.message); } } ``` This code example will forward all event types to Hyperline. If you want to limit the events sent, you can use the Segment [Destination Filters](https://segment.com/docs/connections/destinations/destination-filters), or alternatively modify the code to filter out the data you don't want to send. In the provided code snippet, the API key is a secret configured within the **Settings** tab on the right panel. This approach helps you refrain from hard-coding private variables directly into the function. To implement this: 1. Click on **Add Setting** 2. Input `API Key` as the label (resulting in the generated name `apiKey`) 3. Choose the type `String` 4. Enter your Hyperline API key on the input on the right. You can generate a key with the [following guide](../api-reference/docs/authentication#how-to-generate-an-api-key). 5. Toggle the `Required` and `Sensitive` options 6. Save your setting Finalize the creation of the function with a name ("Test Function" in the example below) and an optional description. After creating the function, you can use it as a Destination of an existing source (in the example below it's the `Backend - Staging` source). Make sure to enable it to start receiving events from Segment in Hyperline. # Slack Source: https://docs.hyperline.co/integrations/slack Connect Slack to Hyperline to send automated billing notifications, alerts, and quote approval requests to your team's channels and direct messages. ## What is Slack? [Slack](https://slack.com) is a collaborative communication platform for teams, offering real-time messaging, file sharing, and integration with various tools. It organizes conversations into channels based on topics, projects, or teams, fostering efficient and organized team communication. ## Connect Slack to Hyperline You can connect Slack as a native integration in Hyperline to receive automated notifications in Slack channels and personal notification messages. To connect Slack: 1. Go to **Settings > Integrations** 2. Find **Slack** in the list of available integrations 3. Click **Connect** and authorize Hyperline to access your Slack workspace 4. Once connected, you can start creating notification rules If the Slack integration shows **Needs action**, reconnect Slack from the integration page. This can happen when Hyperline adds new Slack permissions required for the integration to work fully. ## Notification rules Notification rules let you automatically send Slack messages when specific events happen in Hyperline. Each rule combines a **trigger** (the event), a **Slack channel** (where to send), and a **message template** (what to send). To create a notification rule: 1. Go to **Settings > Integrations > Slack > Notifications** 2. Click **Add rule** 3. Give the rule a **name** 4. Select a **trigger** from the list of available events 5. Choose the **Slack channel** where the notification should be sent 6. Customize the **message template** using variables 7. Save the rule Hyperline automatically attempts to join public Slack channels when you configure them in a notification rule. For private channels, you'll need to manually invite the Hyperline app to the channel. ## Quote approval requests in Slack When Slack is connected, quote approvers can receive approval requests directly in Slack through their personal notification settings. Slack approval request messages include the quote, customer, amount, quote owner, workflow, workflow step, and approvers. Hyperline also posts the quote PDF in a thread so approvers can review the document without leaving Slack. Approvers can: * Click **Approve** to approve the current workflow step * Click **Reject** to provide a rejection reason * Click **Open in Hyperline** to review the quote in Hyperline If the quote is already approved, rejected, or no longer waiting for that step, Hyperline refreshes the Slack message to show the current approval state. Users can manage personal Slack approval notifications from **Profile** > **Notifications**. Learn more about [quote approval workflows](/docs/quotes/approval). ### Available triggers You can create notification rules for the following events: | Trigger | Description | | ----------------------------- | ---------------------------------------------- | | Approval requested | An approval step has been requested | | Approval request approved | An approval step has been approved | | Approval request rejected | An approval step has been rejected | | Bank account errored | A bank account encountered an error | | Data loader failed | A data loader job has failed | | Invoice chargeback | An invoice has been charged back | | Invoice errored | An invoice encountered an error | | Invoice late | An invoice is overdue | | Invoice settled | An invoice has been fully paid | | Quote signed | A quote has been signed | | Quote viewed | A quote has been viewed | | Subscription activated | A subscription has been activated | | Subscription contract renewed | A subscription contract has been renewed | | Subscription renewed | A subscription has been renewed | | Subscription trial ended | A subscription trial period has ended | | Subscription voided | A subscription has been voided | | Aggregator threshold crossed | An aggregator usage threshold has been crossed | ### Message template Each notification rule includes a customizable message template. You can format the message using **Markdown** and insert **dynamic variables** that will be replaced with actual values when the notification is sent. Variables are inserted using the `{{variableName}}` syntax. The available variables depend on the selected trigger — for example, an invoice trigger provides variables like `{{invoiceNumber}}` and `{{invoiceAmount}}`, while a quote trigger provides `{{quoteNumber}}` and `{{quoteValue}}`. You can also use **custom properties** in your message templates (e.g. `{{myCustomProperty}}`). Hyperline automatically attempts to join public Slack channels when you configure them in a notification rule. For private channels, you'll need to manually invite the Hyperline app to the channel. # Stripe Source: https://docs.hyperline.co/integrations/stripe Collect card, ACH, SEPA, and Apple Pay payments through Stripe on Hyperline with one-click connection, customer sync, and full reconciliation. ## Prerequisites You need to have a [Stripe](https://stripe.com) account, finished Stripe's onboarding flow, and admin rights on Hyperline. ## Setup If [Stripe](https://stripe.com) is your preferred Payment Service Provider, connecting it with Hyperline is a straightforward process: 1. In the menu, select **Settings** 2. Select **Payment** 3. Click on **Connect payment provider**, then Stripe This will redirect you to the Stripe login page where you will have to enter your account credentials and click **Continue**. Once the process is completed, you will see Stripe appearing as **Active** in the Payment page. You can connect multiple Stripe accounts to Hyperline so that payments are routed based on your invoicing entities and preferences. ## Payment methods Stripe through Hyperline supports: * **Card** payments from major card schemes such as Visa, Mastercard, American Express, Discover & Diners, China Union Pay, eftpos, girocard, Interac, JCB and Maestro, depending on country and locality * **Direct Debit** payments including SEPA (EU), Bacs (UK), or ACH (US) * **Stripe Link** for faster checkout with saved payment details ## Customer information Each time you bill a customer in Hyperline, the corresponding customer profile and payment details (including payment methods and mandates) are automatically created and managed by Hyperline in your Stripe account. Additionally, Hyperline integrates payment method collection forms into our hosted pages (checkout, customer portal, invoice page, and quote page), requiring no technical effort on your part. This seamless integration ensures that customer data and payments remain synchronized between Hyperline and Stripe, streamlining transaction management and customer information handling. ## Importing existing Stripe data If you already have a Stripe account with existing customers, payment methods, products, prices, or subscriptions, Hyperline can import this data during setup. This is particularly useful when you are moving existing billing operations into Hyperline. Before importing, check these points: * Import prices before creating subscriptions that depend on them, including prices in a new currency such as CHF. * Subscriptions with the same Stripe product on multiple lines may be skipped during import. Consolidate the lines in Stripe, or use distinct products for each line, then run the import again. * Use your sandbox account first when validating the import flow or checking integration behavior. Please contact support before importing existing Stripe data. The team can confirm the expected scope and help you review skipped records after the import. # Xero Source: https://docs.hyperline.co/integrations/xero Push invoices, credit notes, customers, and payments from Hyperline to Xero accounting with automatic product mapping and tax code synchronization. [Xero](https://www.xero.com) is a New Zealand–based technology company that provides cloud-based accounting software for small businesses. ## Prerequisites You need to have a valid [Xero account](https://www.xero.com) and admin rights on Hyperline. ## Setup If you are not already logged into Xero, enter your Xero credentials to proceed. Choose the organisation you want to link to Hyperline, then click Allow access. By default, **your default invoicing entity** will be linked to this organisation. If you want to link a different entity, please contact our support team. Your Hyperline account is ready to send invoices and credit notes. ## Reconcile Hyperline and Xero customers If you already have existing customers in Xero, we'll need to link them with the corresponding customers in Hyperline. Our support team is available to assist you with this process during onboarding. ## Synchronization When you connect your Xero account, Hyperline **automatically sends invoices** with their complete details (including line items and PDF file). By default, only invoices and customers created after the connection date will sync. If you need to push older data to Xero, please contact our support team. ### Invoice PDF synchronization Invoice PDFs are automatically attached to invoices in Xero when they are first synced. If you need to re-attach or update PDFs for existing invoices (for example, if the initial attachment failed), please contact our support team. ### Customer synchronization Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not synchronized with Xero. * **from Hyperline to Xero**: customers created in Hyperline are automatically created in Xero with their details. When a customer is updated in Hyperline, the changes are automatically synced to Xero in real-time. ### Payment synchronization Hyperline supports 3 modes of synchronization for payments: * **no synchronization**: payments are not synchronized with Xero. * **from Hyperline to Xero**: payments created in Hyperline are automatically created in Xero and associated to the corresponding invoice. * **from Xero to Hyperline**: payments created in Xero are automatically created in Hyperline, and the status of the invoice is updated accordingly. The synchronization delay is 5 minutes maximum. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration). ## Settings Please contact our support team if you wish to change these settings. * **Invoice account code**: by default, invoices are created in Xero using the account code *200*. * **Credit note account code**: by default, credit notes are created in Xero using the account code *200*. * **Payment account code**: by default, payments are created in Xero using the account code *001*. ## Product and account codes Xero supports associating a product code and an account code to every invoice line item. You will need to configure the product code and the General Ledger account code for every product that you intend to invoice in Xero, in the **Products > Advanced settings** section. If no account code is defined, the default invoice or credit note account code will be used. # Automate Hyperline with Zapier Source: https://docs.hyperline.co/integrations/zapier Connect Hyperline to thousands of apps using Zapier — automate customer creation, invoice events, and subscription updates without writing code. ## What is Zapier? [Zapier](https://zapier.com) is an online automation tool that connects your apps and services. You can connect two or more apps to automate repetitive tasks without coding or relying on developers to build the integration. You can use Zapier to connect Hyperline to heaps of other tools your team is using such as your CRM, your accounting software, your product, and more. ### What is a Zap? A Zap is an automated workflow that connects your apps and services together. Each Zap consists of a trigger and one or more actions. When you turn your Zap on, it will run the action steps every time the trigger event occurs. ### Trigger and action A trigger is an event that starts a Zap, an action is an event a Zap performs after it is triggered. For example, if you want to create an account in your CRM each time a customer is created in Hyperline, the trigger is "Customer Created" which will trigger the action "Create an account in CRM". You can use the Hyperline app in Zapier to automate things like creating new customers from CRM, sending invoices to your accounting software, or pushing usage data into Hyperline. [Learn more about the basics of using Zapier.](https://zapier.com/resources/guides/quick-start/automation-basics) ### Available triggers The Hyperline Zapier app can start a Zap from several Hyperline events. The exact list available in Zapier depends on your app version, but the most common triggers are: | Trigger | When it runs | | ---------------------------- | ---------------------------------------------------- | | **Customer Created** | A customer is created in Hyperline. | | **Invoice Created** | An invoice is created in Hyperline. | | **Invoice Ready** | An invoice is finalized and ready to be paid. | | **Invoice Paid** | An invoice is settled. | | **Subscription Created** | A subscription is created. | | **Subscription Activated** | A subscription becomes active. | | **Payment Method Created** | A customer adds or starts adding a payment method. | | **Payment Method Activated** | A payment method becomes usable for future payments. | | **Payment Method Deleted** | A payment method is removed from the customer. | If your automation needs to react as soon as a customer enters a payment method, listen to **Payment Method Created**. **Payment Method Activated** only runs once the payment method is confirmed and usable. ### More resources There are lots of helpful guides in Zapier's help center, but here are some of the most useful ones to refer to when using our Zapier app: * [Learn key concepts in Zapier](https://help.zapier.com/hc/en-us/articles/8496181725453) * [Automation basics](https://zapier.com/resources/guides/quick-start/automation-basics) * [Using Filters in Zaps](https://help.zapier.com/hc/en-us/articles/8496276332557) * [Using Formatter in Zaps](https://help.zapier.com/hc/en-us/articles/8496212590093) * [Troubleshooting errors in Zaps](https://help.zapier.com/hc/en-us/articles/8496037690637) ## Connect Hyperline and Zapier Here's how to connect Hyperline to Zapier: 1. Log in to your [Zapier account](https://zapier.com/app/login) or [create a new account](https://zapier.com/sign-up) 2. Navigate to **Zaps** from the left sidebar 3. Click on **+ Create**, search for "Hyperline", and select it Zapier integration is in private access, so you might not see it the first time you search for it. To access the invite link, click the 'Connect' button on the Zapier card in the Settings > Integrations page of your Hyperline account. 4. You'll be asked to **Sign in**, and be prompted to add an API Key, which you can [learn how to generate in Hyperline here](/api-reference/docs/authentication). 5. Once you've added it in Zapier, click **Yes, Continue to Hyperline**. When this is completed you can start creating all the automation you want! Creating a Zap requires no coding knowledge and you'll be walked step-by-step through the setup. By default, this connection to Hyperline will be private and only able to be used by you. If you'd like to share it with your team, click **Share**. Add the members or teams you want to share it with, or select **Share with everyone**, then click **Done**. [Learn more about sharing app connections.](https://help.zapier.com/hc/en-us/articles/8496326497037-Share-app-connections-with-your-team) Follow [this example guide](./slack) to set up a Zap that sends your business metrics to a Slack channel regularly. # Zoho Books Source: https://docs.hyperline.co/integrations/zoho-books Push invoices, credit notes, customers, and payments from Hyperline to Zoho Books accounting with automatic chart of accounts and tax mapping. [Zoho Books](https://www.zoho.com/books) is a cloud-based accounting software developed by Zoho Corporation. ## Prerequisites You need to have a valid [Zoho Books account](https://www.zoho.com/books) and admin rights on Hyperline. ## Setup If you are not already logged into Zoho Books, enter your Zoho credentials to proceed. Your Hyperline account is ready to send invoices and credit notes. ## Reconciling data ### Customers To link an existing Zoho Books customer to a Hyperline customer, navigate to the customer details page, click the "Edit" button in the "Integrations" section, and enter the Zoho Books customer ID. For bulk operations during initial setup, contact our support team or use [this API endpoint](../api-reference/endpoints/customers/bulk-update-providerscustomers-mapping.mdx). ### Products You need to map your Zoho Books products (items) to your Hyperline product catalog. For each product in Hyperline, go to the Accounting section and enter the corresponding Zoho Books item name in the "Product code" field. When specified, Hyperline automatically attaches each invoice line item to the corresponding item in Zoho Books. Zoho Books requires all Hyperline invoice line items to be mapped to Zoho Books items. If a product is not mapped, the invoice will not be created in Zoho Books. ## Synchronization When you connect your Zoho Books account, Hyperline **automatically sends invoices** with their complete details (including line item details). By default, only invoices and customers created after the connection date will sync. If you need to push older data to Zoho Books, please contact our support team. ### Customers Hyperline supports 2 modes of synchronization for customers: * **no synchronization**: customers are not synchronized with Zoho Books. * **from Hyperline to Zoho Books**: customers created in Hyperline are automatically created in Zoho Books with their details. ### Payments Hyperline supports 3 modes of synchronization for payments: * **no synchronization**: payments are not synchronized with Zoho Books. * **from Hyperline to Zoho Books**: payments created in Hyperline are automatically created in Zoho Books and associated to the corresponding invoice. * **from Zoho Books to Hyperline**: payments created in Zoho Books are automatically created in Hyperline, and the status of the invoice is updated accordingly. Synchronization occurs within 5 minutes. ## Manage the integration To reauthorize, reconfigure, resync, or disconnect this integration, see [Manage connected integrations](./manage-integration).