# Currency amounts
Technical representation of monetary values in Hyperline
Learn about [currencies support](../../docs/get-started/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's 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
Learn how to authenticate to use Hyperline's API
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 app](./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
### How to generate an API key
Generating an **API key** is very simple and allow you to use Hyperline's API or integration such as Zapier.
As a Hyperline's admin:
1. Go to your workspace [Settings](https://app.hyperline.co/app/settings/api), section API
2. Click on `+ New API key`
3. Add a name for this key, and select the appropriate scopes (in most cases you'll need right/write accesses)
4. Copy the key and 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.
### Using 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
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.
### Keeping 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, click on the `…` icon on the line of the key name, then `Delete` to permanently delete it. A deleted key cannot be recovered.
# Getting started
Welcome to the Hyperline technical documentation 🤖
We offer you a complete set of resources, including APIs, a webhook system, low-code solutions, and developer tools, to facilitate the creation of a full technical integration seamlessly. However, our main principle is to minimize the technical workload on your end and abstract away the complexities of managing a billing system, allowing you to focus on delivering your core product value.
The Hyperline API is structured following REST principles and utilizes JSON-encoded data payloads. It adheres to industry standards and strives to deliver the most user-friendly interface possible, with straightforward operations, detailed error messages, and predictable behavior. This ensures that integrating with us is an effortless process.
**Sandbox environment**
In order to experiment, we provide you with a test mode (sandbox environment) where no real money or operations are involved. This allows you to test any flows you want without affecting your live data or interact with the banking networks.
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).
## 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) |
| 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) |
| Browser application | [https://sandbox.app.hyperline.co](https://sandbox.app.hyperline.co) |
# Pagination and filtering
All list requests can be paginated and filtered using the same query format. For convenience, we've made sure all *list-based* endpoints returned 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
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
{
"meta": {
"total": 2,
"taken": 2,
"skipped": 0
},
"data": [
{
"id": "cus_3fhwCWcL0Rx5MQ"
// other properties
},
{
"id": "cus_9huL9ahn7KQqHo"
// other properties
}
]
}
```
## 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 equals to 123, 456, or 789
## List of available operators
* equals (or just `=xxx`)
* not
* lt
* lte
* gt
* gte
* contains
* startsWith
* endWith
* 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
Our API is rate limited to ensure fair usage and to protect the system from abuse. The rate limit is set to a maximum of **250 requests per 10 seconds** window.
If you exceed this limit, the API will return a **429 Too Many Requests** HTTP status code. When you receive this status code, it means you have hit the rate limit and must wait before making additional requests.
The response will include an `X-RateLimit-Reset` header, which indicates the time when you can retry your request. You should wait until this time before attempting to make more requests.
If you have specific needs that require a higher rate limit, please contact our support team.
# React components
Learn how to embed Hyperline directly into your React application
Hyperline provides built-in React components to:
* For each customer, display their 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
npm install @hyperline/react-components
```
To allow a customer to see its Hyperline's 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
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 access the page.
```ts
import { Subscriptions, PaymentMethod } from "@hyperline/react-components";
export default function HyperlineSubscriptions() {
return (
",
mode: "production" // if you're using our sandbox, set "sandbox" here
}}
/>
);
}
export default function HyperlinePaymentMethod() {
return (
",
mode: "production" // if you're using our sandbox, set "sandbox" here
}}
onPaymentMethodCreated={() => do something} // optional, from 0.2.20
onPaymentMethodDeleted={() => do something} // optional, from 0.2.20
/>
);
}
```
## Components
### Subscriptions
List all active subscriptions
```tsx
"
}}
/>
```
### Subscription
Display a subscripton by ID
```tsx
"
}}
/>
```
### InvoicesList
List and download all invoices and refunds
```tsx
"
}}
/>
```
### PaymentMethod
Display the current payment method, delete it if allowed, or add a new payment method
```tsx
"
}}
/>
```
### CustomerBillingInfoForm
Display a form with all billing info
```tsx
"
}}
/>
```
## 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
",
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
```
# Third-party app
Enable your app to access Hyperline accounts using OAuth flows
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 an Hyperline account
* enabling your app to manage the customer base of an Hyperline account
* allowing your app to manage the product catalog of an Hyperline account
* allowing your app to manage recurring subscriptions or one-time payments of an Hyperline account
* fetching invoices from an Hyperline account
This list is non-exhaustive and variety of flows can be built levering this kind of app.
## Getting started
Hyperline uses **OAuth** standard to allow your app to access data from a connected account with the user 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 an 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
The third-party app creation capability is granted manually by us. Please contact our support if you are interested and want to enable it.
The first thing you need to do is creating a new app in Hyperline 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. an 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
{
"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
curl -H "Authorization: Bearer " https://api.hyperline.co/v1/customers
```
### Tokens 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/get-started/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/get-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
Keep track of changes and deprecation to the Hyperline API
## 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
* `Subscription.payment_method_strategy` is now optional on `/v2/subscriptions` POST endpoint
## 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 Planned for September 1, 2024
* 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
* Add `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 `Customer.country` in favor of `Customer.billing_address.country`
* 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
Receive webhook messages
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 message sent by Hyperline, go to your [webhooks settings](https://app.hyperline.co/app/settings/webhooks) in the app, click on "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, 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 find in the product Webhooks page, on the "Event Catalog" tab.
Here is a preview of the events you can be notified:
* `customer.created`, `customer.updated`, `customer.archived`, `customer.recovered`, `customer.deleted`
* `subscription.created`, `subscription.activated`, `subscription.trial_ended`, `subscription.paused`, `subscription.updated`, `subscription.cancellation_scheduled`, `subscription.cancelled`, `subscription.voided`, `subscription.errored`, `subscription.charged`, `subscription.commitment_renewed`
* `invoice.created`, `invoice.ready`, `invoice.grace_period.started`, `invoice.settled`, `invoice.errored`, `invoice.voided`, `invoice.reminder_sent`
* `credit_note.ready`, `credit_note.settled`
* `checkout.created`, `checkout.completed`
* `payment_method.created`, `payment_method.activated`, `payment_method.errored`, `payment_method.deleted`
* `wallet.credited`, `wallet.debited`
* `credit.created`, `credit.updated`, `credit.balance_refreshed`, `credit.low_balance`, `credit.balance_at_zero`, `credit.topup_transaction_created`, `credit.usage_transaction_created`
* `daily_analytics.ready`
* `dataloader.failed`
## Consuming webhooks
Webhook calls will always be `POST` HTTPS request contains a JSON body with this format:
```json
{
"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 to send example events to your endpoint.
After sending an example event, you can click into 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 click on "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).
## 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
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.
# Get analytics
get /v1/analytics
Retrieve your pre-computed account's analytics (ARR, revenues, churn, etc).
# Create billable event
post /v1/events
Create a new billable event.
# Create billable events
post /v1/events/batch
Create several billable events in batch (limited to max 5000 events per request).
# Ingest and calculate billable event prices
post /v1/events/prices
Ingest and calculate prices for a single billable event. This endpoint is in beta, please contact us if you want to know more.
# simulate billable event prices
post /v1/events/simulate-prices
Simulate prices for a single billable event. This endpoint is in beta, please contact us if you want to know more.
# Create company
post /v1/companies
Create a new company to which the authentication token will have access to.
# Get companies
get /v1/companies
Retrieve all companies that the authentication token has access to.
# Create coupon
post /v1/coupons
Create a new coupon.
# Delete coupon
delete /v1/coupons/{id}
Delete an existing coupon.
# Get coupon
get /v1/coupons/{id}
Retrieve the details of an existing coupon.
# Get coupons
get /v1/coupons
Retrieve all existing coupons.
# Update coupon
put /v1/coupons/{id}
Update the details of an existing coupon.
# Create custom property
post /v1/custom-properties
Create a new custom property.
# Delete custom property
delete /v1/custom-properties/{id}
Delete an existing custom property.
# Get custom properties
get /v1/custom-properties
Retrieve all custom properties previously created.
# Update custom property
put /v1/custom-properties/{id}
Update an existing custom property.
# Create credit product
post /v1/customers/{id}/credits
Create a credit entity for a given product with an optional balance for a customer.
# 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
get /v1/customers/{id}/credits/{productId}
Retrieve the details of an existing credit product for a customer.
# List credit products
get /v1/customers/{id}/credits
List all credits products attached to a customer.
# List credit transactions
get /v1/customers/{id}/credits/{productId}/transactions
Retrieve all credit transactions associated with a credit product for a specific customer.
# Purchase credits
post /v1/customers/{id}/credits/{productId}/purchase
Purchase a number of credits. This action will generate an invoice and charge the customer. Can take a few seconds to complete.
# Topup credits
post /v1/customers/{id}/credits/{productId}/topup
Topup a number of free credits. This action will not charge the customer.
# Delete payment method
delete /v1/customers/{id}/payment-methods/{paymentMethodId}
Delete an existing customer payment method.
# Get payment method
get /v1/customers/{id}/payment-methods/{paymentMethodId}
Retrieve the details of an existing customer payment method.
# List payment methods
get /v1/customers/{id}/payment-methods
List all payment methods attached to a customer.
# Archive customer
put /v1/customers/{id}/archive
Archive an existing customer.
# Bulk update providers/customers 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
post /v1/customers
Create a new customer.
# Delete customer
delete /v1/customers/{id}
Delete an existing customer. The customer must be archived prior to the deletion.
# Get customer
get /v1/customers/{id}
Retrieve the details of an existing customer.
# Get customer portal
get /v1/customers/{id}/portal
Retrieve the URL of the customer portal.
# Get customer tax rates
get /v1/customers/{id}/taxes/rates
Retrieve the eligible tax rates for a customer.
# Get customers
get /v1/customers
Retrieve all existing customers.
# Unarchive customer
put /v1/customers/{id}/unarchive
Unarchive an archived customer.
# Update customer
put /v1/customers/{id}
Update the details of an existing customer.
# Create component token
post /v1/integrations/components/token
Create a new token for embedded components.
# Create invoice
post /v1/invoices
Create a new invoice.
# Create transaction
post /v1/invoices/{id}/transactions
Manually create a transaction linked to an existing invoice to mark it as paid/partially paid
# Download invoice
get /v1/invoices/{id}/download
Download the PDF of an existing invoice.
# Get invoice
get /v1/invoices/{id}
Retrieve the details of an existing invoice.
# Get invoices
get /v1/invoices
Retrieve all existing invoices. By default, invoices with status `open` are not included.
# Update invoice
patch /v1/invoices/{id}
Update an invoice in draft or grace_period status.
# 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
post /v1/invoices/{id}/void
Void an invoice in a `to_pay` status. This action generates a corresponding credit note.
# Create invoicing entity
post /v1/invoicing-entities
Create a new invoicing entity to send invoices from.
# Delete invoicing entity
delete /v1/invoicing-entities/{id}
Soft deletes an invoicing entity. This action won't delete the associated invoices.
# Get invoicing entities
get /v1/invoicing-entities
Retrieve all invoicing entities for your current client.
# Get invoicing entity
get /v1/invoicing-entities/{id}
Retrieve a specific invoicing entity.
# Update invoicing entity
put /v1/invoicing-entities/{id}
Update an existing invoicing entity.
# Authorize
get /v1/oauth/authorize
Redirects the user to the Hyperline's login page, and grants authorization to your integration.
# Generate tokens
post /v1/oauth/tokens
Exchange an auth code received at the authorize endpoint for an actual access token, or refresh it.
# Get user info
get /v1/oauth/userinfo
Returns the user information associated with an access token.
# Revoke token
post /v1/oauth/revoke
Revoke a refresh token. Once revoked the token can not be used anymore.
# Get organisation
get /v1/organisations/{id}
Retrieve the details of an existing organisation.
# Patch organisation
patch /v1/organisations/{id}
Update the details of an existing organisation.
# 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
# Get plan
get /v1/plans/{id}
Retrieve the details of an existing plan.
# Get plans
get /v1/plans
Retrieve all existing plans.
# Update prices
put /v1/price-configurations/{id}/prices
Update prices of an existing price configuration.
# Create product
post /v1/products
Create a new product.
# Get product
get /v1/products/{id}
Retrieve the details of an existing product.
# Get products
get /v1/products
Retrieve all existing products.
# Update product
put /v1/products/{id}
Update the details of an existing product.
# Create quote
post /v1/quotes
Create a new quote.
# Download quote
get /v1/quotes/{id}/download
Download an existing quote.
# Download quote file
get /v1/quotes/{quoteId}/files/{id}/download
Download a file (attachment or manually signed file) attached to an existing quote.
# Get quote
get /v1/quotes/{id}
Retrieve the details of an existing quote.
# Get quotes
get /v1/quotes
Retrieve all existing quotes.
# Send quote
post /v1/quotes/{id}/send
Send an existing quote by email for signature.
# Sign quote
post /v1/quotes/{id}/sign
Manually mark the quote as signed externally. Built-in Hyperline signature flow won't be used.
# Void quote
post /v1/quotes/{id}/void
Void an existing quote.
# Activate subscription
post /v1/subscriptions/{id}/activate
Manually start a subscription for the first time.
# Cancel subscription
post /v1/subscriptions/{id}/cancel
Cancel an existing subscription.
# Create subscription
post /v2/subscriptions
Create a new subscription and assign it to a customer.
# Create subscription update
post /v1/subscriptions/{id}/update
Create an update to apply on an existing subscription.
# Create subscription updates
post /v1/subscriptions/{id}/update-many
Create multiple updates to apply at once to an existing subscription.
# Get subscription
get /v2/subscriptions/{id}
Retrieve the details of an existing subscription.
# Get subscriptions
get /v2/subscriptions
Retrieve all existing subscriptions.
# Pause subscription
post /v1/subscriptions/{id}/pause
Pause a subscription.
# Reactivate subscription
post /v1/subscriptions/{id}/reactivate
Reactivate a paused subscription.
# 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
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
post /v1/subscriptions/{id}/reinstate
Reinstate an existing subscription scheduled for cancellation.
# Transition subscription to next phase
post /v2/subscriptions/{id}/next-phase
Update a subscription and transition it to the next available phase.
# Update subscription
put /v2/subscriptions/{id}
Update parameters for a subscription.
# Get tax rate
get /v1/taxes/rates/{id}
Retrieve the details of an existing custom tax rate.
# Get tax rates
get /v1/taxes/rates
Retrieve all existing custom tax rates.
# Create app
post /v1/apps
Create a new third-party app.
# Delete app
delete /v1/apps/{id}
Delete an existing third-party app.
# Get apps
get /v1/apps
Retrieve all existing third-party apps.
# Update app
put /v1/apps/{id}
Update an existing third-party app.
# Create wallet
post /v1/wallets
Create a new wallet.
# Get wallet
get /v1/wallets/{id}
Retrieve the details of an existing wallet.
# Get wallet settings
get /v1/wallets/settings
Retrieve the wallet settings.
# Get wallet transactions
get /v1/wallets/{id}/transactions
Retrieve all transactions of an existing wallet.
# Get wallets
get /v1/wallets
Retrieve all existing wallets.
# Load wallet
post /v1/wallets/{id}/load
Load credits on an existing wallet.
# Update wallet
put /v1/wallets/{id}
Update the details of an existing wallet.
# Update wallet settings
put /v1/wallets/settings
Update the wallet settings.
# Create webhook endpoint
post /v1/webhooks/endpoints
Create a new webhook endpoint.
# Delete webhook endpoint
delete /v1/webhooks/endpoints/{id}
Delete an existing webhook endpoint.
# Get webhook endpoint
get /v1/webhooks/endpoints/{id}
Retrieve an existing webhook endpoint.
# Get webhook endpoints
get /v1/webhooks/endpoints
Retrieve all webhook endpoints.
# Get 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
put /v1/webhooks/endpoints/{id}
Update an existing webhook endpoint.
# Product updates May, 2023
## Coupons
Our most requested feature so far is out, you can now assign coupons to customers on Hyperline.
Two types of coupons are available (%-based or amount-based) with plenty of configuration options to choose from.
We also invested time it making it really easy to attach coupons to subscriptions and immediately see the impact.
You'll also be able to attach coupons to specific items depending on your need.
And of course, they're displayed in our invoice and our hosted portals.
## Stripe direct debit
You can now use Stripe as a direct debit provider for SEPA payments.
The integration is done seamlessly in our hosted flows, you just have to switch on the direct debit payment method in your settings once Stripe is connected.
## Improved events page
We have rebuilt our events debugging page from the ground up, making it really easy to explore synchronised events. We've also added for you a “delete” action to remove unwanted events from our database.
## New invoices page
A brand new page has appeared in your sidebar: Invoices. After getting a lot of feedback that invoices weren't really easy to find, we decided to group them together in a single page. We'll soon add export capabilities as well as metrics on your revenue, outstanding invoices, and more.
## One-time payments checkout
You can now create a one-time payment for a customer without a subscription and we'll generate a checkout session and an invoice for you.
To access it click on the customer menu (the 3 dots on the top right of the page) and select “Charge a one-time payment”.
Payment methods selection is only available for checkout-based payments and not for immediate charges.
## Custom domain for hosted pages
We didn't expect it, but 100% of our customers adopted the feature as soon as it was available. You can now configure your own domain for checkout and portal links.
Some good domain ideas we've seen:
* subscribe.acme.io
* buy.acme.io
* billing.acme.io
* getstarted.acme.io
To activate it, you'll need access to your domain DNS configuration and to do a small action on our settings page.
## Subscriptions API
You can now assign subscriptions through our public API. We've made it easy yet configurable so you won't get headaches during the integration phase.
You can find the documentation [here](../api-reference/endpoints/subscriptions/create-subscription) and don't hesitate to reach out to us if you need anything.
# Product updates June, 2023
## Wallets
Wallets allow you and your customers to pre-pay into a balance that's automatically used by Hyperline's system when paying invoices. This feature is particularly useful when you want to set up upfront payments and/or pay-as-you-go flows.
There are two types of top-up: paid ones (billed to your customer), free (offered to your customer).
We also invested time to make sure your customers are autonomous in using wallets by allowing them to see their wallet balance, top-up, and see the future projected wallet debits (next subscription to pay) on their dedicated portal page.
As you can also see, we refreshed the UI of the portal page to make it shinier.
The invoice has been updated accordingly to display all the payment methods used to pay it (wallets + credit card for example).
## Subscriptions seats count increase
We now allow you and your customers to change the number of seats included in an active subscription.
Your customers are autonomous in increasing the number of included seats on their hosted portal page, while you can increase **and** decrease this value on your customer view page.
## Brand new settings
As you may have already seen, we fully revamped the UI and hierarchy of the settings part of the app.
This includes clearer sections and structure, alignment with our UI brand, and a contextual right panel with help/FAQ explanations or an invoice preview to see in real-time the impact of the setting values on your future invoices look and feel.
We'll continue to rollout a new page structure to all pages in the product in the coming weeks.
## Data loaders improvements
We've invested a lot of hidden work and made many improvements in our events ingestion system through data loaders, which make it more reliable and performant (capable of ingesting millions of events).
This is mainly beneficial to our customers with dynamic/usage-based pricing models.
## Webhooks
Our most requested feature by our API customers is finally out! You can now receive webhook events from Hyperline and create deeper integrations with your product flows.
This capability comes with a set of developer tools: testing events send, audit logs and activity insights, visual replay, retry, signature, alongside a catalog describing all the available events (related to invoices, subscriptions and wallets for now).
*[More details in the documentation](../api-reference/docs/webhooks)*
# Product updates July, 2023
## New dashboard
Let’s face it, the previous dashboard didn’t look good… so we revamped it! You get all your key business metrics in a single place.
ARR is calculated every 5 minutes based on live customers consumptions and churn is computed in realtime when you’re opening Hyperline.
## New invoice details page
It’s easier to look at an invoice directly in the app than in the PDF file right? That’s why we’ve added a new invoice details page, accessible by clicking on any invoice table row in the product.
We’ve added a transactions table (with details when an error occurs) and providers fees (nothing is hidden anymore 😉).
## Purchase order
You can now assign a purchase order number to subscriptions and one-off payments. Purchase orders will show on the final PDF invoice and on the invoice page directly.
## New email for transfer payment
Make your payments by bank transfer even easier!
We now automatically send the invoice to be paid by e-mail to your customer when he chooses to pay by transfer.
## New public API endpoints
You can now [create products](../api-reference/endpoints/products/create-product) and [update prices](../api-reference/endpoints/price-configurations/update-prices) through the public API.
We’re making changes to our product catalog and this API is already compatible with the future data models.
## New webhooks
We also added new webhooks related to **customer creation and updates**. This allows you to build you own custom integration either by listening those events in your product or use no-code tools like Zapier or n8n to plug updates into external tools (like your CRM).
## General Availability of Mollie
At Hyperline, our vision is to stay agnostic from the payment provider to let you the full flexibility of the payment system you want to use. We now integrates [Mollie](https://www.mollie.com/) as a new payment provider, it works the same way as Stripe where we orchestrate your account automatically for you.
With Mollie you can also benefit from credit card and SEPA direct debit capabilities, at a lower price than Stripe.
# Product updates August, 2023
## New checkout page
Our hosted checkout page was revamped to a slicker and clearer structure.
Due dates, subscription, and one-time payment are now more clearly displayed with precise dates and summary.
## Multiple bank accounts
You can now add multiple bank accounts for different currencies.
In addition, we now support new bank account details formats:
* Account Number - (Ach) Routing Number
* Account Number - BIC/Swift
* Sort code - Account Number
* and IBAN - BIC (already supported)
If your customer decides to pay with bank transfer, we’ll pick the right bank account and format to put on the invoice depending on their currency.
## Zapier app
Hyperline now smoothly integrates with Zapier with a dedicated app!
You can sync in a few clicks, without any code, your customers base with your favorite CRM, react to Hyperline events to run workflows on your specific tools, push invoices data to your accounting software, push usage events from your tracking tools, …
The set of possibilities is endless!
*[More details in the documentation](../integrations/zapier)*
## Grace period for usage invoices
When using pricing with items based on usage data from your product, generated invoices now enter in a grace period before being sent for payment.
This period allows you to have a complete control over the final invoices and review them.
During this period, invoices don’t have a number, can be updated/refreshed to ensure accuracy, or manually validated before the end of the period.
The number of days of the grace period can be configure in the settings (default to 3 days).
## React components (beta)
Integrate Hyperline capabilities right into your product with just a few lines of code!
We now provide React components to embed customer’s active subscription and payment method (display + edit).
Generate a token with the API, insert the component with possible customisation, and that’s it. No more complexity!
*[More details in the documentation](../api-reference/docs/react-components)*
# Product updates October, 2023
## New customer page and subscription details
This is our first rollout toward our largest iteration to date in Hyperline: our new subscription model with way more flexibility.
In this improvement, we revamped the customer and subscription details page, using a better page structure and organization of the information. You can benefit from more clarity in the display of the subscription products (including all the *future* parameters, a preview of the evolution of metered pricing depending on the consumption, etc.) and the future invoice.
You can also now zoom in and display the details of a subscription on a dedicated page.
## Better currency management
We've made updates on how we handle currencies in Hyperline, especially when you invoice in multiple currencies, to manage more complexity out of the box for you.
The concept of “main currency” is now replaced by two distinct currency types:
* the **accounting currency**: automatically set by us and depending on your company country. This currency cannot be changed as it's used to maintain your accounting ledger with your country's legal requirements. This only affects the footer of your invoices, where we'll display the converted amount when needed;
* the **reporting currency**: configured by you, used in the dashboard page, and revenue analytics computations.
## **ACH Direct Debit 🇺🇸**
We now support ACH Direct Debit!
Like SEPA Direct Debit, this method allows US companies to set up direct debit payment methods for their customers with a US bank account.
## Forward customer emails
You can now set up in your settings custom emails where we'll forward emails sent to your customers. This allows your finance team, accountant, or anyone else to stay in the loop.
## **New login flow (including login with Google)**
Hyperline's users can now log in or sign up using a password or their Google account!
Additionally, we added a reset password flow, and sign up is directly accessible from this page.
## Third-party app
We now allow external products to integrate Hyperline by orchestrating existing accounts. This enables building third-party integration using OAuth2, and adding/using billing capabilities on top of another product with ease.
*[More details in the documentation](../api-reference/docs/third-party-app)*
# Product updates November, 2023
## Product Catalog
We introduced the concept of **reusable products** in Hyperline, which can be configured in a single catalog, allowing you to define different **prices based on a variety of parameters**, including currency, billing interval, commitment duration, country location, etc.
New pricing types are now available including **basic fee**, **volume-based** pricing, or **BPS-based** pricing, in flat-fee, seat, or usage-based products.
*[More details in the documentation](../docs/products/overview?utm_source=changelog)*
## New plans set up
Defined products can now be **reused in one or multiple plans**, plans act as a template for subscriptions where you can define your different offers.
## Even more flexible subscription model
Your customers can now **have multiple active subscriptions** simultaneously. Additionally, a single subscription can **include products with different billing intervals**, trial periods, and commitment durations.
This allows you to represent a wide range of needs, from simple cases to complex ones, such as “a customer committing for one year with a two-week opt-out trial period, featuring an annual upfront fixed charge and monthly usage consumption”.
The checkout session page, which is used for customers to explicitly subscribe and provide their billing details, is now optional. Additionally, in this new version, we offer greater flexibility in terms of payment options and subscription activation.
Obviously, all this logic can also be orchestrated using our API.
*[More details in the documentation](../docs/subscriptions/create?utm_source=changelog)*
## Invoices exports
Invoice exports are live, no more blockers for your accounting! You can now retrieve in one click your invoice data for the period of your choice including line items and PDF files, in JSON, CSV, or XLSX format.
## General Availability of GoCardless
To extend our payment collection capabilities and our promise to stay agnostic from a payment provider, Hyperline now fully **supports SEPA Direct Debit payment through GoCardless**.
Connect your account in one click, your existing mandates can also be imported!
## Customer payment method settings
You can now **customize payment methods at the customer level**, specifying both the methods you allow and the ones that should be used by default. These choices will be reflected on your customer’s checkout pages and portal.
Furthermore, we now offer the option to **disable the payment collection** logic in Hyperline entirely, allowing you to manage it on your own if you already have a system in place.
## Tailored onboarding flow
Our new customers can now benefit from a dedicated in-product experience to help them set up their accounts. Follow the steps and start billing without stress.
## New documentation portal
We recently invested a significant effort in revamping our [documentation](https://docs.hyperline.co), making it accessible to everyone, including non-tech folks. The technical documentation is now more complete than before, including a detailed API reference.
# Product updates December, 2023
## Enhancements for billing plans
We have enhanced price management for plans, enabling you to **customize the price of a specific product within the context of a plan**. This feature allows you to utilize the same product from your catalog in different contexts while representing all possible pricing variations based on factors such as currency, payment interval, commitment period, country, and now, the specific plan in use. Navigate to your plan and click on the 'Customize Prices' button for the desired product.
Also, you can now see your **revenue breakdown among different plans**. Simply navigate to your [Plans](https://app.hyperline.co/app/plans) page to view this information.
## Email tracking
You now have **visibility into the emails sent by Hyperline and their status as opened** by your customers. Hyperline automatically sends emails for new checkouts and invoices (both to be paid and paid) to your customers.
These emails will now appear in your history section on the invoice or subscription pages with a tag indicating whether they have been **Sent, Delivered, or Opened**. This enhancement will help you maintain complete visibility into the communication process.
## Account manager user role
We've introduced a new user role called 'Account Manager' designed for invited users such as sales teams or customer success teams. This role **only grants permissions to manage customers, subscriptions, and invoices**. Meanwhile, the 'Account Owner' and 'Admin' roles retain access to the entire product, including settings.
*[More details in the documentation](../docs/get-started/configure-account#team-members)*
## Cancel subscription
We revamped our subscription cancellation process to provide you with enhanced flexibility and clarity. You now have the option to choose when a subscription should be canceled—either **immediately or at a specific future date**. We present a **clear balance**, indicating the amount to be paid or reimbursed by your customer. You can then decide to bill and refund your customer with the **pre-computed amount**, opt for a **custom amount**, or choose to **ignore** the payment altogether.
*[More details in the documentation](../docs/subscriptions/manage#cancel-subscription)*
## Snowflake
We have added a new native **Snowflake integration** that enables you to connect your database directly to Hyperline using dataloader. Now, you can effortlessly ingest your usage data with zero dev time!
## Test mode
No need to logout and re-login between your main account and your sandbox (test) account. Both authentication flows are now linked and you can **switch from one mode to another in only one click** using the "Test mode" switch button on the bottom left corner of the product.
*[More details in the documentation](../docs/get-started/sandbox)*
# Product updates January, 2024
## Automated seat-based billing
We have introduced a significant enhancement to the "seats" product in Hyperline, designed for representing licensing where the cost of a software application or service is based on a quantity of items (users, accesses, licenses, etc).
Now, this product can be **seamlessly connected to your usage data using a [dataloader](../docs/usage/usage-data-with-connectors)**. This integration sets it apart from a proper "usage" product, as it incorporates all the business capabilities of a seat product (increase/decrease of a quantity with [volume](../docs/products/overview#volume), [packaged](../docs/products/overview#packaged) or [bulk](../docs/products/overview#bulk) pricing models) while adding specific options to this pricing model, such as prorata calculations, custom refresh frequency, invoicing and application schedules, and refunding decreases—**all achieved without the need for any development time**.
*[More details in the documentation](../docs/usage/connected-seats)*
## Salesforce
This marks our first step into CRM integration. Hyperline now enables you to seamlessly **connect your Salesforce account** for automated data synchronization.
It facilitates a **bidirectional sync** between Hyperline customers and Salesforce accounts. Additionally, we push detailed information about Hyperline subscriptions and invoices to Salesforce, also providing prebuilt URLs for management of them. This allows you to create custom page layouts, flows, or analyses directly within your CRM.
All of this without the need for dev time, manual complex configuration operations, or app installation.
Additionally, we have introduced a **dedicated integrations page in the settings**, providing a centralized place where you can access all the capabilities.
*[More details in the documentation](../integrations/salesforce)*
## Custom properties
To provide you with greater flexibility, we have introduced the ability to define structured custom properties that can be associated with customer, product, plan, and subscription entities. These properties support various types including simple text, number, boolean, date, and a select list with predefined values.
This addition allows for a range of use cases within Hyperline. For instance, you can now manage the SIREN of customers directly within the product as a structured property, store additional context for each main entity managed through the API, or representing a set of features enabled by a specific billing plan.
This capability can be managed either through the user interface or via the API.
## Pennylane
Hyperline now enables you to seamlessly **connect your Pennylane account**.
This allows us to automatically send invoices with their complete details, including line items and PDF files, along with payment details. Moreover, we retrieve payment details from Pennylane, facilitating automatic reconciliation and marking invoices as paid.
*[More details in the documentation](../integrations/pennylane)*
## Provider fees
We now display the total provider fees for each payment directly in Hyperline, for each invoice.
This enhancement provides clear visibility into this often overlooked cost, offering transparency on the deduction imposed by your current payment processor or service.
In this specific example, Stripe takes \$38.57 which represents more than 3% of the card transaction total amount.
## BigQuery
We have added a new native **[BigQuery](https://cloud.google.com/bigquery) integration** that enables you to connect your database directly to Hyperline using dataloader. Now, you can effortlessly ingest your usage data with zero dev time!
*[More details in the documentation](../docs/usage/bigquery)*
## Quick actions
We have added a convenient way for quick access to creating customers, subscriptions, one-time payment invoices, products, plans, or coupons. These options are always accessible in the navigation bar.
# Product updates February, 2024
## Create, edit and duplicate invoices
We've introduced several enhancements to our invoices. You can now [create new invoices from scratch](../docs/invoices/create) or [edit existing draft invoices](../docs/invoices/edit) with a real-time visual rendering. This provides you with complete flexibility and control over your invoice content before finalizing and sending it for payment.
Additionally, you now have the option to **duplicate existing invoices**, copying all major details for a seamless creation process.
## Explore invoice events
You now have the capability to **explore events related to an invoice featuring usage products**. This empowers you to gain a comprehensive understanding of the invoice's composition, providing clear visibility into the contribution of each event to the total invoice amount.
This explore feature is **available on the customer portal** for both past invoices and the upcoming invoice (i.e. the one open for the current billing period).
Furthermore, we provide the option to **download a CSV file** containing all the data for further processing in your preferred external tool.
## HubSpot
Hyperline is now **integrated with HubSpot**! Similar to the Salesforce integration, this feature enables a **bi-directional synchronization** between Hyperline customers and HubSpot companies. Furthermore, we introduce a **HubSpot card** that allows you to assign, manage, and access Hyperline subscriptions directly within your CRM, without the need to navigate away.
A comparable widget capability is now accessible for [Salesforce](../integrations/salesforce/component) as well.
*[More details in the documentation](../integrations/hubspot)*
## Subscriptions page
We have introduced a brand new subscriptions page, which displays a **list of all the subscriptions** of your account. This provides you with clear visibility of your subscriptions in one central place, featuring filtering options and the ability to **export the complete data as a CSV file**.
## Reports and exports
To assist you in conducting more **in-depth financial analyses**, we have implemented a comprehensive report feature. This functionality enables you to **download pre-built files**, such as revenue per product/country/plan, aged balance, outstanding invoices, and more.
While we have plans to introduce additional reports in the future, we welcome your suggestions for new ones. Feel free to share your ideas.
Additionally, you now have the capability to **export your customer list into a CSV file** for external processing. Simply utilize the 'Export customers' button available on the [Customers page](https://app.hyperline.co/app/customers).
## Resend invoice emails
We now provide a feature that enables you to **resend past invoice emails** to your customers, whether it be for invoices that are yet to be paid (serving as a reminder) or for those that have already been paid.
## Add/remove products from subscriptions
You now have the flexibility to add or remove products at any time from ongoing subscriptions. We offer various options for charging the customer on a pro-rata basis, with the full price, and more.
Simply go to your subscription details page, and click on the 'Add product' button in the Products section; or click on an existing subscription product and 'Remove product'.
# Product updates March, 2024
## Invoice reminders
You can now automate your payment reminders and dunning process directly within Hyperline! We offer a complete invoice reminder module that allows you to schedule email reminders before, on, or after the due date with fully customizable sequences, messaging, and cohorts.
This enables you to tailor your wording and email frequency based on your criteria, automating your payment reminders and dunning process, thereby eliminating tedious manual actions and ultimately reducing your outstanding and unpaid invoices.
*[More details in the documentation](../docs/invoices/reminders)*
## Flexible subscription updates
Alongside offering the most flexible subscription model on the market, we now enable you to have full control over your running subscriptions with dedicated update flows. Easily change your subscription's invoicing parameters, dates, purchase orders, or product configurations for live subscriptions without recreating them from scratch.
## Automated invoice reconciliation for SEPA bank transfer
Reconciling your banking transactions with their corresponding invoices for wire transfer payments can quickly become tedious. We are introducing our first step toward eliminating this manual task with an automated invoice reconciliation feature for SEPA bank transfers, powered by Mollie.
We assign a dedicated IBAN (always the same for the customer) and a reference number to the invoice. Then, when a payment is received in the related account, we automatically mark the invoice as paid accordingly.
## E-invoicing compliance
Hyperline is now fully compliant with the European standard for electronic invoicing, especially for countries (like Italy) where the standard is already in place and mandatory.
For France, the standard has been postponed to 2026, but we anticipate this compliance aspect to incorporate it into our product foundations.
*[More details in the documentation](../docs/invoices/einvoicing)*
## View previous invoices version
Related to the invoice edition feature, you can now browse your history to view previous versions of a specific invoice prior to its updates.
## Wallet use for bank transfer invoices
The wallet feature in Hyperline is a useful tool that allows your customers to prepay money to cover future invoices, and enables you to offer specific amounts to be deducted from the next customer invoices.
This capability is now also available for customers paying by bank transfer: the invoice total amount will be deducted from the available customer wallet amount, requiring your customer to only pay the remaining amount.
## More fields supported on CRM integrations
We've added a variety of new fields to be synchronized between Hyperline and your CRM, including customer language, timezone, invoice emails, tax number, custom tax rate, custom payment delay, next payment date, and amount, among others. If you are interested in using them, simply go to your CRM integration page in Hyperline, then use the Actions > Reconfigure button.
*More details in the [Salesforce documentation](../integrations/salesforce) or [HubSpot documentation](../integrations/hubspot)*
# Product updates April, 2024
## Send quotes to your customers
In our mission to simplify all topics related to billing, we are introducing a **new quoting feature native in Hyperline**.
Create a quote containing subscription configuration and details, and send it for signature to your customer. The subscription and invoicing will start automatically with all the agreed price and contract configurations, eliminating the need for additional manual actions in between.
Quotes are also available through Salesforce, HubSpot, and Zapier integrations.
This quote feature is in private beta. We are eager to hear feedback from the first usage, and many new capabilities are planned to come in the coming weeks. Let us know if you are interesting testing!
## Automate invoice reconciliation with Bank Connect
Last month, we announced a new method to streamline the invoice reconciliation process by incorporating generated and unique bank details attached to the invoices, leveraging capabilities from Mollie.
Taking this initiative forward, we are now enabling you to **connect any external bank account** and automatically reconcile transactions received on it with Hyperline invoices!
*[More details in the documentation](../docs/payments/reconciliations#with-an-external-bank-account)*
## Discover our revamped customer portal
Our customer portal (shareable public page) now has a fresh new look!
We've revamped the interface to make it shinier, simpler to read, and easier to understand. It allows the display of multiple subscriptions along with additional details.
## Improved invoice translation
We've improved translation support for products and invoices. You can now **add alternative translations for your product names** (defined in your product catalog). The correct translation will be used on your invoice depending on its language.
Additionally, the Hyperline invoice layout is now available in Dutch.
You can also include custom text notes/messages on the invoice for your customers. This feature is accessible when editing an invoice before sending it for payment.
## Explore live consumption for seat-based product
As for usage-based product, you can now **browse live consumption for connected seat products**. This provides you (and your customers) with a clear understanding of the events taken into account for billing.
## See past subscriptions
We now list all past and canceled subscriptions on each customer, providing you with detailed visibility into their history. Track subscription changes, upsell, downsell, and customer evolution in a single place.
Additionally, you can now add or remove coupons from a live and active subscription.
# Product updates May, 2024
## Public invoice page
**Sharing a link to provide details** to your customer or **receive payment about a specific invoice** is now possible with the public invoice page.
Like checkout, portal, or quote pages, the public invoice page allows you to share a publicly accessible link with your customer, including invoice details, usage consumption history, and a payment form.
*[More details in the documentation](../docs/invoices/invoice-page)*
## Upload extra documents and e-sign quote
As a first iteration following the beta launch last month, we focused on **allowing the attachment of additional PDF documents to the quote**, so you can include detailed contracts, terms of use, conditions, or any other document that makes sense for your business and you want your customer to review as part of their quote signature flow.
Additionally, we added a way to **electronically sign quotes**, making them legally compliant. This flow is backed by Yousign, a leading European signature provider.
## Connect multiple payment providers
You can now **connect multiple payment providers** to your Hyperline account. This allows you to distribute payment method usage among multiple providers at different costs. For example, you can let your customers pay by card using Stripe and by SEPA Direct Debit using Mollie.
## Organisation-based billing
One of the main challenges when implementing invoicing for multiple entities within a single customer group is now a no-brainer with Hyperline! You can **represent parent/child dependencies between customers** and choose how you want invoices to be issued (invoice the parent company, group all child invoices into a single one under the parent, etc.).
*[More details in the documentation](../docs/customers/organisation-based)*
## MySQL dataloader
MySQL is now available as a Hyperline dataloader. Similar to PostgreSQL, MongoDB, BigQuery, and Snowflake, you can pull your usage data for billing with just a few configuration clicks and without complex technical integration.
*[More details in the documentation](../docs/usage/usage-data-with-connectors)*
## Fincome integration
[Fincome](https://www.fincome.co) now natively supports Hyperline. Benefit from all Fincome capabilities to analyze your subscription revenue from your Hyperline data.
## Payment Provider Explorer
A new Hyperline side project we released this month, a powerful comparator of payment providers and associated costs with the [Payment Provider Explorer](https://paymentproviderexplorer.hyperline.co). No more hidden fees!
# Product updates June, 2024
## Invoicing entities
Hyperline now allows you to represent **multiple invoicing entities within the same account**. This feature enables you to issue invoices to your customers from different sellers, such as various invoicing subsidiaries or entities you issue on behalf of.
This capability lets you maintain your entire account configuration (products, plans, settings, ...) while easily issuing invoices from different senders you represent.
The invoicing entity can be customized per customer, allowing full flexibility.
No limit on the number of entities apply, and the feature is accessible both in the interface and through the API.
## Update subscription prices
As the last step of subscription updates, we now allow you to **edit the prices of products that are part of an active subscription**. These changes are tracked in a history trail within the subscription page.
This way, you can apply price changes and upgrade or downgrade a subscription without creating a new one, allowing you to keep track of all changes to a customer contract.
*[More details in the documentation](../docs/subscriptions/update#update-product-prices)*
## Edit members role
Hyperline allows you to invite team members with either an Admin or Account Manager role. You can now **edit the role of an existing user** autonomously in your account settings.
*[More details in the documentation](../docs/get-started/users)*
## Add credit products in plans and subscriptions
Credit products can now be added to predefined billing plans and subscriptions like any other product.
*[More details in the documentation](../docs/credits/overview)*
## Edit extra details on emitted invoices
Sometimes it appears that extra information was missed, but the invoice has already been issued. For legal reasons, the core of the invoice cannot be edited. However, you can now **edit the Purchase Order number and the custom note** attached to the invoice.
## Redirect button on customer portal
We added a feature that allows you to **add a button with a custom label and link on the customer portal**. This way, you can easily redirect customers to your product, add an additional link to an external resource, and more.
## New React components
Following the release of our new portal a few months ago, we upgraded our React components library. Each component now has a fresh new look that matches the latest portal design.
*[More details in the documentation](../api-reference/docs/react-components)*
# Product updates July, 2024
## Quote templates
With the release of quote functionality completing the CPQ process on Hyperline, you can now create **quote templates to streamline the quote creation process**. Say goodbye to copy-pasting contract terms and repeatedly re-uploading the same PDF attachments, you can now simply select an existing template from the gallery and create a quote in just a few clicks.
## Dynamic matrix pricing
Dynamic products with usage are now more powerful than ever. You can now **configure specific pricing based on your own fields** within usage events. This allows you to create complex pricing matrices and price points based on specific usage parameters and values.
For example, if you are selling cloud computing services, you can apply different prices depending on the compute instance type and/or region. Similarly, if you are selling banking transaction processing, you can apply specific fees based on the scheme and/or card configuration.
## Subscription assignation
The second step of the subscription assignment flow has been updated with a fresh look, and simplified and clearer options. You can now directly manage the allowed customer payment methods and choose whether to activate the checkout flow.
Additionally, you can now fully disable checkout capabilities in your account settings if you prefer not to use them.
## Multiple customer payment methods
Hyperline now allows your **customers to store multiple payment methods** on their portal page. Whether they are using different cards or a combination of a card and a direct debit mandate, they can save multiple options. This functionality is also available if you have multiple Payment Service Providers connected.
For example, your customers can add their card using Stripe and set up a SEPA direct debit mandate using GoCardless. This process will be seamless for your customers, who will see only two payment method forms, without being aware of the underlying provider complexity.
## More filters
You can now filter customers, subscriptions, and invoices tables by a specific invoicing entity. Additionally, date filters are now available, allowing you to filter subscriptions based on start or cancellation dates, for example.
# Product updates August, 2024
## Custom tax rate
Hyperline now supports the creation of **custom tax rates by invoicing entity**. These rates can be applied to products in the catalog to customize the tax for each product. The complexity of multiple tax rates is managed across all flows, including checkout, portal, quotes, and invoices, making invoicing processes even easier.
Additionally, you can now configure external 'Product code' for each product in your catalog, which facilitates reconciliation between Hyperline products and those in external systems, such as accounting software.
## Change invoice payment method
The payment method on draft invoices and invoices awaiting payment can now be changed. For example, you can easily switch from card to bank transfer or update the bank account on the invoice.
## Invoices in 🇪🇸 🇵🇹 🇵🇱
Emitted documents (invoices, quotes, custom documents) from Hyperline are **now available in three new languages**: Spanish, Portuguese, and Polish. These additions complement the existing options of French, English, German, Italian, and Dutch.
## Subscription pricing configuration
When assigning a subscription, we have simplified the process of adding and configuring products. You can now select any pricing setup from the product catalog and edit the configuration in a dedicated side panel. This provides greater flexibility when setting products to a subscription and allows for the selection of bundles for credit products.
## Quotes export
Quotes can now be exported to CSV files for external use.
# Product updates September, 2024
## Translations of hosted pages
Hosted pages (checkout, portal, quote, and invoice pages) are now available in all supported languages, including **French, English, German, Italian, Spanish, Portuguese, Dutch, and Polish**. This completes the translation of emitted documents (invoices, quotes, and custom documents) already supported, ensuring that your customers can experience the entire flow in their preferred language.
## New accounting integrations
Hyperline now natively integrates with **[Xero](../integrations/xero)** and **[Exact Online](../integrations/exact-online)**, expanding our existing accounting software support, which already includes Pennylane. Invoices and credit notes are automatically pushed to your accounting system with all details, and payment information is synced, making reconciliation a seamless process.
## User permissions
You can now **create custom roles with specific permissions**, offering fine-grained access control for members based on your needs. Permissions are no longer limited to pre-defined roles, giving you full flexibility.
*[More details in the documentation](../docs/get-started/users#manage-roles)*
## Contracts
We've started to introduce a new module that allows you to **manage contract templates and reusable clauses**. This feature simplifies managing a catalog of contracts, tailored to specific invoicing entities, countries, or languages. You can easily add this content to quotes.
## Map tax rates to custom codes
In order to ease integration with accounting and the addition of [custom tax rates](../docs/invoices/tax-management#custom-tax-rates) last month, Hyperline now support **mapping of default rates to custom codes**. This mapping is automatically pushed to Xero and Exact Online.
*[More details in the documentation](../docs/invoices/tax-management#default-tax-rates)*
## CRM more objects
Hyperline now synchronizes way more data on your [Salesforce](../integrations/salesforce) or [HubSpot](../integrations/hubspot) accounts. Push quotes including line items and coupon details, subscriptions including products and coupon details, and invoices including line items, in only a few clicks!
## More flexibility on invoices
You can now select and **assign products from your catalog when creating one-off invoices**, ensuring the correct link between invoice line items and related products, making revenue recognition simpler.
Additionally, you can now **revert an invoice paid by transfer back to unpaid** with a dedicated button that removes the associated bank transaction.
# Dashboard
The dashboard is the first interface you see when logging in to your Hyperline account. It features key metrics at the top, the list of outstanding invoices as well as the coming subscription renewing for the next 7 days at the bottom. It will give you a quick, effective overview on your business.
## Key metrics
### ARR and MRR
Annual Recurring Revenue (ARR) represents the total annualized revenue that a SaaS company expects to receive from its subscription customers over the course of a year, while MRR represents the total monthly revenue generated from subscriptions.
In Hyperline, coupons with a "forever" application schedule are included in the ARR computation. Conversely, coupons with a limited application period are not taken into account in the final amount calculation.
For example, if you have two subscriptions, one with a forever -20% coupon and the other with a -50% coupon for 4 months, the ARR computation will only consider the coupon of the first subscription and ignore the second.
Additionally, the 'Active' and 'Pending' amounts indicate the amount related to the 'Active' and 'Pending' (not running) subscriptions.
Keep in mind: tax (VAT) amounts are not included in the calculation of ARR/MRR.
### Revenue last 30 days
This displays the revenue for the last 30 days for both recurring and one-time invoices. Right below is the total revenue since the 1st January of the ongoing year.
### Active subscriptions
This displays the number of active subscriptions for your account. Below is the ARPA (Average Revenue Per Account) that provides insights into the average value derived from each customer.
### Churn
The Churn is the rate at which customers or subscribers discontinue or cancel their subscriptions or services during the current month vs the last month.
Churn is also known as "customer attrition" or "customer turnover".
Retaining existing customers is often more cost-effective than acquiring new ones. If you observe a high Churn on your account, consider implementing strategies to reduce it, like improving customer support, enhancing the product or service, offering loyalty incentives (through [coupons](../coupons/overview) or [free top-up](../wallets/top-up)), and analyzing customer feedback to address pain points.
## Outstanding invoices
We display on the dashboard a list of invoices, filtered to keep the outstanding invoices only. This gives you at a glance the list of invoices that are still awaiting partial or full payment.
You can mark the invoices as 'Paid' or 'Partially paid' from the dashboard directly.
## Subscriptions renewing in the next 7 days
This section shows the list of customer subscriptions renewing in the next 7 days so you can view near future activity.
# Reports
Hyperline offers a complete set of pre-built report files, where you can get a clear view of company performance. This will be able to explore a comprehensive range of analysis designed to empower finance teams in making informed decisions or do deeper analysis into their preferred external tools.
The reports are accessible through the dedicated Reports page within the Hyperline platform.
## Available reports
Hyperline offers a curated selection of reports (as depicted in the screenshot above), important for assessing various aspects of your company's financial health, all of which are downloadable as CSV files for convenient access to the data you need at any time.
## Requesting a custom report
If you find that a specific report you require is not currently available, simply click on the 'Ask for a custom report' button. Our dedicated support team is committed to providing you with the tailored data essential for your financial analysis.
# Create & apply coupons
## Coupons definition
Coupons in Hyperline are a way to offer discounts to your customers.
Coupons can be offered as a fixed amount or a percentage of a given price.
Coupons can only be applied when [assigning a subscription](../subscriptions/create).
They are a way to offer a discount on a subscription amount and will be applied to the subscription invoice right away.
To offer discounts to your customers out of the context of a subscription (one-time payments), you can top-up their wallet for free. Learn how to [top-up a wallet](../wallets/top-up).
## How to create coupons
To create a new coupon, go to the **Coupons** section and click on **+ New coupon.**
Then fill-up the following information:
* **Name**: the coupon's name (try to use simple, clear names)
* **Description**: the description is for internal use only and is not required to create a coupon
* Choose if you want to create a **fixed amount or a percentage** discount
* Choose **the amount or the value** of the coupon
* **Redemption deadline**: set up a deadline if you want your coupon to become invalid after a specific date
* **Redemption limit**: set up a limit if you want your coupon to be used only a specific amount of times
Click on **Create new coupon** once you are done.
Your new coupon will appear instantly.
## Apply coupons
Once you created coupons, you can apply them to customers.
To do so, go to **Customer,** then to **Subscription**, and click on **Assign new subscription.** In the process, you can add coupons.
Visit our page [assign a subscription](../subscriptions/create) to learn more about this process.
***
# Using the API
You can also decide to manage coupons using the Hyperline API. Visit our API reference documentation for more details.
* [List coupons endpoint](../../api-reference/endpoints/coupons/get-coupons)
* [Create coupon endpoint](../../api-reference/endpoints/coupons/create-coupon)
# Set-up credits on your account
Learn how to set-up customer credit ledgers
Hyperline offers a way to represent credits for each of your customers and provides a dedicated credit product type for this. It can represent any granted quota relevant to your business.
This allows you to easily implement a pre-built ledger, enabling your customers to pay upfront, consume, and purchase new credits as needed.
**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.
You can set a limit to warn of a low balance and set-up which event will consume credits on the customer's balance.
For credits, the pricing type is bundle pricing, a given price for a number of credits. You can also choose to display different purchase options on the customer's portal.
## 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, you will be able to see the most recent consumption by your customer. Additionally, you can manually top up or retain usage via the interface if desired.
## 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.
# Create customers
We call customers the individuals or companies buying products and/or subscribed to you. We recommend that you create a customer in Hyperline as soon as someone registers for your product.
If you have a payment provider connected, we'll make sure to automatically create the customers there for you when necessary.
Click on **New Customer**
Click on **Save customer**
If you don't have all the information now, you can still create the customer and come back later to edit its details. Only a name is required at this step, but we recommend filling in at least the currency and country of the customer.
It will appear right away in your customer list (under the `All` filter).
You can click on your customer's name from the previous screen to access their information.
From this page, you get an overview of your customer's information on the left of the screen, and you can navigate through their [subscriptions](../subscriptions/manage), [wallet](../wallets/overview), [invoices](../invoices/overview) and events on the right.
# Customer exports
Learn how to export your customers
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.
# Organisation-based billing
Learn how to bill customers together
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.
## Activate organisation-based billing
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 customers invoices as pending and concatenate them regularly with other children from the parent. Concatenated invoices will display one line item per children invoice with the original line items listed in 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 on 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.
## 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.
**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`.
**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 on 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.
# Public customer portal
Learn about the hosted customer portal page
## 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:
#### 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 on 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 on the "Edit" option. 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.
#### Download invoices
All invoices are listed and can be open to their dedicated [invoice page](../invoices/invoice-page).
Customer 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 on 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.
# Configure your account
## General configuration
### Company information
You will be asked to fill up the following information about your company:
1. Your company's trade name (the name used to conduct your business)
2. The company's email address (for invoicing inquiries)
### Brand identity
You can also brand your invoices with one color and your company's logo. We provide you with a real time preview on the right of the screen so you can see how your changes are affecting your invoices design.
### Billing information
This section impacts the footer of the invoices. You can add here:
1. Your company's VAT number (make sure the number is valid. A warning icon will appear if it is not)
2. The company's legal name (that can be different from the trade's name)
3. The company's address
The company's country cannot be changed as it determines your accounting currency.
When you're done you can click on **Save changes**.
## Payment
This is done in the **Payment** section. To get started with Hyperline, you will need to provide means of payments (connecting with your PSPs and/or adding bank accounts) and choose which payment methods you want to accept from your customers.
### Connect your Payment Service Provider
Hyperline currently supports three major Payment Service Provider: **Stripe**, **Mollie** and **GoCardless**. If you already have an account with one of those, you can connect it in one click without any technical requirement (no API key, no webhook to connect, etc.).
1. Click on the **Connect** button for the PSP of your choice. This will redirect you to the PSP login page.
2. Enter your account credentials and click on **Continue.**
3. Once the process is completed, you will see the PSP status change to `Active` in Hyperline.
When connected, we will automatically orchestrate your account for you (create, update, refund).
### Add your bank accounts
If you intend to accept bank transfers from your customers, you can add one (or several) bank account(s) by clicking on **Add a bank account**. This is the account that will be indicated on your invoices **depending on the currency of the invoice** when your customers decide to pay by bank transfer.
1. Fill-up the **country**, **currency** and **name of your bank**
2. Select the bank account format and enter the details
3. Click on **Add bank account**.
You will see your account appear in the list. You can delete it anytime by clicking the three-dot menu, and **Delete**. Deleting your bank account information will disable (if you had only one) the bank transfer payment method until you add a new bank account.
You can add a bank account with various formats to accommodate different countries and currencies. These formats include:
1. IBAN / BIC/Swift (for countries in the SEPA area, primarily European)
2. Account Number / (Ach) Routing Number (US - USD)
3. Sort code / Account Number (UK - GBP)
4. Account Number / BIC/Swift (all other cases)
Invoices will display the correct format when customers opt to make payments via bank transfer.
Don't forget to enable payments by bank transfer (last option on the page) to
allow your customers to send payments that way.
### Configure payment methods
Now that everything is configured, you can choose in this section which payment methods you want to accept from your customers. You can choose between accepting:
* Debit or credit cards payments
* Direct debit (SEPA for European bank accounts, ACH for US bank accounts, Bacs for UK bank accounts) payments
* Bank transfer (offline transactions)
When enabling bank transfer payments, your customers will receive your bank
account information and will wire transfer the amount due for their
subscription or one-time payment. As bank transfers are offline, you will have
to manually reconcile them by marking them as paid on your Hyperline
interface. See our page [Transaction and reconciliation](../payments/reconciliations) on how to proceed.
# Supported currencies
Learn about supported currencies and different types
Hyperline supports a variety of currencies (detailed below) for product, subscription, and plan prices, as well as invoices. This provides you with the flexibility to bill your customers in their preferred currency.
| Currency Name | ISO Code |
| ----------------------------- | -------- |
| Afghan Afghani | AFN |
| Albanian Lek | ALL |
| Angolan Kwanza | AOA |
| East Caribbean Dollar | XCD |
| Armenian Dram | AMD |
| Aruban Florin | AWG |
| Australian Dollar | AUD |
| Azerbaijani Manat | AZN |
| Bahraini Dinar | BHD |
| Bangladeshi Taka | BDT |
| Barbadian Dollar | BBD |
| Bosnian Convertible Mark | BAM |
| Brazilian Real | BRL |
| Brunei Dollar | BND |
| Bulgarian Lev | BGN |
| Burmese Kyat | MMK |
| Burundi Franc | BIF |
| Canadian Dollar | CAD |
| Cape Verde Escudo | CVE |
| Cayman Islands Dollar | KYD |
| Central African CFA Franc | XAF |
| CFP Franc | XPF |
| Chilean Peso | CLP |
| Chinese Yuan Renminbi | CNY |
| Colombian Peso | COP |
| Comorian Franc | KMF |
| Costa Rican Colón | CRC |
| Croatian Kuna | HRK |
| Cuban Peso | CUP |
| Czech Koruna | CZK |
| Danish Krone | DKK |
| Djiboutian Franc | DJF |
| Dominican Peso | DOP |
| Egyptian Pound | EGP |
| Euro | EUR |
| Fijian Dollar | FJD |
| Gambian Dalasi | GMD |
| Georgian Lari | GEL |
| Ghanaian Cedi | GHS |
| Gibraltar Pound | GIP |
| Guatemalan Quetzal | GTQ |
| Guinean Franc | GNF |
| Guyanese Dollar | GYD |
| Haitian Gourde | HTG |
| Honduran Lempira | HNL |
| Hong Kong Dollar | HKD |
| Hungarian Forint | HUF |
| Icelandic Krona | ISK |
| Indian Rupee | INR |
| Indonesian Rupiah | IDR |
| Iranian Rial | IRR |
| Iraqi Dinar | IQD |
| Israeli New Shekel | ILS |
| Jamaican Dollar | JMD |
| Japanese Yen | JPY |
| Jordanian Dinar | JOD |
| Kazakhstani Tenge | KZT |
| Kenyan Shilling | KES |
| Kyrgyzstani Som | KGS |
| Lao Kip | LAK |
| Lebanese Pound | LBP |
| Lesotho Loti | LSL |
| Liberian Dollar | LRD |
| Libyan Dinar | LYD |
| Macanese Pataca | MOP |
| Macedonian Denar | MKD |
| Malagasy Ariary | MGA |
| Malawian Kwacha | MWK |
| Malaysian Ringgit | MYR |
| Mauritanian Ouguiya | MRO |
| Mauritian Rupee | MUR |
| Mexican Peso | MXN |
| Moldovan Leu | MDL |
| Mongolian Tugrik | MNT |
| Moroccan Dirham | MAD |
| Mozambican Metical | MZN |
| Namibian Dollar | NAD |
| Nepalese Rupee | NPR |
| Netherlands Antillean Guilder | ANG |
| New Taiwan Dollar | TWD |
| New Zealand Dollar | NZD |
| Nicaraguan Córdoba | NIO |
| Nigerian Naira | NGN |
| North Korean Won | KPW |
| Norwegian Krone | NOK |
| Omani Rial | OMR |
| Pakistani Rupee | PKR |
| Panamanian Balboa | PAB |
| Papua New Guinean Kina | PGK |
| Paraguayan Guarani | PYG |
| Peruvian Sol | PEN |
| Philippine Peso | PHP |
| Polish Zloty | PLN |
| Pound Sterling | GBP |
| Qatari Riyal | QAR |
| Romanian Leu | RON |
| Russian Ruble | RUB |
| Rwandan Franc | RWF |
| Saint Helena Pound | SHP |
| Samoan Tala | WST |
| Saudi Riyal | SAR |
| Serbian Dinar | RSD |
| Seychelles Rupee | SCR |
| Sierra Leonean Leone | SLL |
| Singapore Dollar | SGD |
| Solomon Islands Dollar | SBD |
| Somali Shilling | SOS |
| South African Rand | ZAR |
| South Korean Won | KRW |
| South Sudanese Pound | SSP |
| Sudanese Pound | SDG |
| Surinamese Dollar | SRD |
| Swazi Lilangeni | SZL |
| Swedish Krona | SEK |
| Swiss Franc | CHF |
| Syrian Pound | SYP |
| Tanzanian Shilling | TZS |
| Thai Baht | THB |
| Tongan Paʻanga | TOP |
| Trinidad and Tobago Dollar | TTD |
| Tunisian Dinar | TND |
| Turkish Lira | TRY |
| Turkmenistani Manat | TMT |
| Ugandan Shilling | UGX |
| Ukrainian Hryvnia | UAH |
| United Arab Emirates Dirham | AED |
| United States Dollar | USD |
| Uruguayan Peso | UYU |
| Uzbekistani Som | UZS |
| Vanuatu Vatu | VUV |
| Venezuelan Bolívar | VEF |
| Vietnamese Dong | VND |
| Yemeni Rial | YER |
| Zambian Kwacha | ZMW |
| Zimbabwean Dollar | ZWL |
When it comes to **payment**, the supported currencies mainly depend on your **connected payment provider**. We recommend you to check their capabilities case by case depending on your need.
Two main currencies are used in the Hyperline settings:
* Accounting currency: defined on each invoicing entity
* Reporting currency: unique and defined on your account (shared between all invoicing entities)
Your customer's currency is different from account's accounting or reporting currencies. It can be edited from the **Customer section** → selecting the customer → clicking on **Edit** the customer's information.
## Accounting currency
In most countries, you're legally required to maintain your accounting ledger in your country's main currency. This can get tricky when you're invoicing customers in multiple currencies. At Hyperline, we're setting your accounting currency to your invoicing entity country currency to make sure you won't have any legal issue down the road.
This only affects your invoices' footer, where we'll display the converted amount when needed.
## Reporting currency
Your reporting currency defines how we convert amounts on aggregated views, like your [dashboard](../analytics/dashboard), or your aggregated revenue.
It won't impact invoices or exports, only the display on the app. This value can be changed as often as you want.
# Email settings
Learn about your account email settings
Emails settings of your account can be configured in the Settings > Emails page.
### Additional email recipients
Hyperline provides the ability to add 5 recipients to the emails it sends to your customers.
This feature allows you to keep key stakeholders, such as your finance team or accountant, informed. The email notifications currently include information about pending invoices and paid invoices. This ensures that your team is always up-to-date with your billing status.
### Support email
Hyperline uses a designated email address for support-related communication.
This email is used when issues are detected with your integration, data loaders, or API. By providing a specific email for these notifications, you can ensure that important updates regarding your system's status are directed to the appropriate channel.
### Customers automated emails
Hyperline allows you to manage the types of emails sent to your customers. There are 5 different types of emails that can be enabled or disabled according to your preferences.
* Invoice to pay
* Invoice paid
* Checkout session created
* Checkout session completed
* Payment error
Click on 'Save changes' to validate.
This settings apply to all your customers.
If you wish to apply specific settings at the customer or subscription level, please contact our support.
Visit our [Invoice emails](../invoices/emails) documentation page for more details about invoice emails.
# Multiple accounts
Manage multiple companies on Hyperline
Hyperline enables you to create and configure multiple companies, providing you with distinct accounts for each legal entity. This feature streamlines your billing process by allowing specific set up for each account.
Switch between your various companies seamlessly by clicking on the desired account using the switch button in the product. This eliminates the need to log out and log back in when managing different accounts!
You have the ability to independently [manage your team members](./users) for each account, allowing for precise control over access permissions.
# Testing mode
Learn how you can experiment with billing safely before going to production
## Hyperline test mode
We are well aware that setting up a billing platform can be stressful or intimidating at first glance, especially because it requires experimentation and is linked to an important aspect of your business: revenue. This is why we provide you with a **test mode** (also called **sandbox**) to conduct all kinds of tests without impacting your real account.
When switching to the test mode, this will allow you to perform fake transactions, generate false invoices, add fake customer accounts, and so on. You can get some experience with our features before setting up your real account.
This mode offers the **exact same features and works the same way as your Hyperline (real) account**. Please refer to this documentation to learn how to configure your [product catalog](../products/overview), manage [pricing plans](../plans/overview), [send invoices](../invoices/overview), [use credits and wallets](../wallets/top-up), and more.
On your test account, platform emails are sent as they would be in your real account. Please ensure caution when using emails for your test customers to avoid using real ones and prevent them from being inadvertently delivered to your actual customer mailbox.
## Testing payments
We strongly encourage you to conduct tests before getting started with your real bank account(s). To do so, you can use testing credit cards and false bank account numbers as specified below.
### Testing credit cards numbers
To test payments in Hyperline, you can use the false credit card numbers provided by Stripe or Mollie (see section below).
Payment Service Providers (PSP) provide testing credit cards numbers for users to perform transaction tests.
You can find testing card numbers on the following pages:
* [Stripe testing cards](https://stripe.com/docs/testing#cards)
* [Mollie testing cards](https://docs.mollie.com/overview/testing#testing-different-types-of-cards)
### Testing direct debits
You can test direct debits with test account numbers provided by most PSPs.
You can find testing numbers you can use for Stripe [on this page](https://stripe.com/docs/testing?payment-method=sepa-direct-debit#non-card-payments).
## Simulate usage data without code
This applies if you want to **configure your first usage-based plan** and to **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 on the **Events tab**, and click on the **Simulate new events** button.
Fill up:
* **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 on **Create new events button** 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.
# Users & permissions
Invite team members and set permissions to collaborate on Hyperline
You can invite an unlimited number of team members to access your Hyperline account. We offer 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](./multiple-accounts) using the same login credentials.
## 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 first user of the account (i.e. the one who created the Hyperline account) is granted an **Account owner** role, with full access.
If you wish to transfer account ownership to another member, please contact our support.
### Default role
One of the roles is designated as the default. This role will be automatically assigned to members created through a connected integration, such as a CRM.
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
# Glossary
Billing can get **quite complex**. Learn more about Hyperline's key concepts and what they mean in the context of the platform.
Some things are still unclear? Don't hesitate [to reach out to our
team](mailto:support@hyperline.co) if you need additionnal support.
### Billing platform / billing solution
Hyperline is a **billing platform**, not to be confused with a **Payment Service Provider** (PSP) such as Paypal or Stripe. A billing platform or billing Saas solution is a platform that helps businesses manage their billing and invoicing processes. It automates tasks like invoice generation, recurring billing for subscriptions, and payment processing. Hyperline offers ways to connect with your PSPs (Stripe, Mollie, Gocardless) so that we can update the status of invoices and payments for you.
### Checkout page
Hyperline provides you a **checkout page** allowing your customer to autonomously fill their billing information and subscribe to your product.
Generating a checkout page for your customer is only possible after you [assigned them with a new subscription.](../subscriptions/create) or [charge them for a one-time payment](../invoices/overview#one-off-invoices-charge-one-time-payments)..
### Coupon
A coupon is a way to give a discount to your customers. You can either decide to offer a fixed amount (a 10\$ coupon), or a percentage (10% off).
Learn more about how [to create and apply coupons](../coupons/overview).
### Credit note
When you refund a customer, either fully or partially, we issue in Hyperline a credit note (CN) that will appear under those initials in your customer's transaction's history. Credit notes have the same layout as invoices, but feature a refund instead of a payment.
Learn more about refunds and credit notes [on this page](../invoices/refunds).
### Currencies
We offer dozens of different currencies for you and your customers to choose from. Yet, your account can only have two main currencies: an **accounting currency** (the one matching the country and address you provided while configuring your account) and a **reporting currency** (that will display on your dashboard but not impact your invoices).
Learn more about currencies on the [Supported currencies](../get-started/currencies) page.
### Customer
We call customer in Hyperline the end user of the services you are selling. Customers need to be created in Hyperline before you can assign them subscriptions or bill them for one-time payments.
Learn more on how to [create customers](../customers/create).
### Customer portal
Customer portals are part of the hosted pages we offer you to allow your customer to make autonomous payments (along with checkout pages). From customer portal, your customers can make payments, update their payment method, [add credit to their wallet](../wallets/top-up) and download their past invoices.
### Dunning
"Dunning" refers to the process of communicating with customers who have overdue payments or outstanding invoices to remind them to make payments and resolve any outstanding balances. The primary goal of dunning is to recover the owed funds while maintaining a positive relationship with the customer.
In Hyperline, we alert you when an invoice is still unpaid after the payment delay exceeded (for bank transfers only). Three days before the **due date**, we will notify the customer with a warning that the invoice is about to be late. On the due date, the invoice status switches to **late**. The customer is notified.
### Invoice
Invoices are at the heart of Hyperline's product. We allow you to bill your customers easily for many different products and pricing models. Invoices are managed in the Invoicing section, and you can [configure them](../invoices/configuration) in Settings → Invoices before you get started.
Invoices are always numbered sequentially that can't be altered.
### Legal information
You can add legal information that will be featured on all your invoices (in the footer). This can be related to VAT, legal specificities related to your industry or geographical area, or your terms and conditions specific to the services you provide.
### Payment Service Provider (PSP)
Payment service providers - also known as merchant service providers or PSPs - are third parties that help merchants accept payments. Payment service providers enable merchants to accept credit and debit card payments (as well as Direct Debit, bank transfer, real-time bank transfer, etc.) by connecting them to the broader financial infrastructure. They provide both a merchant account and a payment gateway, ensuring that businesses can collect and manage their payments in a simple and efficient way.
Hyperline allows you to connect to your PSP's account (either Stripe, Mollie or GoCardless at the moment) so that transactions can be automatically processed, and your invoice statuses updated accordingly. Hyperline is not a PSP, we are a billing solution that connects to PSPs to automate the invoicing flow.
### Pricing models
**Pricing models:** A pricing model refers to the strategy used to determine how a product or service will be priced. It can include various approaches such as subscription-based, usage-based, or tiered pricing. We explain in more details the different pricing models below. Visit [our Saas Pricing Explorer](https://explorer.hyperline.co/) for more insights into pricing models.
### Subscriptions
In Hyperline, the subscription model represents the link between a customer and a plan, alongside additional options like prices, items and [coupons](../coupons/overview). You need to create a customer and a plan prior to [assign subscription to customers](../subscriptions/create).
Subscriptions can be paused, cancelled (with or without a refund). They match the pricing model (usage based, monthly regular payment, etc.). A customer can have multiple subscriptions at the same time.
### Usage data & events
Usage data refers to the detailed information sent by SaaS application users, tracking their interactions and activities within the software. This includes actions like accessing features, making API calls, or using specific resources. Usage data and events are relevant in the context of usage pricing models where you charge your end-users proportionally to the service they consume.
"Events" represent specific user-triggered occurrences or actions within the application, such as data uploads, API requests, or the initiation of specific processes.
### Tax number
A tax number help tax authorities track tax collection and compliance. It can refer to VAT number (a unique identifier for businesses registered to collect and remit Value-Added Tax (VAT) in countries with VAT systems), or Sales Tax Number (a unique number assigned to businesses by state or local tax authorities in regions where sales tax applies).
Learn more about [Tax management](../invoices/tax-management)
### Wallet
Wallets and [top-up](../wallets/top-up) are used in the context of “pay-per-use” or if you wish to offer free funds to your customers. The wallets' capability allow you and your customers to pre-pay funds to be automatically used by Hyperline's system when paying invoices.
# Welcome to Hyperline!
Hyperline is the most flexible billing platform for B2B SaaS businesses.
Our mission is to make subscription billing radically simple with an innovative and enjoyable experience. With Hyperline, managing your customers, creating diverse pricing models or plans, and initiating your billing process is effortlessly done in just a few clicks!
## Get started
High-level set up of account and payment provider.
Create and manage your customers in Hyperline.
Familiarize yourself with the concept of subscriptions.
Configure, brand and send invoices from Hyperline.
Send your usage data and configure your first plan.
Visit our technical documentation for more details.
# Why building your billing system in-house is not a good idea
Your company is growing? Congratulations! It is not 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
How to configure your invoices
If you did not already configure your invoices during the initial onboarding process, you can do it anytime from the 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 up the trade and legal names of your country, your Tax number (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 invoices design.
Click on `Save changes` once you are done.
## Invoicing
You can customize settings that will apply to all generated invoices. New configuration will be applied for invoices generated after the changes will be 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 |
#### Next invoice number
Do you already have an invoicing history?
If you do, we encourage you to have a look at the number of last invoice you sent, and to indicate this number +1 as the **next invoice number**. This way, you will keep a sequential order between your invoices while transitioning to Hyperline.
The invoice numbers generated after you set the next invoice number will follow each other in a sequential order. Once the first final invoice is generated on Hyperline, this number cannot be changed.
You can change this invoice number format at any time. However, we recommend
you to make sure it does not create any issue with your accounting.
#### 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.
#### 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.
Click on `Save changes` when you are ready.
# Create invoice manually
Learn how to create an invoice manually
In most cases, invoices are automatically generated, either on a recurring basis for ongoing subscriptions or from one-time payments.
Hyperline also enables **manual creation of invoices for specific ad-hoc needs** with a visual preview. To do this, click on the 'Create Invoice' button from the customer details page.
## Invoice header
You can edit your billing information on Settings > Company (this will impact
all your other invoices created afterwards) and your customers' billing
information on their customer details page by clicking on Edit information.
#### Emission date
For legal reasons, the emission date cannot be updated and will be set on today's date.
#### Due date
You can set the due date anytime in the future, including today. This will function the same way as the payment delay: once the due date reached, the invoice status will change to late.
#### Purchase order
Optionally, you can add a custom purchase order on the invoice.
#### Custom note
Optionally, you can add a custom note on the invoice. You can use it to add any additional information to your customer.
## Line items
Line items correspond to the products on your subscription and one-time-payment invoices, expect they are fully custom, and not connected to the product and coupons catalog. This means you can add custom line items and coupons that will be one-use only.
#### Add line item
You can add an unlimited amount of line items to your invoice by clicking on new line item. The name, description and display a custom payment interval can be fully customized. The quantity and unit price will be multiplied automatically to calculate the total price. The VAT rate is set based on the customer country, and cannot be edited.
#### Delete line item
Line items can be deleted at any moment by clicking on delete line item.
## Coupons
Coupons will apply a discount to the total amount of the invoice before taxes.
#### Add coupon
You can add a coupon and customise its name and discount amount.
#### Delete coupon
Coupons can be deleted at any moment by clicking on delete coupon.
## Create draft invoice
Once all set, you can click on 'Create draft invoice'.
The invoice generated will not be sent to the customer, but put into a `draft` status. You will be able to [edit the invoice](./edit) as many times as a needed before generating the final invoice to send it to your customer.
# Custom documents
How to customize your custom documents
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.
# Duplicate invoice
Learn how to duplicate an existing invoice and edit it
Hyperline allows you to **duplicate and modify information displayed on any existing invoice**, providing you with full flexibility and control over the final invoices.
From an existing invoice, click on the 'Duplicate invoice' button in the Actions dropdown.
This is useful if you want to quickly duplicate a payment, or if there was an error on a final invoice and you want to fix it.
If any changes have been made to the customer's address or tax rate, the new
invoice will be up-to-date.
We provide you with live visual preview to ensure a clear and accurate final
rendering of the content.
## Header
### Creation date
You can set any emission date, but be careful, setting an emission date different from the current date may not be compliant in your local regulation.
### Due date
You can set the due date from the creation date to anytime in the future. This will function the same way as the payment delay: once the due date reached, the invoice status will change to late.
### Purchase order
Optionally, you can add a custom purchase order on the invoice.
## Line items
Line items correspond to the products from the subscription or one-time-payment the invoice was generated from. They can be fully customized, and any edit will not impact the product catalog or ongoing subscription.
### Edit line item
For each line item, you can customize the name, description and display a custom payment interval. The quantity and unit price will be multiplied automatically to calculate the total price. The VAT rate is set based on the customer country, and cannot be edited.
### Add line item
You can add an unlimited amount of line items to your invoice by clicking on new line item.
### Delete line item
Line items can be deleted at any moment by clicking on delete line item.
## Coupons
Coupons will apply a discount to the total amount of the invoice before taxes.
### Edit coupon
Their name and discount amount can be edited. If the amount was a percentage of the invoice, it will be transformed into a fixed amount coupon.
### Add coupon
You can add a new coupon to the invoice by clicking on add coupon.
### Delete coupon
Coupons can be deleted at any moment by clicking on delete coupon.
## Save changes
This will create a new draft invoice, allowing you to generate the final invoice and send it to your customer whenever you want.
# Edit invoice
Learn how to edit an existing invoice before being sent for payment
Hyperline allows you to **modify information displayed on the invoice before sending it for payment**, providing you with full flexibility and control over the final invoices.
An invoice can be edited when its status is `draft` or in `grace period`. Invoices with other statuses will not be editable, as they have already been finalized and sent to your customers.
From an existing invoice, click on the 'Edit invoice' button in the Actions dropdown.
We provide you with live visual preview to ensure a clear and accurate final
rendering of the content.
## Header
### Emission date
For legal reasons, the emission date cannot be updated and will remain set on the day the invoice was created.
### Due date
You can set the due date from the creation date to anytime in the future. This will function the same way as the payment delay: once the due date reached, the invoice status will change to late.
### Purchase order
Optionally, you can add a custom purchase order on the invoice.
### Custom note
Optionally, you can add a custom note on the invoice. You can use it to add any additional information to your customer.
## Line items
Line items correspond to the products from the subscription or one-time-payment the invoice was generated from. They can be fully customized, and any edit will not impact the product catalog or ongoing subscription.
### Edit line item
For each line item, you can customize the name, description and display a custom payment interval. The quantity and unit price will be multiplied automatically to calculate the total price. The VAT rate is set based on the customer country, and cannot be edited.
### Add line item
You can add an unlimited amount of line items to your invoice by clicking on new line item.
### Delete line item
Line items can be deleted at any moment by clicking on delete line item.
## Coupons
Coupons will apply a discount to the total amount of the invoice before taxes.
### Edit coupon
Coupons already added to the subscription will be found in the coupon section. Their name and discount amount can be edited. If the amount was a percentage of the invoice, it will be transformed into a fixed amount coupon.
### Add coupon
You can add a new coupon to the invoice by clicking on add coupon.
### Delete coupon
Coupons can be deleted at any moment by clicking on delete coupon.
## Save changes
When the invoice status is draft, the saved invoice will **remain in draft**, allowing you to generate the final invoice and send it to your customer.
When the invoice is in the grace period, editing it and saving the changes will **switch it to draft status** and **disable metering for future ingested events**.
# E-invoicing
Learn about electronic invoicing compliance in Hyperline
## 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 standard** in the European Union, which means it can generate valid invoices in the required PDF and XML formats and automatically transmit issued invoices to the relevant tax authority of the invoicing entity's country.
Although the implementation of the e-invoicing standard in France has been postponed to 2026, Hyperline is proactively incorporating this compliance aspect into its product foundations. Hyperline is currently collaborating with a Partenaire Dematerialisation Platform (PDP) to offer this service in France and other future countries once the standard becomes obligatory.
| Country | Generate compliant PDF & XML files | Automatic transmission |
| -------- | ---------------------------------- | ---------------------- |
| Italy | Yes | Yes |
| Portugal | Yes | Yes |
| France | Yes | Planned |
| Germany | Yes | Planned |
| Spain | Yes | Planned |
## Activation
If your country already requires this standard, you can activate this capability in your settings.
You can then follow the status of the transmission for each invoice in the invoice details page.
# Invoice emails
Overview about customer email notifications for invoices
Hyperline automatically sends invoices to your customers via email.
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 his 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 your 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 note.
## 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 invoice email will take precedence over the customer's email.
If everything looks good, press "Resend email", and the email will be sent. An entry will also be added to the invoice's history.
# Invoice exports
Learn how to export your invoices
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 on 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.
### 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
Easily share a dedicated invoice page with your customers
## 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 into a CSV file by clicking the button on the top-right corner.
# Overview
Overview of the invoice concept
## 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.
Invoices numbers always follow a sequential pattern (learn more in the [invoice configuration](./configuration#invoicing-numbers)).
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's 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's 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 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 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](../payments/reconciliations).
* **Partially paid** - The invoice has been paid only partially (only for transfers). See the [Transactions & reconciliation page](../payments/reconciliations) for more details.
* **Paid** - The invoice is fully paid and now has a settled date, you can bookkeep it.
* **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).
### Invoice categories
* **Refund** - The related payment has been refunded. A credit note has been issued.
* **One-time payment** - Describes a one-off invoice.
* **Subscription** - Describes an invoice that is part of a subscription.
### Invoice filters
* **Outstanding** - Invoices that have been only partially paid and still awaiting for payments.
* **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.
## Send recurring invoices
Recurring invoices are automatically generated for recurrent payments, such as for monthly subscriptions. For this, you need to [assign](../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-off invoices (charge one-time payments)
One-off invoices will be generated for one-time payments, such as onboarding fees, unique license fees or any other kind of product with a **fee** model you create from the **Product catalog** section.
To charge a one-time payment:
Select the customer you want to charge.
If none are set by default, you can still visit the **Product catalog** page to create new fee products.
1. If you select **Charge immediately**, the invoice is created instantly and will appear with a **Paid** status.
2. If you select **Generate checkout link**, 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 for a customer without an active subscription.
# Credit notes & refunds
How to issue credit notes and refund a paid invoice
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 unpaid invoice, or
for an invoice not created by Hyperline.
As an alternative, you can [provide a free top-up on your customer's wallet](/docs/wallets/top-up),
which will be used to pay for future invoices.
## Configuring your credit notes
Credit notes are generated manually or when you refund 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.
## Refund a paid invoice and issue a credit note
If you wish to refund an invoice that has already been paid:
Click on the invoice to refund. Note that only **paid** or **partially
paid** invoices can be refunded.
Refunding a payment will initiate a new transaction to your customers'
default payment method and generate a credit note. This action cannot be
undone.
Click on **Refund** to validate.
This will generate a credit note marked as **paid**.
Credit notes appear in the invoice list in the **Refund** category.
## Visualize your credit notes
To see your credit notes:
From there, you can download credits notes and/or see transactions on PSPs by clicking on the three-dots menu for each credit note.
# Invoice reminders & dunning
Learn how to automate your payment reminders and dunning process
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 via bank transfer can be more challenging, often requiring you to manually remind your customers about due invoices and missing payments.
Hyperline offers a complete invoice reminders module, allowing you to schedule email **reminders before, on, or after the due date** with fully customizable sequences, messaging, and cohorts. This enables you to **tailor your wording and email frequency** based on your own criteria, **automating your payment reminders and dunning process**, thereby eliminating any tedious manual actions.
By default, we create a default sequence (with English wordings) for all new accounts with the setup described in the following image.
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:
Add a name, choose a language, and add at least one email.
### Cohort settings
When creating a sequence, it's necessary to configure a cohort. A cohort is defined by a set of criteria that your customers must meet for the reminder sequence to be used for outstanding invoices. Only customers paying by **bank transfer** are considered.
By default, you have the option to select a specific language that your customers should match to be part of the cohort. Additionally, we offer an 'All' option, which allows matching with all customers regardless of their language preference.
For added flexibility, you can configure [custom properties](../properties) on your customer entity. This enables you to base your reminder sequence cohort on specific values within these custom properties, allowing for a more tailored approach to managing invoice reminders.
### 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. Your can also configure the email subject and body with your own content.
The PDF invoice will be automatically attached in all email reminder sent.
To preview the email, 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 Customers page > Click on the customer > 'Edit' link > Switch off the 'Invoice email reminders'.
## Track emails sent
When an email reminder is sent for a specific invoice, a corresponding history log in added to the invoice (invoice details page).
As for other emails, we provide delivery, open, and read status for complete traceability.
# Tax management
Taxes computation can drive a lot of complexity into your invoicing process. Luckily, Hyperline can manage this for you, at no extra cost.
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, it's crucial to determine whether your customers are businesses or consumers. Hyperline will verify VAT numbers for you so you can make sure to only manage legally registered businesses.
Here's a flow chart representing how VAT should be applied (and how Hyperline works under the hood).
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.
### Outside the EU
If you're a business registered within a 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.
## Taxes in Hyperline
In Hyperline, tax settings are managed per invoicing entities, 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 tax standard 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, 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 filling taxes by country.
To opt for this mode, you need to navigate to the 'Settings' section, then '% Taxes' and deselect the 'Enable Automated Tax Collection' toggle, which is enabled by default.
### Tax 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 lines.
### Tax per customer
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 to that rate in the invoice. You can add a custom invoice note for the customer to fix this.
#### Customize tax rate per customer
### VAT in the EU
Hyperline automatically manages VAT in the EU - but a customer will only get a reverse charge rate (so a 0% rate) if the tax number is filled on their profile. You can do it yourself or have them do it from their portal / checkout flow.
### Checking for invalid VAT numbers
While we are verifying the VAT number's validity and displaying it in your interface, we're trusting your customer as long as the format of the VAT number is valid.
VAT databases are not always up-to-date and Hyperline cannot always confirm a specific number belongs to a specific customer.
Make sure to check our interface regularly to see if some customers have invalid VAT numbers (in the **Customer** page → VAT number).
An invalid VAT number does not impact the ability to send invoices with Hyperline, but it can have negative consequences on your business if your invoices are not VAT compliant in your country (subject to fines).
### Default tax rates
When using the Hyperline's automatic tax collection feature, you can define codes for the default tax rates, so that they match the codes in your accounting software.
#### Assign code to default tax rates
Select the country and the tax rate, assign the code from your accounting
software, and click on 'Set tax code'.
If you have an accounting software connected to Hyperline, the tax codes will be automatically linked to the item lines, before pushing the invoice to your accounting software.
### Custom tax rates
While country's standard tax rates are used by default in Hyperline's tax rate logic, you can also customize specific tax rates to suit your needs, which don't have to match the general standard rates.
#### Create reusable custom tax rate
The tax code is used to help you match tax in your accounting software.
The custom tax rates can later be assigned to products in your catalog, allowing for precise control over which rate applies to each product, depending on the invoicing entity.
# Invoice payment term
Learn about invoices payment term settings
Setting 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 settings can be updated afterward using the 'Edit customer' action, and will impact every invoice created afterwards.
## Grace period
For invoices with dynamic 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
Learn how Hyperline orchestrates payment providers
Hyperline natively support majors Payment Service Provider (PSP). This means that using these services won't require you any technical operation: simply connect your account in one click and let Hyperline orchestrates it without extra work on your side.
| PSP | Supported payment methods |
| ---------- | ------------------------------------------------------------ |
| Stripe | Card, SEPA Direct Debit, ACH Direct Debit |
| Mollie | Card, SEPA Direct Debit, SEPA Transfer |
| GoCardless | SEPA Direct Debit, Bacs Direct Debit |
| Airwallex | Card, SEPA Direct Debit, Bacs Direct Debit, ACH Direct Debit |
## Orchestration
Following connection, Hyperline will automatically create or update customers and their related details as needed on the payment providers.
Payment method collection forms (card details, Direct Debit mandates, etc.) are directly embedded in Hyperline flows, hosted pages, and frontend components without requiring technical work on your part.
Payments are automatically triggered on the customer's payment method when needed, and all related flows (retry, refund, chargeback, etc.) are natively integrated for you.
You no longer have to worry about the technical complexity of integrating a payment provider; just use Hyperline, and we cover the rest for you. As an extra advantage, switching between providers becomes a no-brainer since you are not coupled with any specific one anymore.
## Import
Hyperline supports starting with an existing payment provider account. We have mechanisms to easily import your customers and their associated payment methods into Hyperline, allowing you to start with your current customer base without needing to ask for your customers' payment methods again.
Please contact our support if you are interested.
## Multi-providers
You can connect multiple payment providers simultaneously. This allows you to distribute payment method usage among multiple providers at different costs.
For example, you can let your customers pay by card using Stripe and by SEPA Direct Debit using Mollie, benefiting from negotiated rates for each.
Additionally, you can connect multiple accounts of the same provider.
# Handling payment errors
How to handle invoice payment errors
## 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 saved payment method of the customer by creating a debit or initiate a payment. This is the basic use case for credit cards and Direct Debit.
This payment method should have been previously saved by the customer when they went through a checkout or filled it in their portal page.
**Bank transfer payments and manual reconciliation**
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 3rd attempt
For each attempt, a new transaction is created for the invoice. If all the attempts fail, we will mark the invoice as "error".
This state corresponds to the `error` status on the invoice API, and to the
`invoice.errored` webhook message.
## Subscription error
Additionally, if the invoice is related to a running subscription, we will switch the subscription to a `payment errored` state.
Following this, we will 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.
**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, you can click on the **Retry charging 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 the problem can be resolved by your customer, for example, because their card has expired or declined and needs to be replaced, or because they do not have sufficient funds on the card and need to act accordingly, we will inform them by email, telling them that they can manage their payment on their dedicated portal page (with a link pointing to it).
### 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 the using [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
Learn about supported payment methods
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 ([Europe and other countries](https://www.ecb.europa.eu/paym/integration/retail/sepa/html/index.en.html))
* **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
On your **Settings** -> **Payment**, you can connect the PSP you want to use and select the payment methods you want to enable on your account.
## Payment Service Provider (PSP)
Hyperline natively support three majors PSP. This means that using these services won't require you any technical operation, 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 |
| Mollie | Card, SEPA Direct Debit, SEPA Transfer |
| GoCardless | SEPA Direct Debit |
## Customer payment methods
At your customer level, you have the flexibility to customize the payment methods you wish to enable. This allows for precise control in restricting payment methods based on customers. The enabled payment methods will be presented to the customer on their [portal page](../customers/portal) or when utilizing [embedded components](../../api-reference/docs/react-components).
This can be configured either in the **Settings** modal within the **Payment methods** section on the relevant customer page, or when assigning a subscription to a customer and selecting the [New](../subscriptions/create#payment) payment method option.
Additionally, you can optionally configure the **default payment method** used by your customer between the saved payment method, bank transfer, or outside of Hyperline. If not configured, Hyperline will automatically use the first payment method set by the customer.
## Manage payments outside of Hyperline
If you are not interested in using built-in payment capabilities, Hyperline lets you manage payments outside of its system. This is particularly useful if you already have a complex banking system in place or if you are already acting as a payment operator.
For this, you don't need to connect a PSP and you can configure your customers to use the "Outside of Hyperline" option as payment method. When activated, this option will disable all payment-related logic in the billing flows and remove the payment method sections in the checkout and portal pages.
# Transactions and reconciliation
Alongside pricing and billing-related capabilities (including subscriptions, invoicing, etc.), Hyperline assists you with the payment process by charging the payment method and automatically reconciling it.
Payments correspond to the 'Transaction' concept and represent a move of money.
## Transaction status
In the Invoice section, there is a segment dedicated to displaying the invoice's transaction status. This status can be:
* `To process`: The transaction is waiting to be processed by Hyperline system.
* `Pending`: The transaction has been authorized by the related payment processor, but the banking transaction is not yet settled.
* `Settled`: The transaction has been cleared on the banking side, the money transfer is fully completed.
* `Cancelled`: The transaction has been cancelled and won't be processed again.
* `Failed`: The transaction failed. Learn how to handle payment errors [on this page](./payment-errors).
One invoice can feature several transactions with different statuses.
## Payment reconciliation
### With a payment provider
If you choose **cards or direct debit**, invoices processing will be automatic and **automatically reconcile** without the need of manual action.
Learn more about how to handle payment errors [on this page](./payment-errors).
### With an external bank account
Hyperline **supports over 3000 bank connections in 30 countries**, enabling you to link your business bank account in just one click within the platform. Once added, you'll be able to connect and use your bank account details in invoices, and allow Hyperline to **suggest transactions from the account for each invoice, facilitating easy reconciliation**.
Click on 'Connect bank account'.
Click on the 'Link new bank' button and follow the steps.
Once linked, you can decide which account you want to connect.
Hyperline will automatically suggest transactions from your bank account for each unpaid invoice based on matching details. Reconciliation is shortened to just one confirmation click!
Suggestion for invoice reconciliation is available on each invoice when they are in 'To pay' or 'Partially paid' statuses and assign to the 'Bank transfer' payment method.
Transactions are fetched daily, meaning that a transaction arriving in the bank account on one day will be suggested for reconciliation the following day.
#### Disconnect bank account
If you which to disconnect your bank account from Hyperline, simply delete your bank account.
### With automated bank transfer
Hyperline offers a method to **automate bank transfer reconciliation** by assigning bank account details to each invoice for a customer (the account details remain constant for each customer) and a distinct reference for every 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 in this bank account 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 and unrecognized reference, the funds are 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.
### With manual bank transfers
If you enable manual bank transfers as a payment option (in the 'Settings -> Payment' page), you'll need to manually update invoices as 'Paid' in Hyperline, since we cannot access your bank account information and transaction history.
After you've set up a subscription for your customer, they can pay via their checkout page by choosing 'Bank transfer'.
When the customer clicks on **Pay**, they will access a link to download their invoice as a PDF document.
From there, the invoice will appear to you in the **Invoices** section as **To pay**.
It will be your prerogative to mark it as **Paid** or **Partially paid** from Hyperline.
#### Marking invoices as paid or partially 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 a first payment is made by the customer.
There are two ways you can switch a **To pay** status to **Paid** or **Partially paid**.
From the Invoices page, by clicking on the three-dots menu on the line of the chosen invoice, and by clicking on **Mark as paid / partially paid**.
Or from the invoice page itself, by clicking on Actions and then on **Mark as paid / partially paid.**
You can choose to mark the invoice as **Paid** or **Partially paid**. Specify the amount paid and click on **Save**.
The **partially paid** status allows you to offer to your customers to pay in
several payments. You can update the invoice status after each payment until
receiving the total amount, and thus be more flexible in the payment options
you offer.
The invoice status will switch to either **Paid** or **Partially paid**, and the transaction status will be marked as **Settled** which means the transaction has been completed.
Here is how it will look for a partially paid invoice:
And for a fully paid invoice:
# Manage plans
Create plans to make it easier to assign subscriptions
In Hyperline, a plan is **a set of products and preconfigured prices and options**. They are used to represent your pricing offering or the different packages in a more structured way with customer-facing names.
Plans are a way to start a subscription easily, allowing you to start from the preconfigured ones when assigning a subscription to a customer — see them as templates for subscriptions.
A plan can contain multiple products, each product with their own configuration.
You can also configure a specific **commitment period** for a plan, alongside a **trial period**. You can choose to delay the first payment for the subscription to the end of the trial period using the **Delay first payment until the end of the trial period** option.
**A plan can encompass products with varying billing frequencies**, accommodating scenarios such as a product billed annually alongside another product subject to monthly charges based on usage.
# Price books
Learn about extending your product catalog with price books and fine-grained pricing attribution
## 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.
# Metering options
Learn about metering in Hyperline
Metered products are a bit more complex than standard products but don't worry, it's still easy to setup.
A metered 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. To know more about ingesting and managing events, you can read our [dedicated article](../usage/send-your-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
The understand how our different prices models work, you can refer to our [pricing models glossary](../products/overview#pricing-models).
As for any other products, metered prices can be overriden 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 tresholds to your subscription to make sure your customer won't pay under 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 treshold 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 4 different metering periodicity which should cover most use cases, don't hestitate 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 straightfoward option for most use cases, like billing overheads for a given subscription period or standard usage-based pricings.
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 : Committed 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 treshold (for instance your customer is allowed 10M€ of spent 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 : 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.
# Products catalog
Learn about product types and pricing in Hyperline
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.
## Types of product
Hyperline enables you to represent a variety of products for sale by leveraging three product categories.
### Fee
A "flat fee product" refers to a product or service for which the cost is a **fixed**, a **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 period 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 their 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.
Hyperline is enhancing its seat-based products by adding automated metering capabilities.
This will allow for background updates and customized payment terms, such as yearly pro-rated charges based on peak user counts.
Learn more about this in our [Automated seat-based billing](/docs/usage/connected-seats) guide.
**Pricing models**
This product supports both [volume](#volume) or [bulk](#bulk) prices.
### Usage
An "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 "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 needs 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
For a usage-based product, metering needs to be configured using operations (such as count or sum) on events to retrieve eligible data, which will be aggregated for billing within the period. Additional filters can be applied to extra fields in each ingested event to narrow down the eligible events for this product. These extra fields can contain custom values (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.
***
## Pricing models
Products in Hyperline support a variety of pricing models: **flat fee** pricing, **volume** pricing, **bulk** pricing, and **basic point (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 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.
### 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
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's language (if the customer has defined italian as its 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's translations)
* English
* Default product name
# Custom properties
Learn how to adapt Hyperline to your extra needs using custom properties
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**, **plan**, and **subscription** entities. 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 plans, 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 ask 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 purpose, meaning that it won't appear in the Hyperline's interface but will only be available through the API.
When this option is untoggled, the field is both accessible in the interface and the API.
## Managing custom property values
When created, the custom property can be found of the related entity in the interface.
On the **customer**, the custom properties appear in the bottom of the information panel on the customer details page.
For **products** and **plans**, they will appear in a dedicated box on the product/plan in the 'Advanced settings' section.
For **subscription**, you can set the value in the second step of the subscription assignation flow.
## 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/get-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), [plan](../../api-reference/endpoints/plans/get-plan).
### How this differ from the `properties` field on customer and subscription
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 those entities, we recommend using custom properties when possible to ensure safety and better manageability.
# Quotes
Learn about Hyperline quoting module
Hyperline provides a complete **CPQ (Configure Price Quote) process**, allowing salespeople to configure products, determine the price (pre-configured or custom) and produce a quote document for signature.
These documents give potential buyers the cost of goods or services before making a purchase decision and facilitate internal purchase approval processes. Once a quote is accepted and signed, the related subscription is automatically activated, starting the billing and invoicing cycle without any additional operations or manual actions.
## Create quote
A quote can be created and saved as draft to be finish later. You can create multiple quotes for a same customer.
Hyperline will display a warning message if there is an unfinished draft quote when creating a new one for the customer.
Click on the 'New quote' button in the top-right corner.
{/*
*/}
Select a customer for which you want to create the quote.
Optionally, you can start the quote creation from an existing template of your account gallery.
See more details in the [quote template page](./templates).
Configure an **expiration date** for your quote. After this date, the customer will still be able to access the quote but won't be able to sign it.
You can also decide to **collect customer payment details** as part of the quote signature flow. This is particularly useful when your customer pays by card or direct debit, as you can retrieve the payment method mandate and start invoicing with all the required details.
You can also opt to require a **Tax ID** (e.g., VAT number) from your customers. If enabled, providing a Tax ID becomes mandatory for customers to sign the quote.
All invoices from a subscription created by a quote will inherit from the **payment delay** configured on the assigned customer. Either, the customer has a custom payment delay or the default one from our account settings is used. You can customize this delay for the customer in one click from the quote creation flow.
Additionally, you can require your customer to fill specific pre-configured custom properties during the quote signature flow. This is useful if you have custom needs and you want to retrieve non-standard details from your customer. See more details in the [custom properties page](../properties/overview).
In Hyperline, the quote directly includes a subscription configuration. At this point, you can add a subscription with all the available capabilities from the subscription assignment flow: plan, contract configuration, invoice settings, products, price customization, coupons.
This is particularly powerful because once the quote is signed, the related subscription will start with all the given configurations without manual or technical work in between. Additionally, this ensures that quotes are created only for supported invoicing cases, and the customer will sign exactly what will be invoiced later, without any configuration drift.
Additionally, you can add custom free text notes for your customer and contract terms. Those will be display on the quote document and support line breaks and URL links rendering.
When creating or editing a quote, you can attach any PDF files in the additional information section. This allows you to include custom files such as Service Terms of Use, external contract files, or any other relevant documents for your business.
These attachments will be visible on the quote public link and during the quote signature step.
You can attach more than one file when editing an existing quote.
## Subscription options
When assigning a subscription configuration to a quote, we offer two additional options:
#### Automatically start subscription once quote is signed
This option allows the subscription to automatically start following the customer's signature of the quote. The subscription's start date will remain as configured in the quote. If not activated, the subscription will remain 'Pending' after the signature and will need to be manually activated later.
#### Align subscription start date with signature date
If you wish to align the subscription start date with the signature date, you can use this option. After the customer signs, Hyperline will automatically adjust the subscription contract and billing start date to match the signature date, overriding the dates configured in the quote. If not activated, the subscription start date will remain unchanged.
## Send quote
### Attachments
When creating or editing a quote, you can attach any PDF files in the additional information section. This allows you to include custom files such as Service Terms of Use, external contract files, or any other relevant documents for your business.
These attachments will be visible on the quote public link and during the quote signature step.
You can attach more than one file when editing an existing quote.
### Sending the quote
## Send quote
### Attachments
When creating or editing a quote, you can attach any PDF files in the additional information section. This allows you to include custom files such as Service Terms of Use, external contract files, or any other relevant documents for your business.
These attachments will be visible on the quote public link and during the quote signature step.
You can attach more than one file when editing an existing quote.
### Sending the quote
Once finalized, quotes appear as `Ready to be sent`. At this stage, you can decide to generate the related public quote page to share it with your customer for signature.
Alternatively, you can send it to your customer by email from Hyperline using the 'Send quote' action, or download it by PDF to share it by yourself. When sending from Hyperline, you can add a custom message and specify the email address of the signer (if different that the customer billing email).
After this, the quote will switch to a `Pending signature` status.
#### Reminder
Once sent, you can resend the quote 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.
Simply use the 'Edit quote' action, update the details, and re-send it to your customer.
Editing a quote will disable the existing public quote page and signature for
the customer. You can resend the quote or regenerate the public link if you
want to make it accessible again.
### 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
Learn about Hyperline quote signature process
Hyperline offers natively 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
This option 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.
## 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.
# Quote templates
Learn how to configure quote templates
To simplify the quote creation process, Hyperline offers a feature to create templates, allowing you to pre-configure quote details.
## Create templates
Only Admin users are able to create and manage quote templates.
Click on the 'New template' button.
Choose a name and optionally a description to easily identify your template.
You can find [all the details available](./overview#create-quote) in the create quote flow.
Pre-select the required values, texts, and attachments so they are prefilled when using the template when creating a quote later.
### Subscription plan
In quote templates, plans representing the subscription details are used. When creating a quote from a template, the plan details (contract details, products, prices, invoices settings, etc) will be used to configure the final quote subscription.
More details in the [manage plans page](../plans/overview).
## Using a template
In the quote creation form, you are able to select a template from the gallery or start the quote configuration from scratch.
## Stats
For each template, Hyperline highlights the number of quotes using the template and the related total estimated value.
# Public checkout page
Learn about the hosted checkout page to let your customers subscribe
When assigning a subscription or charging a one-time payment, Hyperline offers the option to create a **Checkout Session**. This generates a public page that can be shared with the customer, where they can view pricing details, enter their billing information, and add their payment method.
## Subscriptions checkout
When assigning a subscription, you can select an option on page 2 to create a new **Checkout Session** for the subscription.
The "send link by email" option will send an email to the customer with a link to the checkout session and can be used to speed up the process, otherwise the link will be available on their Hyperline page.
Payment methods are configured for the subscription whether or not you're setting up a checkout session - but the configuration will be used to choose which form we'll show the customer within the session.
For instance for a subscription with both **Card** and **SEPA Direct Debit Enabled**, you'll get the following interface.
Once the user validates the checkout, they'll receive an email confirming their subscription and the subscription will show as "Active" on your dashboard?
## One-time payment checkout
When charging a one time payment, you can also create a checkout session for the user to purchase your product. Options are the same, the interface looks slightly different as you don't have the subscription parameters.
# Subscription basic setup
Assign subscriptions to customers in Hyperline
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 [plans](../plans/overview) 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 plan or from scratch with the products from your catalog.
**Subscription start**
* **In the past**, if you want to backport a subscription that has already started but not in Hyperline yet for example - but be careful as we will bill any past period that's due.
* **Immediately**, the default value
* **In the future**, if you want to schedule a subscription for the future
**Subscription alignment**
If the subscription starts on the **first day of the payment interval**, it will be automatically aliged to finish at the end of the payment interval.
Example: my subscription is billed monthly. If my subscription starts on March 1st, the billing period will finish on March 31st ; the next one will start on April 1st, and end on April 30th, taking into account the number of days in the month.
If the subscription starts on **any other day of the payment interval**, the next payment date will be on the anniversary date.
Example: my subscription is billed annually. If my subscription starts on March 14th, 2024, the billing period will finish on March 14th, 2025 and so on.
**Subscription end**
* **End at a fixed date**
* **Keep on running forever**
In the contract configuration, we allow you to configure a **commitment period** during which you want your client to commit, and/or a date until which the subscription is in **trial period**.
If a trial date is configured, the first payment of the subscription can be delayed until the end of this period. This allows you, for example, to enable experimentation time of your tool to your customers, giving them the option to cancel the subscription if they are not satisfied with the service before paying something.
If a plan is selected, these configurations are automatically prefilled.
Select, remove, adjust the products either prefilled from a selected plan or from scratch.
Additional settings are available depending on the type of product (fee, seat, usage).
At this step, when you override the price for a given product, it will not impact your product catalog, it will only have an effect on the subscription you are editing.
This gives you high flexibility to use different prices per customer while still defining a base price for your offer in your catalog.
When adding products outside of a plan, after selecting the product, you will be presented with the list of prices that are set in your product catalog.
It's divided in a few sections:
* **Suggested:** will list the best pricing according to various parameter 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 congifiguration is selected, you can edit the product details.
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.
**Purchase order**
Add a text element that will be present on the header of every invoice emmitted 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.
**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 chose 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 setting**, 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
On 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 its 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.
#### 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 the
**Generate checkout session** option.
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
Three options are also offered to activate the subscription.
* **Immediately** or **Starting on...**, the subscription will start either immediately or on the specified starting date.
* **Manually later**, the subscription must be activated manually on the customer page.
* **After checkout**, this option is only available if you decide to generate a checkout session. The subscription will be automatically activated if the starting date has passed when the customer completes the checkout session. If the starting date is later than the checkout completion date, the subscription will be automatically activated on the starting date.
When activated and started, the first invoice will be automatically sent to the customer depending on the products charged or that need to be paid (more details about [invoice emails](../invoices/emails)).
#### Assign the subscription
When everything is set and ready to go, you can click on **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
```
Additonnaly, 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 [get subscriptions endpoint](../../api-reference/endpoints/subscriptions/get-subscriptions).
### Create a subscription from a plan
In this example, we create a new subscription from the plan `plan_zHmjoDea4ZRmQV` for the customer `cus_3PYD5R2q5NFK5E`, with a starting date on December 12, 2023 and activated by the customer through a generated checkout session sent by email.
```sh
curl --request POST \
--url https://api.hyperline.co/v2/subscriptions \
--header 'Authorization: Bearer ' \
--header 'Content-Type: application/json' \
--data '{
"customer_id": "cus_3PYD5R2q5NFK5E",
"plan_id": "plan_zHmjoDea4ZRmQV",
"starts_at": "2023-12-20T00:00:00Z",
"activation_strategy": "checkout",
"payment_method_strategy": "current",
"checkout_session": {
"send_to": { "email": "josh@acme.com" },
}
}'
```
### 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, 2023 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
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",
"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
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
Learn how to export your subscriptions
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
Manage a subscription lifecycle, pause or cancel it
## Activate a pending subscription
If you want to activate a subscription from a `pending` status (e.g. if the **manually** or **after checkout** activation strategy were used during creation, see [Activation section](./create)):
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 payment collection
You can pause a subscription if you want to stop payment collection without cancelling the subscription:
The subscription is not charged while paused. You can reactivate it anytime (instantly
or later).
### Reactivate a paused subscription
On the subscription, click on **Actions** then **Reactive payment collection**. Upon reactivation, Hyperline will not bill any past period that's due.
## Cancel subscription
If a customer wishes to stop his 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".
## Viewing past subscription history
In order to provide enhanced transparency regarding subscription activities, you have now 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)
# How do subscriptions work?
Overview of the subscription concept
In Hyperline, **the subscription model is the link between products (or a plan) and a customer**.
The subscriptions can be created via the customer page on the product by an Hyperline user, or orchestrated via the technical API.
## Subscriptions lifecycle
A customer can have one or multiple subscriptions at the same time. These subscriptions can be active (running), scheduled to start in the future, or scheduled to be automatically cancelled. This makes it easy to plan any changes or bill products with a different payment schedule and renewal logic.
Hyperline provides the flexibility to specify a commitment subscription period, which may differ from the billing interval of the product it encompasses. Furthermore, the billing intervals can also vary between different products.
This high level of flexibility enables you to 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 status is `pending`. You can choose how the subscription will be activated:
* when a new customer completes the [checkout](../subscriptions/checkout-page) flow
* automatically at the scheduled start date
* manually in the interface or with the API
Once a subscription is active, it will show a live green tag on your customer's page.
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 payment collection" 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 canceled from an active state.
* `voided` The subscription has been voided directly from the pending state.
* `paused` The subscription's payment collection 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 when to bill each product independently, either at the start or the end of the billing period. Usage-based product will always be billed at the end of the period, depending on the consumption.
This level of flexibility enables you to represent scenarios such as:
* A yearly subscription with a flat fee billed at the start of the period, and add-ons billed at the end of each quarter.
* A monthly subscription with a flat fee billed at the start of the month, and usage (like the number of user active) at the end of the month.
#### Only-once products
When creating a subscription, you can assign products billed only once (one-off items). This is useful for charging implementation or onboarding fees for example. You can also choose to bill these products at the start or end of the period, and when billed they will be detached from future invoicing.
# Update a subscription
Update aspects of a subscription, such as products, quantities, and coupons.
#### Overview
Navigate to the 'Update Subscription' interface from any subscription
You will find several options allowing you to adjust many aspects of the subscription:
#### Update products on the subscription
You can update the products that have been added to your subscription as well as remove them and add new ones
#### Add a product to a subscription
You can add a product to a subscription at any time. The product will be added to the subscription and the customer will be charged according to the options you choose.
In this step, you can override anything on the product such as it's price or name.
Just like when assigning a subscription, these changes are limited to this subscription and won't affect existing products in your catalog.
* **Do not charge:** Adds the product to the subscription without charging your customer.
* **Charge pro-rata:** Charges your customer a pro-rata amount based on the remaining time in the billing period.
* **Charge full price:** Charges the full price of the product to your customer immediately.
You will see a small recap of the options you chose. on the same page.
Click on **Add product** to confirm your selection.
#### Remove a product from a subscription
You can do so at any time. The product will be removed from the subscription and the customer will be refunded according to the options you choose.
* **Do not refund:** Removes the product from the subscription without issuing a refund to your customer.
* **Refund pro-rata** Refunds your customer a pro-rata amount based on the remaining time in the billing period.
* **Refund full price** Refunds the full price of the product to your customer immediately.
You will see a small recap of the options you chose. on the same page.
Click on **Remove product** to confirm your selection.
When removing a product before billing, for instance, if the product is on a
monthly billing, charged "end of period", and the removal is initiated
mid-month you'll have the option to charge the customer instead. The selection
choices will stay consistent.
#### Update product quantities
Quantities can be updated for any products that aren't directly connected to a data source
#### Update product prices
You can update the price of a product on a subscription at any time.
#### Applying and removing coupons
# Connect with BigQuery
Pull data automatically from your BigQuery project
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 setup 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 Editor**, then click "Continue" and "Done".
4. Find the newly created service account in the list, click on the service account, go to the "Keys" tab, then click "Add Key" and choose "Create new key.", choose JSON and click Create.
## Load your data
To get start, 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 save, it's all good.
# Configure your first usage-based subscription
To configure a usage-based subscription, you first need to connect your data as Hyperline will need some dataset for you to configure usage-based products. If it's not done already, you can use a [CSV file](./import-events-csv), our [API](./send-your-usage-data) ou [data loaders](./usage-data-with-connectors).
When your first events have arrived, you'll be able to create a usage-based product [here](https://app.hyperline.co/app/products/create/select/).
Select the usage based product, then configure your options and your metering to attach your product to the data you want to bill. Metering can be configured in many different ways, to know more you should take a look at our [product catalog guide](../products/overview#usage).
Once the product is setup and at least one recurring price is defined, you'll be able to assign it to a subscription.
Head over to the subscription tabs and click on [new subscription](https://app.hyperline.co/app/subscriptions/create), select your customer and then click on add product.
Select your product, an interface will appear for you to configure prices, the subscription schedule and various parameters.
If you want to learn more about metering options on a subscription, read our [metering guide](../products/metering).
Click on payment settings and assign the subscription using the `Manually later` option, you'll be redirected to the customer page, the subscription should display the current usage.
If you're in [test mode](../get-started/sandbox), you'll be able to simulate new events directly from the "events" tab.
If you want to explore your consumption, you can click on the little eye icon next to the unit count, it will open the live consumption modal and will give you the detail of your consumption.
And done! Feel free to browse our documentation specific to subscriptions or to contact us on Intercom to get some help on your use case!
# Automated seat-based billing
We're improving our seat-based products by integrating metering capabilities.
## Concept
Seat-based billing is a prevalent model, typically managed manually by companies using subscription update APIs in tools like Hyperline.
Here's the typical process:
The process can become more intricate if you're seeking **automatic updates** to prevent immediate charges to users, or if your billing needs involve specific payment terms.
For instance, if you want to bill customers yearly on a pro-rated basis at each month's end based on the maximum number of users, you would need to:
1. Monitor initial and peak monthly seat counts.
2. Schedule monthly updates for yearly subscriptions.
3. Wait until the end of the month or manually calculate earnings.
4. Manually calculate pro-rated charges unless using a flexible billing tool.
Our goal is to automate these steps directly in Hyperline.
## Theoretical Differences
How do metered and seat-based items differ?
| Seat-based | Metered |
| --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| Invoiced at the end of the period based on data used | Invoiced at the start of the period, end of the period or in real-time (when an event occurs) |
| Resets every period (meaning when we restart a period we restart the count) | Can be invoiced outside of the base schedule (a yearly item can be reviewed monthly) |
| Does not consider the time for each "event" | Considers timestamps |
| No pro-rata management as we don’t track when an item is added | Pro-rata management |
| Useful for: API calls, financial flows | Useful for: users, devices, connectors… anything that’s always live |
## Practical Application
### How to create an automated seat-based product?
Navigate to the Products Section for this.
Ensure to choose the event you wish to count or sum, as connected seats products are centered around an entity called an **aggregator**.
The aggregator plays a crucial role in gathering data received by Hyperline.
It determines whether the incoming data should be factored into the billing calculations, providing a more streamlined and accurate billing process.
That's it! Your seat-based product should now be marked as "**Connected seat**".
### How to configure connected seats product in subscriptions?
There are two main parameter groups: **Refresh and Invoicing.**
#### 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.
#### Invoicing schedule
* **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.
#### Other parameters
* **Application schedule**: We'll apply the update to the subscription immediately or wait until the end of the period. It doesn't impact billing but it affects the subscription values.
* **Charging method**: If prorata is selected, we'll charge the units at the pro-rated rate given the product payment interval. Full amount means we'll charge the entire price regardless of when the change is detected.
* **Charge the highest detected value for the period**: Instructs Hyperline to use the highest value it has counted regardless of the current one. Useful to always commit the maximum number of seats.
* **Refund when a decrease in unit count is detected**: Instructs Hyperline to count negative updates as refunds if they’ve already been paid.
## 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.
More detailed information can be found in the [Explore usage consumption section](/docs/usage/explore-usage-consumption).
# Explore your data usage
Exploring your data usage to understand how your customers are consuming your products
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.
This view is global and will show all the events that are being tracked.
However, for each subscriptions and invoices, 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
In order to analyze and process your usage data, you can download it in CSV format by clicking on the **Export CSV** button.
Then you'll obtain a CSV file with the following columns:
## Customise 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.
# Import events with a CSV file
## Format your file
To write a well-formatted events CSV file, you should follow these guidelines:
* Use a comma as the delimiter to separate fields.
* Use double quotes to enclose fields that contain commas or line breaks.
* Use a header row to describe the contents of each column.
* Use a consistent date and time format, such as ISO 8601.
* Use a consistent format for nested fields, such as `record/id` and `record/amount`.
* All fields are mandatory, except for the `record` field, which can contain any number of nested fields.
Here is an example of a well-formatted CSV file that follows these guidelines:
### Example
```csv
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-"
```
Note that:
The `timestamp` field follows the ISO 8601 format.
The `record` field contains nested fields, such as `record/id`, `record/amount`, and `record/is_live`.
* The `record/id` field contains an integer value, so it does not need to be enclosed in quotes.
* The `record/type` field contains a string value, so it needs to be enclosed in quotes.
* The `record/is_live` field contains a boolean value, so it does not need to be enclosed in quotes.
## Load your file
To get start, just go to the [events explorer page](https://app.hyperline.co/app/events/explore) in Hyperline.
To upload your CSV file, click on the `Import events from CSV` button at the top right corner of the page.
This will open a modal where you can select your file.
You can also download a template file by clicking on the `Get the CSV template` download button.
This file contains the header row and an example event, which you can use as a starting point for your own events CSV file.
Once you have selected your file, click on the `Import CSV file` button to start the import process.
If there are no errors or warnings, your events will be imported into Hyperline and will be available for analysis and visualization.
# Connect with MongoDB
Pull data automatically from your MongoDB database
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 start, 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 setup 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 opposed to tranditional 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.
# Send your usage data
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 anyways. If you need a great product analytics solution, we recommend you check out our friends at [June.so](https://june.so/) or at [Mixpanel](https://mixpanel.com/).
This being said, you shouldn't restrain 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).
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
Events payloads always follow the same (minimalist) structure and can be sent to the [POST `/events` endpoint](../../api-reference/endpoints/billable-events/create-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.
You can send as many as 50 events per second before being rate-limited. We'll increase these limits as our infrastructure grows, please contact us if you need a custom limit.
Here's an example payload
```json Event
{
"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're making some basic security check, we can't filter every personal or confidential data off 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 localization
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
{
"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 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, just send the same payload with the updated field and it will be updated.
To find out which event is the latest, we're using the `timestamp` value.
Using our users again, here's an example where we add a "status" property
```json
{
"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 them 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 early 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.
## 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
# Connect with Snowflake
Pull data automatically from your Snowflake warehouse
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 start, 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, Hyperline will only need a read access to the tables you need to synchronise.
## Load your data
Snowlake is a standard SQL loaders and you just 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 an `id`, `customerId` and `timestamp` fields with the correct casing.
# Pull usage data with connectors
No-code usage based with Hyperline connectors and automatic data pulling
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 trafic 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 start, 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 on 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 pour 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` will represent the date we use to calculate if a record should be included in an invoice. For instance, if you bill on monthly API calls, we'll bill all events with a timestamp within the last 30 days. It's less important if you don't have periodic metering
* `customerId` is the customer unique identifier **ON YOUR SIDE**. We'll use it to associate a record with a subscription.
* `id` is the identifier of the record **ON YOUR SIDE**. We'll use it to de-duplicate and update records later, so make sure it really represents the record uniquely.
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 had a name to the customer when creating it, which will make it easier for you to find them later.
To to summarise, the minimum acceptable request looks like this
```sql
-- 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
-- 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 on 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 in the interface.
### Deleting records
Hyperline doesn't delete records automatically to avoid any issue, we recommend that you add a `deletedAt` fields 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 query 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 that this, consider importing only records that have been updated after the last refresh, or importing them less often. It's actually quite easy.
```sql
-- Adapt this to your refresh time
SELECT xxx FROM table WHERE (updated_at + interval '60 minutes') > NOW()
```
# Overview
Overview of the wallet concept
## Use cases for wallets
Wallets allows you and your customers to pre-pay funds to be automatically used by Hyperline's system when paying invoices. This feature is particularly useful when you want to set up upfront payments in pay-as-you-go flows, or offer free funds to your customers.
There are 2 main concepts when starting with wallets in Hyperline:
* **Wallet settings**: configured at your account level and shared for all your customers
* **Wallet**: configured at your customer level and unique to the customer
In Hyperline, a wallet contains money in the currency of your customer.
A wallet cannot have a negative balance.
### 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.
### Free top-up
You might want to offer funds to your customers at no additional cost. Wallets allow you to do so by doing a free top-up so that your customers will have less to pay on their next invoice.
Free top-ups can only be made by Hyperline's users and from our API.
### 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 nil balance interrupts their services.
You can use [our webhooks](https://doc.hyperline.co/docs/webhooks) to monitor wallets activity.
## Configuration
Wallets are configured in the **Settings** page, in the **Wallets** section.
### Allow free top-up
This option allows you to add funds directly to your customer's wallets at no additional cost. Activate this option if you'd like to enable them.
### Allow users to buy top-up from the portal
You can choose to enable this option in the wallet settings.
Then, users will be able to add funds with their current payment method directly in their portal.
## Create a wallet for a customer
Now that you have enabled wallets in the settings page, you will be able to create wallets for your customers from Hyperline.
To do so, go to Hyperline main menu, in the **Customers** section.
Navigate to the **Wallet** tab, and click on **Create wallet.**
## Manage wallets
Once you have created a wallet, you can come back to it anytime to **Top-up** or **Pause the wallet payment** if you need to. Those are done through the wallet **Action** menu.
***
# Using the API
You can also decide to manage wallets using the Hyperline API. Visit our API reference documentation for more details.
* [Get wallet settings endpoint](../../api-reference/endpoints/wallets/get-wallet-settings)
* [Update wallet settings endpoint](../../api-reference/endpoints/wallets/update-wallet-settings)
* [Get wallet endpoint](../../api-reference/endpoints/wallets/get-wallet)
* [Create wallet endpoint](../../api-reference/endpoints/wallets/create-wallet)
* [Get wallet transactions endpoint](../../api-reference/endpoints/wallets/get-wallet-transactions)
# Manage wallet balances
Learn about top up, debit and balances
## Top-up an existing wallet
There are 3 ways funds can be added to a customer's wallet:
1. You can either top-up through Hyperline yourself (after discussing with your customer and agreeing on an amount)
2. Customers can also top-up their account themselves through their customer portal
3. The wallet can be topped-up through the API
### Top-up your customer's wallet in Hyperline
Once you created a wallet for your customer:
**Paid top-up** are funds your customer paid (or will pay) for. **Free top-up**
are an offer you are making to the customer (the funds will be added for free).
#### Invoices for top-up
One-off invoices are generated when users tops-up their wallet. As funds are added through credit cards, an invoice is generated at the time of purchase and paid immediately.
### Top-up from the customer portal
You can make your customers autonomous by offering them to top-up 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
Customers wallets are automatically debited when the feature is enabled (wallet settings configured) and if there is money on it. They are used to pay subscriptions, related invoices and one-time payments.
A wallet cannot have a negative balance.
We make sure to take the maximum amount of money from wallets when paying invoices, but the potential remaining part to pay will be processed with the default customer payment method (the one saved).
An invoice can have multiple debit methods, e.g. wallet + credit card, and this will be displayed on the final generated PDF invoice.
## Wallet balance & projection
Wallet balance are computed in real time in Hyperline.
In addition to the wallet balance, we also compute and return a projected balance. This balance take 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 restrain access to your product if the customer doesn't have enough funds on their wallet.
You can also decide to top-up a wallet using the Hyperline API. Visit our API reference documentation for more details.
* [Load wallet endpoint](../../api-reference/endpoints/wallets/load-wallet)
* [Get wallet balance endpoint](../../api-reference/endpoints/wallets/get-wallet)
# Exact Online
Learn how to push your invoicing data in your accounting tool
[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 you are not already logged into Exact Online, enter your credentials to
proceed.
The Exact Online connection flow does not offer the possibility to select in
which entity (called Division in Exact Online) the data will be pushed.
Please contact our support to provide your division number.
Invoices and credit notes will now be automatically sent to Exact Online.
## 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). Also, **new customers created in Hyperline will automatically be created** in Exact Online.
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.
### Payment synchronization
Hyperline supports 2 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.
The synchronization delay is 5 minutes maximum.
## Settings
Please contact our support team to define the following values to be used when creating invoices and credit notes in Exact Online:
* **Invoice account code**
* **Credit note account code**
* **Sales journal code**: by default, invoices and credit notes will be created with the sales journal code *70*.
### Product and tax codes
Exact Online requires a **product code** and a **tax code** for every invoice line item. You will need to configure the tax codes in the tax settings of the relevant invoicing entity, and then define the product code and tax code for every product that you intend to invoice in Exact Online.
# GoCardless
Learn how to collect payments through GoCardless on Hyperline
## Set-up
If [GoCardless](https://gocardless.com) is your preferred Payment Service Provider, integrating it with Hyperline is a straightforward process:
1. Navigate to the menu and select **Settings**.
2. Choose **Payment** from the options.
3. Click on **Connect** for GoCardless.
This will direct you to the GoCardless login page, where you will need to enter your account credentials and click on **Connect Account**.
Once the process is complete, you will notice the GoCardless status change to 'Active' in the Payment tab.
## Payment methods
Now that you have successfully activated your account, it will be automatically designated as the primary payment gateway for the following transaction types:
* **SEPA Direct Debit**: GoCardless accepts payments in Europe and in UK.
## Customer information
Each time you've successfully created and billed a customer in Hyperline, the corresponding customer profile and payment details are automatically generated in your GoCardless account.
If you want to double check you just have to on the Payments and Customers tabs on your Gocardless dashboard.
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.
It is not possible to change your payment provider from Hyperline in autonomy.
If you wish to do so, please contact support at the following address:
[support@hyperline.co](mailto:support@hyperline.co)
The account holder field is transliterated, upcased and trucated to 18
characters by GoCardless. This behaviour does not prevent payments to go
through.
## 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
Learn how to sync data from Hightouch
## 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 a 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 columns 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
{
"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 component
Learn how to benefit from Hyperline UIs right into your CRM
To seamlessly integrate your CRM usage with Hyperline's extensive UIs, flows, and capabilities, we offer a **native HubSpot card**. This card **appears on your company and deal views**, ensuring a perfect blend of continued CRM usage for your revenue teams along with access to all Hyperline functionalities.
## Installation
Before installing the component, ensure that you have a HubSpot account connected to Hyperline. If not, please refer to the [setup guide](./overview#setup) for instructions.
This component is **automatically installed when you connect your account**, requiring no manual action from you. It will appear directly on your company views once the setup is completed.
## Behavior
Once installed, this component can be found on both `company` or `deal` views, on the right side panel.
From it, you can directly manage your Hyperline customer, create new quotes, assign subscriptions, and manage existing subscriptions for your HubSpot company.
When loaded on the CRM side, the component will **automatically create the first time (and if it doesn't exist yet) a corresponding user on Hyperline** using the user email address from the CRM and the ['Account manager' role](../../docs/get-started/configure-account#account-manager-role).
### Root object
You can control the component's behavior and determine whether the root object displaying the billing details for the customer is Company or Deal.
# HubSpot
Learn how to connect HubSpot with Hyperline
The Hyperline HubSpot integration offers seamless synchronization of your HubSpot companies, quotes, subscriptions and invoices enabling effortless data transfer between Hyperline and your HubSpot instance without any manual effort or technical configuration.
Additionally, Hyperline provides you with a dedicated component that can be inserted into your HubSpot Company page, allowing you to assign and manage your subscriptions using the full-powered Hyperline UI directly within your CRM. [See more details](./component).
By doing so, the Hyperline integration empowers your business teams to **maintain Salesforce as their primary tool while capitalizing on the capabilities offered by Hyperline**.
## Prerequisites
You need to have a valid [HubSpot account](https://hubspot.com/) and admin rights on Hyperline.
We recommend you to **experiment with a test account** before going live. For this you can create a dedicated free [HubSpot account](https://app.hubspot.com/signup-hubspot/crm) for your testing, and use the [test mode](../../docs/get-started/sandbox) of your Hyperline account.
### Custom objects
In order to synchronize data, Hyperline needs specific custom objects on your HubSpot account. If the custom object doesn't exist, you won't be able to activate the synchronization for this entity and no data will be pushed to HubSpot.
| Entity | HubSpot Object Name |
| -------------------- | --------------------------------- |
| Quote | `hyperline_quotes` |
| Quote line item | `hyperline_quote_line_items` |
| Quote coupon | `hyperline_quote_coupons` |
| Subscription | `hyperline_subscriptions` |
| Subscription product | `hyperline_subscription_products` |
| Subscription coupon | `hyperline_subscription_coupons` |
| Invoice | `hyperline_invoices` |
| Invoice line item | `hyperline_invoice_line_items` |
To create them:
1. Click on the Gear icon (top-right corner).
2. Go to **Data Management** > **Objects** > **Custom Object**.
3. Click on the **Create Custom Object** button.
4. Enter the object name.
A field `name` of type text is mandatory for all created custom objects.
5. Proceed the same way for all the objects you want to synchronize
We recommend you create the specific custom objects only for the data/entity you need to sync.
## Behavior
### Data synchronization
The integration enables synchronization between your **HubSpot Company** (standard object) and Hyperline **Customer**, and automatically push data from Hyperline to HubSpot related to **Quote**, **Subscription** and **Invoice** (custom objects).
Upon connecting your HubSpot account, the integration will automatically configure the necessary custom fields in HubSpot on this object.
More details about the fields meaning can be found in the API reference for [quote](../../api-reference/endpoints/quotes/get-quote), [subscription](../../api-reference/endpoints/subscriptions/get-subscription) and [invoice](../../api-reference/endpoints/invoices/get-invoice).
Deleting a Hyperline custom field created in HubSpot might break the
integration. If you don't want to use some of them we recommend to hide them
in your pages layout settings.
### Native card component
Additionally, we offer a [native HubSpot component](./component) that enables you to create and manage quotes, assign and manage subscriptions, as well as manage customer details and invoices, through Hyperline flows embedded in your CRM.
## Setup
You will be redirected to HubSpot where you will be ask to enter your credentials.
The HubSpot card will be marked as 'Setup in progress'. **This operation can
take a few moments to complete** as we are preparing your HubSpot account to
be ready to be integrate with Hyperline.
You can now access the **Settings** and start benefit from the integration.
Learn [how to install](./component) the HubSpot native component.
## Settings
Hyperline allows you to configure how you want to integration to behave.
For customers you can decide to select the **synchronization direction** (one-way or bidirectional) and determine **which HubSpot companies to import** into Hyperline (all accounts or specific/flagged ones).
### Flagged companies
During integration setup, Hyperline will create a **Sync to Hyperline** checkbox field on the HubSpot Company object (`hyperline_sync` field).
When choosing the 'Only specific companies' option, the integration will import and synchronize companies where the **Sync to Hyperline** checkbox is selected, disregarding other companies.
The option 'Only specific companies' is selected by default, meaning that **we don't sync any HubSpot companies by default**.
## Send Hyperline Customer to HubSpot
Customers created before connecting your HubSpot instance won't be automatically transferred to HubSpot during the initial setup.
You can choose to send them to HubSpot on a case-by-case basis.
To do this:
1. Navigate to your Hyperline customer page (Customers > Click on the customer).
2. Click on **Integrations** in the top-right corner.
3. Utilize the **Send to HubSpot** button.
This option will sync the customer details, and push its subscriptions and invoices.
Additionally, you can use the "Re-synchronize" button anytime for a customer already sent to HubSpot. This actions retriggers the synchronisation.
## Reconcile Hyperline Customer and HubSpot Company
When a Hyperline Customer is created, a corresponding Company is created in HubSpot. Similarly, when a HubSpot Company is created or updated with the 'Sync in Hyperline' field enabled, a corresponding Customer is created in Hyperline. Both Customer and Company entities are then linked.
To associate an existing Customer (created before connecting your HubSpot account) with an existing Company, you can fill the "Hyperline ID" (`hyperline_id`) field in your Company object. This action ensures synchronization between both entities. We recommend to perform this operation prior to enabling the 'Sync in Hyperline' field. Failing to do so might result in duplicates, where an Company could sync to Hyperline without the `hyperline_id` value in the meantime.
## Disconnect
At any time, you can disconnect the integration by clicking on the **Disconnect** button located in the top-right corner of the HubSpot integration settings page.
Disconnecting will halt synchronization, but the custom fields and previously pushed data in HubSpot will remain intact; they won't be erased.
# Mollie
Learn how to collect payments through Mollie on Hyperline
## Prerequisites
You need to have a [Mollie account](https://my.mollie.com/dashboard), a [profile](https://my.mollie.com/dashboard/settings/profiles) with payment methods (Cards and/or SEPA Direct Debit) activated, and admin rights on Hyperline.
## Set-up
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** for Mollie
This will redirect you to the Mollie login page where you will have to enter your account credentials and click on **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 the Mollie status change to `Active` in the Payment tab.
## Payment methods
Now that you have successfully activated your Mollie account, it will be automatically designated as the primary payment gateway for the following transaction types:
* **Card transactions**: Whenever your customers make payments using credit or direct debit cards.
* **SEPA Direct Debit**: Mollie accepts payments in Europe and in UK.
## Customer information
Each time you've successfully created and billed a customer in Hyperline, the corresponding customer profile and payment details are automatically generated in your Mollie account.
This seamless integration ensures that your customer data and payments are synchronized between Hyperline and Mollie, streamlining your management of transactions and customer information.
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.
It is not possible to change your payment provider from Hyperline in autonomy.
If you wish to do so, please contact support at the following address:
[support@hyperline.co](mailto:support@hyperline.co)
# Integrations overview
Learn how Hyperline integrates with your tools stack
## Payment gateway
}
href="./stripe"
>
Use Stripe global payment processing platform as payment gateway.
}
href="./mollie"
>
Use Europe-based Mollie payment processor as payment gateway.
}
href="./gocardless"
>
Use GoCardless recurring payments as payment gateway.
## Data platform
}
href="./segment"
>
Push events collected by Segment to Hyperline.
}
href="./hightouch"
>
Sync data from databases, warehouses, spreadsheets, and more to Hyperline.
## Database
}
>
Automatically pull usage data from your MySQL database.
}
>
Automatically pull usage data from your PostgreSQL database.
}
>
Automatically pull usage data from your MongoDB database.
}
>
Automatically pull usage data from your BigQuery database.
}
>
Automatically pull usage data from your Snowflake database.
## 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.
## Customer Relationship Management (CRM)
}
href="./salesforce"
>
Bi-directionally sync your Hyperline customers, invoices, and subscriptions
data with your Salesforce instance, and fully manage your subscriptions
directly from your CRM.
}
href="./hubspot"
>
Bi-directionally sync your Hyperline customers data with your HubSpot
companies, and fully manage your subscriptions directly from your CRM.
## Accounting software
}
href="./pennylane"
>
Push your Hyperline invoices data and reconcile easily with Pennylane.
}
href="./xero"
>
Push your Hyperline invoices data to Xero. Use transactions from Hyperline
to update invoice status in Xero or vice-versa.
}
href="./exact-online"
>
Push your Hyperline invoices data to Exact Online. Use transactions from
Exact Online to update invoice status in Hyperline.
## Analytics
}
href="https://www.fincome.co?utm_source=hyperline"
>
Monitor and analyze Hyperline subscription revenue with Fincome.
# Pennylane
Learn how to push your invoicing data in your accounting tool
[Pennylane](https://www.pennylane.com) is a French financial and accounting management solution, available as SaaS. Hyperline has partnered with [Billy](https://heybilly.io) to offer a Pennylane integration.
## Prerequisites
You need to have a valid [Pennylane account](https://www.pennylane.com) and admin rights on Hyperline.
## Setup
You need to click on the "Se connecter avec Pennylane" button.
You will be redirected to Pennylane where you will be ask to enter your
credentials.
Then, select and authorize the company you want to use.
Afterward, you will be redirected back to Billy. You'll find a button to return to your Hyperline account.
Please note that the initial synchronization may take up to 24 hours to complete. Subsequent invoices will be automatically processed.
## Synchronization
When you connect your Pennylane account, Hyperline **automatically sends invoices** with their complete details (including line items and PDF file). Payment details are included, but only if the transaction was processed through Stripe or GoCardless, as per Pennylane's limitations.
Furthermore, whenever an invoice payment is created in Pennylane, corresponding **payment details are automatically created** on the Hyperline side. This facilitates **automatic reconciliation** and marks invoices as paid.
The synchronization delay may take up to 24 hours to take effect.
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 created on or after the connection date are synchronized. If you wish to push your previous data to Pennylane, please contact our support.
## Reconcile Hyperline and Pennylane customers
If you already have existing customers in Pennylane, Billy tries to match them with Hyperline customers as closely as possible using their name, address, email, and VAT number to push invoices data.
To have control over this mapping, you can click on the 'Voir les clients' button in their interface (after clicking on 'Settings' under Pennylane on the Hyperline integrations page), and you will have a dedicated UI to manually reconcile customers between Hyperline and Pennylane.
# Salesforce component
Learn how to benefit from Hyperline UIs right into your CRM
To seamlessly integrate your CRM usage with Hyperline's extensive UIs, flows, and capabilities, we offer a **native Salesforce component**. This component can be easily **inserted into your page layout**, ensuring a perfect blend of continued CRM usage for your revenue teams along with access to all Hyperline functionalities.
## Installation
Before installing the component, ensure that you have a Salesforce account connected to Hyperline. If not, please refer to the [setup guide](./overview#setup) for instructions.
This component is **automatically installed when you connect your account**.
To add it on your account's or opportunity's page:
1. Navigate to any account's or opportunity's page
2. Click on the top right menu and select 'Edit Page'
3. Search for the 'Morph...' component and drag-and-drop it to your page editor
4. Save (if it's your first time editing the page layout, you'll be prompted to Activate the view)
## Behavior
Once installed, this component can be used on both `Account` or `Opportunity` views.
From it, you can directly manage your Hyperline customer, create new quotes, assign subscriptions, and manage existing subscriptions for your Salesforce account.
When loaded on the CRM side, the component will **automatically create the first time (and if it doesn't exist yet) a corresponding user on Hyperline** using the user email address from the CRM and the ['Account manager' role](../../docs/get-started/configure-account#account-manager-role).
### Root object
You can control the component's behavior and determine whether the root object displaying the billing details for the customer is Account or Opportunity.
# Salesforce
Learn how to connect Salesforce with Hyperline
The Hyperline Salesforce integration offers seamless synchronization of your Salesforce accounts, quotes, subscriptions and invoices enabling effortless data transfer between Hyperline and your Salesforce instance without any manual effort or technical configuration.
Additionally, Hyperline provides you with a dedicated component that can be inserted into your Salesforce Account page, allowing you to assign and manage your subscriptions using the full-powered Hyperline UI directly within your CRM. [See more details](./component).
By doing so, the Hyperline integration empowers your business teams to **maintain Salesforce as their primary tool while capitalizing on the capabilities offered by Hyperline**.
## Prerequisites
You need to have a valid [Salesforce account](https://salesforce.com) and admin rights on Hyperline.
We recommend you to **experiment with a Developer Account** before going live. For this you can create a free [Salesforce Developer instance](https://developer.salesforce.com/signup), and use the [test mode](../../docs/get-started/sandbox) of your Hyperline account.
### 1. Permissions
Hyperline automatically sets up technical mechanisms in your Salesforce instance upon connection to enable notifications and benefit from real-time synchronization.
For this, we recommend using a user with the **System Administrator** profile when connecting your Salesforce instance. Otherwise, the user account used needs to have specific permissions.
The user needs to 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 settings can be updated via:
1. Click on the Gear icon (top-right corner) and click **Setup**.
2. Type "profiles" into the **Quick Find** box and select **Profiles**.
3. Click **Edit** against the **Profile** you wish to enable the permissions.
4. Add the corresponding permission boxes and click **Save**.
### 2. Custom objects
In order to synchronize data, Hyperline needs specific custom objects on your Salesforce instance. If the custom object doesn't exist, you won't be able to activate the synchronization for this entity and no data will be pushed to Salesforce.
| Entity | Salesforce Object Name |
| -------------------- | ------------------------------ |
| Quote | `HyperlineQuote` |
| Quote line item | `HyperlineQuoteLineItem` |
| Quote coupon | `HyperlineQuoteCoupon` |
| Subscription | `HyperlineSubscription` |
| Subscription product | `HyperlineSubscriptionProduct` |
| Subscription coupon | `HyperlineSubscriptionCoupon` |
| Invoice | `HyperlineInvoice` |
| Invoice line item | `HyperlineInvoiceLineItem` |
To create them:
1. Click on the Gear icon (top-right corner) and click **Setup**.
2. Type "object manager" into the **Quick Find** box and select **Object Manager**.
3. Click on the **Create** dropdown and **Custom Object**.
4. Fill the label, object name, and record name fields.
The **Object Name** field needs to match the expected object names given above. Other fields can be configured with the values that better fit for you.
5. Proceed the same way for all the objects you want to synchronize
We recommend you create the specific custom objects only for the data/entity you need to sync.
## Behavior
### Data synchronization
The integration enables synchronization between your **Salesforce Account** (standard object) and Hyperline **Customer**, and automatically push data from Hyperline to Salesforce related to **Quote**, **Subscription** and **Invoice** (custom objects).
Upon connecting your Salesforce instance, the integration will automatically configure the necessary custom fields in Salesforce on these objects.
More details about the fields meaning can be found in the API reference for [quote](../../api-reference/endpoints/quotes/get-quote), [subscription](../../api-reference/endpoints/subscriptions/get-subscription) and [invoice](../../api-reference/endpoints/invoices/get-invoice).
Deleting a Hyperline custom field created in Salesforce might break the integration.
You can also decide later in the [settings](#settings) which data you want to synchronize.
### Native card component
Additionally, we offer a [native Salesforce component](./component) that enables you to create and manage quotes, assign and manage subscriptions, as well as manage customer details and invoices, through Hyperline flows embedded in your CRM.
## Setup
You will be redirected to Salesforce where you will be ask to enter your
credentials.
The Salesforce card will be marked as 'Setup in progress'. **This operation can
take a few moments to complete** as we are preparing your Salesforce instance to
be ready to be integrated with Hyperline.
You can now access the **Settings** and start benefit from the integration.
Learn [how to install](./component) the Salesforce native component.
## Settings
Hyperline allows you to configure how you want to integration to behave.
You have the option to select which data and entities (customers, invoices, subscriptions) you want to synchronize.
Additionally, for customers you can decide to select the **synchronization direction** (one-way or bidirectional) and determine **which Salesforce accounts to import** into Hyperline (all accounts or specific/flagged ones).
### Flagged accounts
During integration setup, Hyperline will create a **Sync to Hyperline** checkbox field on the Salesforce Account object (`HyperlineSync__c` field).
When choosing the 'Only specific accounts' option, the integration will import and synchronize accounts where the **Sync to Hyperline** checkbox is selected, disregarding other accounts.
The option 'Only specific accounts' is selected by default, meaning that **we don't sync any Salesforce accounts by default**.
## Send Hyperline Customer to Salesforce
Customers created before connecting your Salesforce instance won't be automatically transferred to Salesforce during the initial setup.
You can choose to send them to Salesforce on a case-by-case basis.
To do this:
1. Navigate to your Hyperline customer page (Customers > Click on the customer).
2. Click on **Integrations** in the top-right corner.
3. Utilize the **Send to Salesforce** button.
This option will sync the customer details, and push its subscriptions and invoices.
Additionally, you can use the "Re-synchronize" button anytime for a customer already sent to Salesforce. This actions retriggers the synchronisation, pushing all associated details such as subscriptions and invoices.
## Reconcile Hyperline Customer and Salesforce Account
When a Hyperline Customer is created, a corresponding Account is created in Salesforce. Similarly, when a Salesforce Account is created or updated with the 'Sync in Hyperline' field enabled, a corresponding Customer is created in Hyperline. Both Customer and Account entities are then linked.
To associate an existing Customer (created before connecting your Salesforce instance) with an existing Account, you can fill the "Hyperline ID" (`HyperlineId__c`) field in your Account object. This action ensures synchronization between both entities. We recommend to perform this operation prior to enabling the 'Sync in Hyperline' field. Failing to do so might result in duplicates, where an Account could sync to Hyperline without the `HyperlineId__c` value in the meantime.
## Disconnect
At any time, you can disconnect the integration by clicking on the **Disconnect** button located in the top-right corner of the Salesforce integration settings page.
Disconnecting will halt synchronization, but the custom fields and previously pushed data in Salesforce will remain intact; they won't be erased.
# Segment
Learn how to ingest events from Segment
## 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 exemple of an additional property pushed to Hyperline.
```javascript
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
Learn how to send automated messages to Slack
## 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.
## Send messages from Hyperline to Slack
As an example, this guide sets up a workflow to send your current Annual Recurring Revenue (ARR) to a dedicated Slack channel every day.
For this, we'll create and use a [Zapier zap](./zapier) using the Hyperline app.
For this example, use the **Daily Analytics Ready** event. This event is send every day by Hyperline with the latest values.
Configure the action with the message you want to post.
You can use precomputed variables from Hyperline: ARR, MRR, active customers, revenue last 30 days, ARPA, etc. Those metrics can also be found in your [dashboard](../docs/analytics/dashboard) on Hyperline
Send and publish the Zap. That's it! 🎉
# Stripe
Learn how to collect payments through Stripe on Hyperline
## Set-up
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** for Stripe
This will redirect you to the Stripe login page where you will have to enter your account credentials and click on **Continue**.
Once the process is completed, you will see the Stripe status change to `Active` in the Payment tab.
## Payment methods
Now that you have successfully activated your Stripe account, it will be automatically designated as the primary payment gateway for the following transaction types:
* **Card transactions**: Whenever your customers make payments using credit or direct debit cards.
* **Direct Debit**: In cases where your customers use SEPA (Europe), ACH (US), or Bacs (UK) direct debit for payments.
## Customer information
Each time you've successfully created and billed a customer in Hyperline, the corresponding customer profile and payment details are automatically generated in your Stripe account.
This seamless integration ensures that your customer data and payments are synchronized between Hyperline and Stripe, streamlining your management of transactions and customer information.
If you already have a Stripe 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.
It is not possible to change your payment provider from Hyperline in autonomy.
If you wish to do so, please contact support at the following address:
[support@hyperline.co](mailto:support@hyperline.co)
# Xero
Learn how to push your invoicing data in your accounting tool
[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.
Invoices and credit notes will now be automatically sent to Xero.
## 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). Also, **new customers created in Hyperline will automatically be created** in Xero.
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.
### 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.
## 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*.
# Automate using Zapier
Overview about Zapier no-code integration
## 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 into 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 customer from CRM, sending invoices to your accounting software, or pushing using data into Hyperline.
[Learn more about the basics of using Zapier.](https://zapier.com/resources/guides/quick-start/automation-basics)
### 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
Zapier integration is in private access. To access the invite link, click the 'Connect' button on the Zapier card in the Settings > Integrations page of your Hyperline account.
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
4. You'll be ask to **Sign in**, and be prompted to add an API Key, which you can [learn how to generate in Hyperline here](https://doc.hyperline.co/docs/generating-an-api-key).
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#send-messages-from-hyperline-to-slack) to set up a Zap that sends your business metrics to a Slack channel regularly.