# Stream App API Documentation

> Complete API documentation and guides for Stream App

## Quick Start for LLMs

> Read this section first. It is written for AI agents and coding assistants integrating with Stream (streampay.sa), a Saudi payment platform for payment links, invoices, subscriptions, installments, coupons, and a hosted customer billing portal. Everything below is derived from the guides and API reference listed in the Table of Contents further down.

### Mental model (read before writing any code)

- **Default flow:** Your server -> `POST /api/v2/payment_links` -> redirect the customer (or embed) to the returned `url` -> Stream hosted checkout -> customer lands on your `success_redirect_url` / `failure_redirect_url` -> **you verify server-side** and/or receive webhooks.
- **Payment links are the recommended way to collect money.** The invoice and subscription create endpoints say so themselves: "For most use cases, use the Checkout/Payment Link API instead." Do not default to `POST /invoices` or `POST /subscriptions`.
- **Entities are created only after a successful payment.** A paid link creates:
  - one-time products -> an **invoice** + **payment(s)**
  - recurring products -> a **subscription** + initial **invoice** + **payment**
  - A failed attempt creates nothing (no invoice, payment, or subscription).
- **Recurrence lives on the product, not the link.** Create the product as one-time or recurring first, then reference it by `product_id`.
- **"Consumer" = "customer".** The API says consumer; the dashboard says customer. The consumer `id` is what you pass as `organization_consumer_id`.

### Base URL and authentication

- Base URL: `https://stream-app-service.streampay.sa/api/v2`
- Header on every request: `x-api-key: <base64("api-key:api-secret")>`
- Build the token: `echo -n 'api-key:api-secret' | base64`
- Create the key pair in the dashboard under Settings -> API Keys. The secret is shown at creation; store it like a password.
- Never put the key pair or token in browser/mobile code. All calls go through your backend.
- Optional header `x-branch-id: <uuid>` selects the branch. If omitted, the key's default branch is used. Keys only reach branches they were granted (or all branches if created with `is_all_branches`). Unauthorized branch -> 4xx.
- The MCP server uses a different header: `Authorization: Bearer <key>` (see MCP section).

### The five-step integration

**1. (Optional) Create a consumer** - `POST /api/v2/consumers`

Only `name` is required. Recommended: `phone_number` (E.164, e.g. `+966501234567`) or `email` so Stream can notify them, plus `external_id` for your own ID.

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/consumers \
  -H "x-api-key: $STREAM_TOKEN" -H "Content-Type: application/json" \
  -d '{"name":"Ahmad Ali","email":"ahmad@example.com","phone_number":"+966501234567","external_id":"cust_12345"}'
```

Returns the consumer; keep `id`. Duplicate phone/email -> `DUPLICATE_CONSUMER`: list consumers and reuse the existing `id`.

**2. Have a product** - `POST /api/v2/products` (one-time or recurring). Keep its `id`. A product can hold one active price per currency (`POST /products/{product_id}/prices` adds another currency).

**3. Create the payment link** - `POST /api/v2/payment_links`

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/payment_links \
  -H "x-api-key: $STREAM_TOKEN" -H "Content-Type: application/json" \
  -d '{
    "name": "Order 789",
    "items": [{"product_id": "PRODUCT_UUID", "quantity": 1}],
    "contact_information_type": "PHONE",
    "currency": "SAR",
    "max_number_of_payments": 1,
    "organization_consumer_id": "CONSUMER_UUID",
    "success_redirect_url": "https://example.com/success",
    "failure_redirect_url": "https://example.com/failure",
    "custom_metadata": {"order_id": "789"}
  }'
```

- Response includes `url`, `id`, `status` (e.g. `ACTIVE`), `amount` (decimal string like `"2500.00"`), `currency`. Redirect the customer to `url`.
- Omit `organization_consumer_id` for a shareable link: each payer enters their own details and a consumer is auto-created. Use a higher `max_number_of_payments` for these (docs example: 100).
- Set `organization_consumer_id` + `max_number_of_payments: 1` for a link tied to one known customer; the checkout skips the details form.

**4. Handle the redirect, then verify.** Stream appends query params (`status`, `message`, `payment_link_id`, and on success `invoice_id`, `payment_id`, `consent_id`, `organization_consumer_id`). **Do not trust them.** Fetch `GET /api/v2/invoices/{invoice_id}` and check `status`, `amount`, `currency` against your own order before fulfilling.

**5. Confirm asynchronously with webhooks** (recommended) and/or poll `GET /api/v2/payments/{id}` and `GET /api/v2/subscriptions/{id}`. The `status` field on the fetched object is the source of truth.

### Embedded checkout (instead of redirect)

Create the payment link on your server, pass only the `url` to the page:

```html
<div id="stream-checkout"></div>
<script src="https://stream-embed.streampay.sa/sdk/embed.min.js"></script>
<script>
  Stream.Checkout({ paymentLink: "URL_FROM_SERVER", container: "#stream-checkout" });
</script>
```

Optional: `minHeightPx` (280), `maxHeightPx` (920), `vhCapPx` (800), `vhFraction` (0.7). Apple Pay in embedded mode requires hosting Stream's domain-association file at `/.well-known/apple-developer-merchantid-domain-association` on your domain and contacting Stream support to register you.

### Webhooks in 60 seconds

- Register endpoints in the dashboard (Settings -> Webhooks) and pick event types. There is also a `POST /api/v2/webhooks` endpoint.
- Body shape: `event_type`, `entity_type`, `entity_id`, `entity_url`, `status`, `data`, `timestamp`. `data.metadata` echoes your `custom_metadata`.
- Headers: `X-Webhook-Event`, `X-Webhook-Entity-Type`, `X-Webhook-Entity-ID`, `X-Webhook-Timestamp`, `X-Webhook-Signature` (`t={timestamp},v1={signature}`).
- **Verify the signature:** HMAC-SHA256 over the exact string `"{timestamp}.{raw_request_body}"` using the webhook's `secret_key`, hex digest, constant-time compare to `v1`. Use the **raw bytes** of the body, not re-serialized JSON.

```python
import hmac, hashlib
def verify(secret: str, raw_body: bytes, header: str) -> bool:
    parts = dict(p.split("=", 1) for p in header.split(","))
    msg = f"{parts['t']}.{raw_body.decode()}"
    expected = hmac.new(secret.encode(), msg.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts["v1"])
```

- Respond with any 2xx quickly. Non-2xx triggers up to 5 retries at roughly 5 min, 30 min, 2 h, 6 h, 12 h; after that the delivery is marked failed.

### Testing

- Use the sandbox environment with Moyasar test cards. Name: any two words. Expiry: any future date. CVC: any 3 digits (4 for AMEX).
- Success: Mada `4201320111111010`, Visa `4111111111111111`, Mastercard `5421080101000000`, AMEX `340000000900000`.
- Insufficient funds: Mada `4201320000311101`, Visa `4123120001090000`, Mastercard `5457210001000092`, AMEX `340033000000000`.
- Generic decline: Mada `4201321234411220`, Visa `4123120001090109`.
- 3DS failure cases exist for Visa only (see Testing Cards guide).
- **Apple Pay in sandbox is driven by amount:** 200.00-300.00 SAR succeeds; 1000.00-1700.00 SAR hits assorted failures; **any other amount fails.** Do not use random amounts when testing Apple Pay.

---

## Tips and Tricks for LLMs

### Hard rules (violating these causes real bugs or lost money)

1. **Never mix one-time and recurring products in one payment link.** Split into two links tied to one internal order (store a shared order reference in `custom_metadata` or your DB), run them sequentially, and mark the order complete only after both succeed.
2. **Never fulfill an order from redirect query params alone.** Verify via `GET /invoices/{invoice_id}` (status, amount, currency) or a verified webhook.
3. **Never expose the key pair, the Base64 token, or a webhook `secret_key` client-side.** Embedded checkout only needs the link `url`.
4. **Always verify `X-Webhook-Signature`** and reject missing or invalid ones.
5. **Make webhook handlers idempotent.** Retries and multi-event flows mean you will see duplicates and out-of-order delivery. Key on `entity_id` + `event_type`.
6. **Do not use the redirect `id` param as a Stream ID.** It is the payment gateway's ID, for support debugging only. Use `payment_id` or `invoice_id`.

### Choosing the right endpoint

| Goal | Use |
|---|---|
| Collect a one-off payment | `POST /payment_links` with one-time product(s) |
| Start a subscription | `POST /payment_links` with recurring product(s) |
| Take payment via your own page | `POST /payment_links` + Embedded Checkout |
| Record money received offline (cash, bank transfer, etc.) | Create invoice, then `POST /payments/{id}/mark-paid` |
| Send customer to self-service billing | `POST /consumer_portal/sessions` |
| Charge a saved card on demand | `POST /payments/auto-charge-on-demand/{payment_id}` (restricted; only some orgs) |
| Pause billing | `POST /subscriptions/{id}/freeze` |
| Reverse a payment | `POST /payments/{id}/refund` |

### Consumers

- Check for an existing consumer before creating one (match by `external_id`, or `GET /consumers?search_term=...`) to avoid `DUPLICATE_CONSUMER`.
- Phone numbers must be E.164. `+966501234567`, not `0501234567`.
- `communication_methods` accepts `WHATSAPP`, `EMAIL`, `SMS`. Provide at least a phone or email, otherwise Stream cannot notify the customer.
- `DELETE` on a consumer is a soft delete (`is_deleted`).

### Payment links

- `contact_information_type` is `PHONE` or `EMAIL` (shown in docs examples) and controls which contact the checkout collects/uses for login.
- Put your own references in `custom_metadata` (arbitrary JSON, nested allowed). It comes back in webhook `data.metadata`, which is the cleanest way to join Stream events to your orders.
- `language=en` or `language=ar` as a query param on the link URL switches the checkout UI language only. Default is Arabic (or the org's configured language).
- Installments: pass `payment_methods: {"installment": true|false}` on the link to override the org default. Omit `payment_methods` to inherit the org setting.
- Link coupons and status are managed after creation with `PATCH`-style endpoints: Update Payment Link Coupons, Update Payment Link Status. To retire a link, update its status rather than deleting.
- Failed payment-link attempts produce **no** invoice/payment/subscription. To catch these, subscribe to `PAYMENT_LINK_PAY_ATTEMPT_FAILED`, not `PAYMENT_FAILED`.
- Redirect `status` values: `paid`, `pending`, `failed`, `failed_internal_error`. `failed` = definite decline, let the payer retry. `failed_internal_error` = unclear (timeout etc.); money may or may not have moved, so tell the payer to contact support and reconcile via the API before retrying or refunding.

### Installments

- Customers choose 2, 3, or 4 installments at checkout. **Installments are disabled automatically for recurring products.**
- Each installment is its own payment with its own due date. Default split period is monthly; it cannot be changed via API or dashboard (contact support).
- Minimum is **100 SAR per installment**. A 250 SAR order allows 2 installments but not 3. This minimum is also support-only to change.
- Rounding remainder goes to the **last** installment (999.98 / 3 -> 333.33, 333.33, 333.32).
- Webhooks: one `PAYMENT_SUCCEEDED` per installment paid; `INVOICE_COMPLETED` only fires once **every** installment is paid.
- Invoice-level installment settings are configured in the dashboard (invoices are created from the UI per the guide); payment-link defaults live in Settings -> Payment Settings.

### Subscriptions

- Cancel (`POST /subscriptions/{id}/cancel`): an `ACTIVE` subscription is **scheduled to cancel at period end** and stays active until then. `INACTIVE`, `TRIALING`, and `TRIAL_PENDING` subscriptions cancel **immediately**. Pass `cancel_related_invoices` to also cancel ongoing invoices. Undo a pending cancellation with the Uncancel endpoint.
- Update (`PUT /subscriptions/{id}`):
  - Items, subscription-level coupons, and recurring interval changes are **deferred to `current_period_end`** as a "pending change". The response includes `pending_change` with `next_invoice_preview` and a per-line diff.
  - If the next-cycle invoice already exists and is unpaid, it is cancelled and reissued at the new amount.
  - Description, auto-cancel cycle count (`until cycle number`), and payment-method overrides apply **immediately**.
  - You cannot change the payer. Cancel and create a new subscription instead.
  - Revert a scheduled change with `DELETE /subscriptions/{id}/pending-change` (returns 200 even if nothing was scheduled).
- Freeze pauses **invoice generation** for a date range and auto-resumes afterward. Freezes have their own list / update / delete endpoints.
- Renewal webhook sequence: `INVOICE_CREATED` -> `PAYMENT_SUCCEEDED` -> `INVOICE_COMPLETED` (plus `SUBSCRIPTION_CYCLE_RENEWED_SUCCESSFULLY`). On `INVOICE_COMPLETED`, check `subscription_id` in the payload to recognize a renewal. Failed automatic renewals emit `SUBSCRIPTION_CYCLE_RENEWAL_FAILED`.
- Plan-change event family: `SUBSCRIPTION_PLAN_CHANGE_SCHEDULED` (deferred), `..._CHANGED` (deferred change applied), `..._CHANGE_CANCELED`, `..._CHANGE_INVOICE_REISSUED`, and `SUBSCRIPTION_PLAN_UPDATED` (immediate change such as seats, add-ons, cycle count).

### Payments, refunds, and manual payments

- Multiple refunds per payment are supported. Partial refund -> payment status `PARTIALLY_REFUNDED` + `PAYMENT_PARTIALLY_REFUNDED`. Cumulative total reaches the payment amount -> `REFUNDED` + `PAYMENT_REFUNDED`. **The invoice status does not change on refund.** Subscribe to both refund events if you handle partials.
- Webhook refund payloads carry `amount_refunded` (this refund) and `total_amount_refunded` (cumulative).
- If a payment belongs to a shared charge, set `payment_is_part_of_related_set: true` on the refund request to spread the refund across the related payments in invoice order.
- Refund errors: `PAYMENT_REFUNDED_ALREADY` (duplicate, safe to treat as done), `PAYMENT_REFUNDED_FAILED` (processor failure, retryable later).
- `mark-paid` supports methods `CASH`, `BANK_TRANSFER`, `CARD`, `QURRAH`. Omit `amount` (or equal to payment amount) for full. A partial amount reduces the original payment, marks it `SUCCEEDED`, and creates a new `PENDING` `SPLIT_REMAINDER` payment for the rest; the remainder must be more than 1 in the payment currency, and partial is not allowed while `UNDER_REVIEW`. The invoice completes only when every payment is paid.
- Invoice in-place edits (`PATCH /invoices/{id}/inplace`) are for small changes such as description or scheduled date. A finalised invoice rejects actions with `INVOICE_FINALISED`.
- Products and coupons used by a finalized invoice cannot be edited (`PRODUCT_USED_IN_FINALIZED_INVOICE`, `COUPON_USED_IN_FINALIZED_INVOICE`). Create a new one instead. Deleting a product price is a soft delete (archive).

### Lists, pagination, and filtering

- Query params: `page` (starts at 1), `limit` (max 100), `sort_field` (default `created_at`), `sort_direction` (`asc`/`desc`, default `desc`), `search_term` (free text across names/IDs/descriptions).
- Array filters repeat the key: `statuses=PENDING&statuses=PROCESSING`. In Python `requests`, pass a list. Resource-specific filters exist (e.g. `invoice_id` on payments).
- Response: `{"data": [...], "pagination": {"total_count", "max_page", "current_page", "limit", "has_next_page", "has_previous_page"}}`. Loop on `has_next_page`; use `limit=100` to minimize calls. Note: the guide describes `total_count` as the count on the current page, so rely on `has_next_page` / `max_page` rather than assuming it is a global total.
- When you apply filters, pagination metadata reflects the filtered set.

### Errors

- Handled errors use `{"error": {"code": "...", "message": "...", "additional_info": "..."}}`. Branch on `code`, never on `message`.
- Validation failures (HTTP 422) can instead return FastAPI-style `{"detail": [{"loc": [...], "msg": "...", "type": "..."}]}`. Handle **both** shapes.
- Status mapping: 400 bad request, 401 unauthorized, 403 forbidden / permission, 404 not found, 410 gone, 422 unprocessable or duplicate.
- Codes you should handle explicitly: `INVALID_PARAMETERS`, `DUPLICATE_CONSUMER`, `DUPLICATE_PAYMENT`, `PHONE_ALREADY_REGISTERED`, `INVOICE_FINALISED`, `PAYMENT_REFUNDED_ALREADY`, `PAYMENT_REFUNDED_FAILED`, `PERMISSION_FORBIDDEN`, `PRODUCT_USED_IN_FINALIZED_INVOICE`, `COUPON_USED_IN_FINALIZED_INVOICE`, `STREAM_ERROR`, `STREAM_UNKNOWN_ERROR`. On `STREAM_ERROR` / `STREAM_UNKNOWN_ERROR`, log `additional_info` and escalate to support rather than blind-retrying a money-moving call.

### Customer portal

- Backend calls `POST /api/v2/consumer_portal/sessions` with `organization_consumer_id` (HTTP 201 -> `url`). The token is **short-lived and single-use**, so generate a fresh session each time the customer clicks "Manage billing". Do not cache or email the URL.
- Optional body fields: `return_url` (a back-link hint only; Stream does **not** auto-redirect) and `subscription_id` (open directly on one subscription). The URL can be used for a redirect or an iframe.
- The portal can only offer plan switches and add-ons if the dashboard catalog is configured: **product switch groups** (only members of the same group can replace each other; mixed MONTHLY/YEARLY allowed) and **add-on mappings** (which base products make an add-on eligible), plus the Customer Portal permission toggles. If the portal shows nothing to switch, the cause is configuration, not the API.
- Subscriptions with subscription-level coupons generally cannot be edited from the portal. Proration is computed by Stream and excludes the current day; do not reimplement it.

### Handling your own customer notifications

By default Stream notifies consumers (confirmations, invoice updates, subscription changes). To own all messaging: (1) ask Stream support to enable the setting that blocks default consumer notifications, (2) use webhooks for event-driven messages, (3) poll the List Payments / Invoices / Subscriptions endpoints with filters for scheduled messages like reminders and overdue notices. You cannot self-serve step 1.

### Branches

Requests are scoped to one branch. Use `x-branch-id` to target a branch; without it the key's default branch is used. If resources seem "missing", you are probably querying the wrong branch.

### MCP server (for AI agents)

- Hosted at `https://mcp.streampay.sa/mcp`. Config key `"url"`, plus `"headers": {"Authorization": "Bearer <key>"}` for operational tools.
- The resource `stream://docs/openapi` exposes the **full, current OpenAPI spec and needs no API key**. Read it before guessing request fields; this documentation set links endpoint pages whose rendered Markdown does not include the full request/response schemas.
- Tool groups: payment links, customers, products, coupons, invoices (create, list, get, send, void), payments (list, get, refund). Tool names (e.g. `create_payment_link`, `refund_payment`) are not the same as REST paths. Note that some MCP descriptions (for example ZATCA-compliant invoices) are tool-level descriptions, so confirm behavior in the OpenAPI spec.

### SDKs

TypeScript SDK (`StreamSDK.init(process.env.STREAM_API_KEY!)`) and an Express SDK (a `Checkout({ apiKey, ... })` route handler). Full docs live in their GitHub repositories, linked at the bottom of the Table of Contents. SDKs take the same `x-api-key` token.

### Gotchas and doc inconsistencies to be aware of

- **The Installments link in the Table of Contents is malformed** (`https://docs.streampay.sa/docs/guides/installments.md`). The correct path is most likely `https://docs.streampay.sa/docs/guides/installments.md`. The installment facts above come from the same guide as published in the developer-docs full export.
- The Authentication guide says "HTTP Basic Authentication" but the actual mechanism is the **`x-api-key` header carrying the Base64 token**, not an `Authorization: Basic` header. Use `x-api-key`.
- The Authentication guide's curl example posts `{"name","amount"}` to `/payment_links`; that is a placeholder. A real payment link requires `items` with `product_id`s, as in the Getting Started examples.
- The Pagination guide's example hits `/api/v2/customers`; the real resource path is **`/api/v2/consumers`**.
- The Branches guide example calls `/api/v2/user`; the identity endpoint listed in the API reference is "Get User And Organization Info" (`/api/v2/me`-style). Check the reference for the exact path.
- The branch create path may differ between exports (`/api/v2/branch` vs the public reference's "Create Branch"). Confirm in the OpenAPI spec.
- Sandbox vs production: the docs reference a sandbox environment and test cards but do not publish a separate sandbox base URL. Use the sandbox-mode key/dashboard Stream gives you, or ask support, rather than inventing a hostname.
- Amounts in responses appear as **decimal strings in SAR** (e.g. `"2500.00"`). Compare as decimals, not floats.
- When unsure about a field name, enum value, or required property, do not guess. Read `stream://docs/openapi` via the MCP server or the endpoint's page in the Table of Contents.

### Suggested agent workflow for "add Stream payments to my app"

1. Ask which flow: one-time, subscription, installments, or embedded/redirect. Confirm whether the cart ever mixes one-time and recurring items.
2. Create (or look up) the product(s), and the consumer if the customer is known.
3. Create the payment link from the backend; return only `url` to the client.
4. Implement the success/failure routes: read `invoice_id`, call `GET /invoices/{id}`, check `status`/`amount`/`currency`, then fulfill.
5. Implement the webhook endpoint with raw-body signature verification, idempotency, and fast 2xx. Subscribe to at minimum `PAYMENT_SUCCEEDED`, `PAYMENT_FAILED`, `INVOICE_COMPLETED`, plus `PAYMENT_PARTIALLY_REFUNDED` / `PAYMENT_REFUNDED` and the `SUBSCRIPTION_*` events if you sell subscriptions.
6. Test with the sandbox cards above (and Apple Pay amount ranges) before going live.

---

## Getting Started with Stream


Welcome to **Stream**, your partner for seamless and secure online payments.
This guide walks you through the essentials to integrate our **checkout experience** into your website or app.

The full payment flow:

> Your site → Stream Secure Checkout → Redirect to your success or failure page

:::tip Using an AI assistant?
Point it at [`/llms.txt`](pathname:///llms.txt) for an LLM-friendly index with integration instructions (full content in [`/llms-full.txt`](pathname:///llms-full.txt)). Any docs page is also available as Markdown by appending `.md` to its URL (for example `/webhooks.md`) or by requesting it with `Accept: text/markdown`. The [MCP server](/mcp-server) gives agents direct tool access.
:::

## Overview: Integration Steps

1. [Authorization](#authorization)
1. [Create a Customer (Consumer)](#create-a-customer-consumer)
1. [Creating a Payment Link](#creating-a-payment-link)
1. [Handling Payment Redirects](#handling-payment-redirects)
1. [Retrieve Payment or Subscription Status](#retrieve-payment-or-subscription-status)

---

## Authorization

All API calls require authentication using your Stream API Key Pair (`api-key` + `api-secret`).

1. Navigate to Stream [API Settings](https://app.streampay.sa/settings/api-keys).
1. Click **Create Key Pair** and store the keys securely.

To authenticate your requests, encode your API key and secret as a Base64-encoded token. Use the following command (replace `api-key` and `api-secret` with your actual values):

```bash
echo -n 'api-key:api-secret' | base64
```

Include this Base64-encoded token in the `x-api-key` authentication header for all API requests:

```
x-api-key: <your-base64-token>
```

---

## Create a Customer (Consumer)

Before you can generate a payment link for a specific customer, you must first create a customer (consumer) record in Stream. This step registers the customer in your organization and returns a unique identifier that you'll use to tie payment links to that customer.

### Why Create a Customer First?

- **Personalized checkout**: When you attach a customer to a payment link, Stream skips the customer-details form during checkout because the customer's information is already known.
- **Customer tracking**: Every invoice, subscription, and payment is linked back to the customer record, making reconciliation straightforward.
- **Repeat billing**: For recurring products, the customer record is required to manage the subscription lifecycle.

### Step 1: Prepare the Customer Data

Decide which contact fields to include. The only **required** field is `name`. All other fields are optional but recommended for a complete integration.

| Field                     | Type       | Required | Description                                                                 |
| ------------------------- | ---------- | -------- | --------------------------------------------------------------------------- |
| `name`                    | string     | **Yes**  | Full name of the customer                                                   |
| `phone_number`            | string     | No       | Phone number (E.164 format, e.g., `+966501234567`)                          |
| `email`                   | string     | No       | Email address                                                               |
| `external_id`             | string     | No       | Your own system's ID for this customer (useful for cross-referencing)        |
| `iban`                    | string     | No       | IBAN (max 34 characters) for bank-related operations                        |
| `alias`                   | string     | No       | Short alias or display name                                                 |
| `comment`                 | string     | No       | Internal notes about the customer                                           |
| `preferred_language`      | string     | No       | Customer's preferred language for communications                            |
| `communication_methods`   | string[]   | No       | Preferred channels: `WHATSAPP`, `EMAIL`, `SMS` (can include multiple)       |

> **Tip**: Always include at least `phone_number` or `email` so Stream can send payment notifications to the customer.

### Step 2: Send the Create Request

- **Endpoint**: `POST /api/v2/consumers`
- **Auth**: `x-api-key: <base64(api-key:api-secret)>`

**cURL example:**

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/consumers \
  -H "x-api-key: <your-base64-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Ahmad Ali",
    "email": "ahmad@example.com",
    "phone_number": "+966501234567",
    "external_id": "cust_12345",
    "communication_methods": ["EMAIL", "SMS"]
  }'
```

### Step 3: Handle the Response

A successful response (`200 OK`) returns the full customer record. The most important field is `id` — this is the `organization_consumer_id` you'll use when creating payment links.

**Example response (simplified):**

```json
{
  "id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "name": "Ahmad Ali",
  "email": "ahmad@example.com",
  "phone_number": "+966501234567",
  "external_id": "cust_12345",
  "is_deleted": false,
  "created_at": "2025-06-15T10:30:00Z",
  "communication_methods": ["EMAIL", "SMS"],
  "preferred_language": "ar"
}
```

> See the full response schema in the [Create Consumer API Reference](/api/v2-consumers-create).

### Step 4: Handle Errors

If the request fails validation, the API returns a `422` status with an array of error details:

```json
{
  "detail": [
    {
      "loc": ["body", "name"],
      "msg": "Field required",
      "type": "missing"
    }
  ]
}
```

Each object in the `detail` array contains `type` (error kind), `loc` (field path), and `msg` (human-readable message). Common error scenarios:

| `type` / Scenario | `loc` | `msg` (example) | Resolution |
| ------------------ | ----- | ---------------- | ---------- |
| `missing` | `["body", "name"]` | `"Field required"` | Include the required `name` field in the request body |
| `value_error` | `["body", "phone_number"]` | `"value is not a valid phone number"` | Use E.164 format: `+<country-code><number>` (e.g., `+966501234567`) |
| `value_error` | `["body", "email"]` | `"value is not a valid email address"` | Provide a properly formatted email address |

The API may also return a non-validation error with a top-level error code instead of a `detail` array. The most common one:

| Error Code | Cause | Resolution |
| ---------- | ----- | ---------- |
| `DUPLICATE_CONSUMER` | A consumer with the same phone number or email already exists | Use [Get All Consumers](/api/v2-consumers-list) to find the existing record and use its `id` instead |

> **Tip**: Always check for an existing consumer before creating a new one to avoid `DUPLICATE_CONSUMER` errors. You can list consumers with `GET /api/v2/consumers` or match by `external_id` in your own system.

### Step 5: Use the Customer ID in a Payment Link

Once you have the customer `id` from the response, pass it as `organization_consumer_id` when [creating a payment link](#creating-a-payment-link). This ties the payment to the specific customer and skips the customer-details step at checkout.

> **Note**: If you omit `organization_consumer_id`, the payment link will collect customer details during checkout and create a new customer record automatically. Use this approach for general-purpose links shared with multiple customers.

### Managing Existing Customers

After creating customers, you can manage them with these endpoints. The `{consumer_id}` path parameter is the `id` returned by `POST /api/v2/consumers` — the same value you pass as `organization_consumer_id` when creating payment links.

| Action     | Method   | Endpoint                             | API Reference                         |
| ---------- | -------- | ------------------------------------ | ------------------------------------- |
| List all   | `GET`    | `/api/v2/consumers`                  | [Get All Consumers](/api/v2-consumers-list)   |
| Get one    | `GET`    | `/api/v2/consumers/{consumer_id}`    | [Get Consumer](/api/v2-consumers-get)         |
| Delete     | `DELETE` | `/api/v2/consumers/{consumer_id}`    | [Delete Consumer](/api/v2-consumers-delete)   |

Before creating a new customer, you can check for an existing record by listing consumers or using your `external_id` to avoid duplicates.

---

## Creating a Payment Link

Create a checkout/payment link using the [Payment Link API](/api/v2-payment-links-create).

- **Endpoint**: `POST /api/v2/payment_links`
- **Auth**: `x-api-key: <base64(api-key:api-secret)>`

Payment links redirect customers to Stream's secure checkout page. They support two use cases:

1. **For multiple customers**: Create a general-purpose link that anyone can use. Each customer enters their information during checkout. Perfect for events, group purchases, or public product sales.

1. **For one specific customer**: Create a link tied to a specific customer by setting `organization_consumer_id`. The checkout page will skip the customer details collection step since the customer information is already known. Use this when charging a known customer.

When a customer pays through a payment link, the behavior depends on the product types you include:

- **One-time products**: When the payment link is paid, Stream creates an invoice with the products. The payment can be split into multiple installments, but the product itself is a one-time purchase (not recurring).

- **Recurring products**: When the payment link is paid, Stream creates a subscription (with recurring billing) and an initial invoice. The subscription will automatically generate invoices for future billing cycles based on the recurring interval.

> **Important**: You cannot mix one-time and recurring products in the same payment link. All products must be either one-time or all must be recurring.

### Strategy: Single Order with Both One-Time + Recurring Items

If a cart contains both one-time and recurring products, split it into **two payment links** and guide the customer through a short two-step checkout. This keeps each payment link valid while preserving a single “order” in your system.

**General approach**

- Create one link that contains only **one-time** items and a separate link that contains only **recurring** items.
- Treat both links as part of the same internal order (e.g., by storing a shared order reference in metadata or your database).
- Present the links sequentially (or based on your business preference) so the customer completes both steps.

- Confirm both outcomes via your normal status checks or webhooks before marking the order as complete.

> **Note**: You'll need existing products to create payment links. See the [Products API](/api/v2-products-create) for creating products. If you want to link a payment to a specific customer, you'll also need to create a customer first using the [Consumers API](/api/v2-consumers-create).

### Example: Payment Link for Multiple Customers

This example creates a payment link that can be used by multiple different customers. Each customer will enter their information when they visit the checkout page.

```json
{
  "name": "Event Registration",
  "description": "Annual conference registration",
  "items": [
    {
      "product_id": "your-product-uuid-here",
      "quantity": 1
    }
  ],
  "contact_information_type": "PHONE",
  "currency": "SAR",
  "max_number_of_payments": 100,
  "success_redirect_url": "https://example.com/success",
  "failure_redirect_url": "https://example.com/failure",
  "custom_metadata": {
    "event_id": "conf_2025",
    "campaign_source": "email_marketing"
  }
}
```

**Code snippet (general-purpose, one-time product):**

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/payment_links \
  -H "x-api-key: <your-base64-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Event Registration",
    "description": "Annual conference registration",
    "items": [
      { "product_id": "your-product-uuid-here", "quantity": 1 }
    ],
    "contact_information_type": "PHONE",
    "currency": "SAR",
    "max_number_of_payments": 100,
    "success_redirect_url": "https://example.com/success",
    "failure_redirect_url": "https://example.com/failure"
  }'
```

> **Note**: `organization_consumer_id` is **not set**, so the link will collect customer information from each payer.

### Example: Payment Link for One Specific Customer

This example creates a payment link for a specific customer. When you specify `organization_consumer_id`, the checkout page will skip the customer details collection step since the customer information is already known.

```json
{
  "name": "Product Purchase",
  "description": "One-time payment for product order",
  "items": [
    {
      "product_id": "your-product-uuid-here",
      "quantity": 1
    }
  ],
  "contact_information_type": "PHONE",
  "currency": "SAR",
  "max_number_of_payments": 1,
  "organization_consumer_id": "your-customer-uuid-here",
  "success_redirect_url": "https://example.com/success",
  "failure_redirect_url": "https://example.com/failure",
  "custom_metadata": {
    "customer_id": "cust_12345",
    "order_id": "order_789"
  }
}
```

> **Note**: `organization_consumer_id` **is set**, so the checkout page will skip the customer details collection step. The `max_number_of_payments` is typically set to `1` when targeting a specific customer.

### Example: Payment Link for a Recurring Product (New Subscription)

Use this when you want a customer to start a subscription from checkout. The product itself must be **recurring** (e.g., monthly), which is configured when you create the product via the [Products API](/api/v2-products-create). The payment link request is **the same endpoint** as one-time links:

- **Endpoint**: `POST /api/v2/payment_links`
- **Auth**: `x-api-key: <base64(api-key:api-secret)>`

When the customer completes payment, Stream automatically creates a **subscription** and an **initial invoice**. Future invoices are generated based on the product's recurring interval. You can retrieve the created subscription via the [Subscriptions API](/api/v2-subscriptions-list).

```json
{
  "name": "Premium Plan Subscription",
  "description": "Monthly recurring plan",
  "items": [
    {
      "product_id": "recurring-product-uuid-here",
      "quantity": 1
    }
  ],
  "contact_information_type": "EMAIL",
  "currency": "SAR",
  "max_number_of_payments": 1,
  "organization_consumer_id": "your-customer-uuid-here",
  "success_redirect_url": "https://example.com/success",
  "failure_redirect_url": "https://example.com/failure",
  "custom_metadata": {
    "plan": "premium_monthly",
    "source": "pricing_page"
  }
}
```

**cURL example:**

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/payment_links \
  -H "x-api-key: <your-base64-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Premium Plan Subscription",
    "description": "Monthly recurring plan",
    "items": [
      { "product_id": "recurring-product-uuid-here", "quantity": 1 }
    ],
    "contact_information_type": "EMAIL",
    "currency": "SAR",
    "max_number_of_payments": 1,
    "organization_consumer_id": "your-customer-uuid-here",
    "success_redirect_url": "https://example.com/success",
    "failure_redirect_url": "https://example.com/failure"
  }'
```

> **Notes**:
> - The recurring behavior is defined on the **product**, not the payment link.
> - Do not mix one-time and recurring products in the same payment link.
> - If `organization_consumer_id` is omitted, the checkout will collect customer details and the subscription will be created for that newly created customer.

### Response

The API returns a payment link object. The most important field is `url`, which you'll redirect customers to:

```json
{
  "url": "https://streampay.sa/s/...",
  "id": "payment-link-uuid",
  "status": "ACTIVE",
  "amount": "2500.00",
  "currency": "SAR"
}
```

> **Note**: This response has been simplified for brevity. The full response includes additional fields like `items`, `custom_metadata`, `success_redirect_url`, and more. See the [API Reference](/api/v2-payment-links-create) for the complete response schema.

Redirect your customer to the `url` field to complete the payment securely.

### Checkout Language

The checkout page language can be overridden using the `language`
query parameter on the payment link URL. By default, the checkout page is displayed to the customer in the language the organization is configured in.

Example:

```
https://streampay.sa/s/...?...&language=en
```

Or:

```
https://streampay.sa/s/...?language=en
```

Supported values:

| Value | Language |
| ------- | ---------- |
| `ar` | Arabic (default) |
| `en` | English |

> Note: This parameter only affects the hosted checkout page UI language. Data is not affected.

---

## Handling Payment Redirects

After checkout, Stream can redirect the customer to your `success_redirect_url` or `failure_redirect_url` (if provided) with payment information as query parameters. If you omit these URLs, Stream will show its hosted success/failure pages instead.

### Redirect URL Examples

**Success redirect:**

```
https://example.com/success?id=...&invoice_id=...&status=paid&message=APPROVED
```

**Failure redirect:**

```
https://example.com/failure?payment_link_id=...&id=...&status=failed&message=...
```

### Query Parameters

All redirects include these parameters:

| Parameter         | Description                                                                                                                                                                    |
| ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `id`              | Payment gateway payment ID - for internal use only. Useful for debugging when contacting support, but cannot be used in Stream APIs. Use `payment_id` or `invoice_id` instead. |
| `payment_link_id` | UUID of the payment link that was used                                                                                                                                         |
| `status`          | Payment status: `paid`, `pending`, `failed`, or `failed_internal_error`                                                                                                        |
| `message`         | Status message from the gateway (e.g., `APPROVED`, `DECLINED`, `The customer’s bank has declined.`)                                                                            |
| `login_method`    | Consumer's preferred login method: `PHONE` or `EMAIL`                                                                                                                          |

:::info

- **`status=failed`**: A definite rejection (e.g. insufficient funds, card declined). The payer should **retry** after addressing the issue.
- **`status=failed_internal_error`**: Transient or unclear failures (e.g. timeouts). The payer should **contact support**; money may or may not have been taken.

:::

**Additional parameters on success only:**

| Parameter                  | Description                                                                                            |
| -------------------------- | ------------------------------------------------------------------------------------------------------ |
| `invoice_id`               | UUID of the invoice created from the payment link                                                      |
| `consent_id`               | UUID of the payment consent/authorization                                                              |
| `payment_id`               | UUID of the payment record in Stream's system                                                          |
| `organization_consumer_id` | UUID of the customer who made the payment (newly created if not set when the payment link was created) |

> **Note**: On failure, the additional parameters above are not included since the payment did not complete successfully.

### Processing the Redirect

Parse the query parameters from the redirect URL on your server.

:::danger

**Important:** Always validate the payment server-side before accepting the order or completing any business action. Fetch the invoice using the `invoice_id` from the redirect with the [Invoice API](/api/v2-invoices-get), and verify its `status`, `amount`, and `currency` match your expectations. This server-side verification ensures the payment is legitimate before updating your system state. Never trust redirect parameters alone, always verify through our API.

:::

---

## Retrieve Payment or Subscription Status

Use the **Get Payment** and **Get Subscription** endpoints to fetch the latest status programmatically.

**Endpoints**

- **Payment status:** `GET /api/v2/payments/{payment_id}` → [Payments API](/api/v2-payments-get)
- **Subscription status:** `GET /api/v2/subscriptions/{subscription_id}` → [Subscriptions API](/api/v2-subscriptions-get)

**Authentication**

Use the same `x-api-key` header described in [Authorization](#authorization):

```
x-api-key: <base64(api-key:api-secret)>
```

### Example: Fetch Payment Status (cURL)

```bash
curl -X GET https://stream-app-service.streampay.sa/api/v2/payments/your-payment-id \
  -H "x-api-key: <your-base64-token>"
```

### Example: Fetch Subscription Status (cURL)

```bash
curl -X GET https://stream-app-service.streampay.sa/api/v2/subscriptions/your-subscription-id \
  -H "x-api-key: <your-base64-token>"
```

### Example: Fetch Status in JavaScript (Node.js)

```js
const API_BASE = "https://stream-app-service.streampay.sa/api/v2";
const API_KEY = process.env.STREAM_API_KEY_BASE64; // base64(api-key:api-secret)

async function getPaymentStatus(paymentId) {
  const res = await fetch(`${API_BASE}/payments/${paymentId}`, {
    headers: { "x-api-key": API_KEY }
  });
  if (!res.ok) throw new Error(`Payment fetch failed: ${res.status}`);
  const payment = await res.json();
  return payment.status;
}

async function getSubscriptionStatus(subscriptionId) {
  const res = await fetch(`${API_BASE}/subscriptions/${subscriptionId}`, {
    headers: { "x-api-key": API_KEY }
  });
  if (!res.ok) throw new Error(`Subscription fetch failed: ${res.status}`);
  const subscription = await res.json();
  return subscription.status;
}
```

> **Tip**: The `status` field in each response is the source of truth for the current state. See the full response schema in the linked API reference pages.

---

## Pagination & Filtering


## Pagination

Pagination helps you efficiently navigate, sort, and filter large collections of data without fetching everything at once.
This is especially useful for endpoints like:

- [List Payments](/api/v2-payments-list)
- [List Products](/api/v2-products-list)
- [List Invoices](/api/v2-invoices-list)
- [List Subscriptions](/api/v2-subscriptions-list)

## Filtering

Filtering is another way to efficiently navigate and filter large collections of data without fetching everything at once.

Whenever pagination is applied, then so is filtering.

Filtering allows you to filter your fetched objects through specific features or conditions like queries.

Whenever an endpoint may return many items, Stream uses a consistent pagination and filtering structure across all list responses.

---

## Request Parameters

### Pagination Parameters

You can control pagination using the following query parameters:

| Parameter        | Type   | Description                                                                 |
|------------------|--------|-----------------------------------------------------------------------------|
| `page`           | int    | Page number starting from **1**.                                            |
| `limit`          | int    | Number of items per page. Maximum: **100**.                                |
| `sort_field`     | string | Field used to sort the results.                                             |
| `sort_direction` | string | Either `"asc"` or `"desc"` depending on sorting direction.                  |

By default, `sort_field` is `created_at` and `sort_direction` is `desc`.

```
GET api/v2/products?page=1&limit=20&sort_field=created_at&sort_direction=desc
```

---

### Filtering Parameters

Filtering allows you to query objects based on specific attributes. When you apply filters, the `pagination` metadata in the response will reflect the total count of items *matching* your filter, not the total database count.

| Parameter     | Type             | Description                                                                                       |
|---------------|------------------|---------------------------------------------------------------------------------------------------|
| `search_term` | `string`         | A generic query string. The API searches relevant fields (e.g., names, IDs, descriptions) for matches. |
| **Field Specific**| `string` / `array` | Specific attributes depending on the resource (e.g., `invoice_id`, `statuses`, `currency`).       |

**Note on Array Filters:**
Some parameters, like `statuses`, accept multiple values. In the query string, this appears as repeating keys:
`statuses=PENDING&statuses=PROCESSING`

For example, the [List Payments](/api/v2-payments-list) endpoint takes filtering queries like `invoice_id` and `statuses` to filter down the returned payments.

Example query:

```
GET api/v2/payments?page=1&limit=20&invoice_id=73b89d47-1bb1-443c-9a4c-f0ee23e22191&statuses=PENDING&statuses=PROCESSING
```

---

## Pagination Response Structure

Paginated responses include a `pagination` object that provides metadata about the current, previous, and next pages.

| Field              | Description                                                                 |
|--------------------|-----------------------------------------------------------------------------|
| `total_count`      | Number of objects returned in the current page.                             |
| `max_page`         | Maximum page number available.                                              |
| `current_page`     | Page you are currently on.                                                  |
| `limit`            | Page size (echoes your request, capped at 100).                             |
| `has_next_page`    | Whether another page exists after this one.                                 |
| `has_previous_page`| Whether a page exists before this one.                                      |

Example response snippet:

```
{
  "data": [...],
  "pagination": {
    "total_count": 20,
    "max_page": 12,
    "current_page": 1,
    "limit": 20,
    "has_next_page": true,
    "has_previous_page": false
  }
}
```

---

## Examples (Python)

Below are practical examples using Python's `requests` library.

### 1. Basic Pagination

Fetching the first page of results with a custom limit.

```python

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://stream-app-service.streampay.sa/api/v2/products"

response = requests.get(
    BASE_URL,
    headers={"x-api-key": API_KEY},
    params={
        "page": 1,
        "limit": 20
    }
)

data = response.json()
print(f"Showing page {data['pagination']['current_page']} of {data['pagination']['max_page']}")
```

### 2. Global Search Filtering

Using the `search_term` to find items matching a specific string (e.g., a customer name or partial ID).

```python

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://stream-app-service.streampay.sa/api/v2/customers"

response = requests.get(
    BASE_URL,
    headers={"x-api-key": API_KEY},
    params={
        "search_term": "JOHN DOE", # Searches for customer with that name
        "limit": 10
    }
)

results = response.json()["data"]
print(f"Found {len(results)} matches for 'Al-Faisaliah'")
```

### 3. Advanced Filtering (Lists & Specific Fields)

Filtering by a specific `invoice_id` and multiple `statuses`. Note how the list of statuses is passed to the `params` dictionary.

```python

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://stream-app-service.streampay.sa/api/v2/payments"

# To filter by multiple statuses, pass them as a list
payload_filters = {
    "page": 1,
    "limit": 50,
    "invoice_id": "73b89d47-1bb1-443c-9a4c-f0ee23e22191",
    "statuses": ["PENDING", "PROCESSING"] # Requests handles this as statuses=PENDING&statuses=PROCESSING
}

response = requests.get(
    BASE_URL,
    headers={"x-api-key": API_KEY},
    params=payload_filters
)

payments = response.json()["data"]
for p in payments:
    print(f"Payment ID: {p['id']} | Status: {p['status']}")
```

### 4. Iterating Through All Pages

A robust pattern to fetch every item available.

```python

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://stream-app-service.streampay.sa/api/v2/products"

page = 1
all_products = []

while True:
    response = requests.get(
        BASE_URL,
                headers={"x-api-key": API_KEY},
        params={"page": page, "limit": 100} # Maximize limit to reduce requests
    )

    body = response.json()
    all_products.extend(body["data"])

    # Stop if there are no more pages
    if not body["pagination"]["has_next_page"]:
        break

    page += 1

print(f"Successfully fetched {len(all_products)} products.")
```

---

---

## Webhooks


Webhooks allow your platform to receive real-time notifications from Stream when key events occur—such as payment successes, failures, or cancellations. This enables you to react to events programmatically, such as updating your database, sending notifications, or triggering internal workflows.

Stream's webhook infrastructure is designed for reliability and includes features like:

- Event-specific subscriptions
- Secure payload signing
- Delivery tracking for observability
- Automatic retries using exponential backoff

## Creating a Webhook

To create or manage your webhooks, go to [Webhook Settings](https://app.streampay.sa/settings/webhooks).

There you can:
- Register a new webhook endpoint
- Select which event types you want to subscribe to
- Enable, disable, or delete webhooks

## Webhook Flow Logic

Understanding which webhooks are sent in different scenarios:

### Single Payment Succeeds

When a single payment succeeds:

1. `PAYMENT_SUCCEEDED` webhook is sent (one per payment)
2. If the payment completes the invoice (all payments are now paid), `INVOICE_COMPLETED` webhook is also sent

Example: Invoice with 1 payment of 1000 SAR
- Payment succeeds → `PAYMENT_SUCCEEDED` webhook
- Invoice completes → `INVOICE_COMPLETED` webhook

### Multiple Payments Succeed (Installments)

When multiple payments succeed together (e.g., installments):

1. `PAYMENT_SUCCEEDED` webhook is sent for each payment that succeeded (one per payment)
2. If all payments complete the invoice, `INVOICE_COMPLETED` webhook is also sent

Example: Invoice with 3 payments of 1000 SAR each
- Payments 1, 2, 3 all succeed together:
  - `PAYMENT_SUCCEEDED` webhook for payment_1
  - `PAYMENT_SUCCEEDED` webhook for payment_2
  - `PAYMENT_SUCCEEDED` webhook for payment_3
  - `INVOICE_COMPLETED` webhook

Example: Invoice with 5 payments, payments 1-3 succeed together:
- `PAYMENT_SUCCEEDED` webhook for payment_1
- `PAYMENT_SUCCEEDED` webhook for payment_2
- `PAYMENT_SUCCEEDED` webhook for payment_3
- No `INVOICE_COMPLETED` webhook (invoice not yet fully paid)

### Payment Fails

When a payment fails:

1. `PAYMENT_FAILED` webhook is sent
2. No invoice completion webhook is sent

### Payment Refunded (Partial or Full)

Stream supports multiple refunds on a single payment. Webhook events depend on whether the payment is fully refunded or only partially refunded:

**Partial refund** (cumulative refunded amount is still less than the payment amount):

1. `PAYMENT_PARTIALLY_REFUNDED` webhook is sent
2. Payment status becomes `PARTIALLY_REFUNDED`
3. Invoice status does not change

**Full refund** (cumulative refunded amount equals the payment amount):

1. `PAYMENT_REFUNDED` webhook is sent
2. Payment status becomes `REFUNDED`
3. Invoice status does not change

Example: Payment of 1000 SAR

- First refund of 300 SAR → `PAYMENT_PARTIALLY_REFUNDED` (`amount_refunded` = 300, `total_amount_refunded` = 300)
- Second refund of 200 SAR → `PAYMENT_PARTIALLY_REFUNDED` (`amount_refunded` = 200, `total_amount_refunded` = 500)
- Final refund of 500 SAR → `PAYMENT_REFUNDED` (`amount_refunded` = 500, `total_amount_refunded` = 1000)

:::info

`PAYMENT_REFUNDED` means the payment is **fully** refunded. If you care about partial refunds, also subscribe to `PAYMENT_PARTIALLY_REFUNDED`.

:::

### Payment Marked as Paid

When a payment is manually marked as paid:

1. `PAYMENT_MARKED_AS_PAID` webhook is sent
2. If this completes the invoice, `INVOICE_COMPLETED` webhook is also sent

### Subscription Renewal

When a subscription cycle renews:

1. New invoice created → `INVOICE_CREATED` webhook
2. Payment succeeds → `PAYMENT_SUCCEEDED` webhook
3. Invoice completes → `INVOICE_COMPLETED` webhook

**Note:** For subscription renewals, the `INVOICE_COMPLETED` webhook indicates that the subscription cycle has been renewed successfully. The invoice will have a `subscription_id` in its payload, and you can check if it's a renewal invoice by comparing it with previous invoices for that subscription.

## Event Types

### Payment Events

- `PAYMENT_SUCCEEDED` - Payment completed successfully
- `PAYMENT_FAILED` - Payment attempt failed
- `PAYMENT_CANCELED` - Payment was canceled
- `PAYMENT_PARTIALLY_REFUNDED` - A refund was issued and the payment is still only partially refunded
- `PAYMENT_REFUNDED` - Payment was fully refunded
- `PAYMENT_MARKED_AS_PAID` - Payment was manually marked as paid

### Invoice Events

- `INVOICE_CREATED` - New invoice created
- `INVOICE_SENT` - Invoice sent to consumer
- `INVOICE_ACCEPTED` - Invoice accepted by consumer
- `INVOICE_REJECTED` - Invoice rejected by consumer
- `INVOICE_COMPLETED` - Invoice completed (all payments done)
- `INVOICE_CANCELED` - Invoice canceled
- `INVOICE_UPDATED` - Invoice details updated

### Subscription Events

- `SUBSCRIPTION_CREATED` - New subscription created
- `SUBSCRIPTION_ACTIVATED` - Subscription changed to `ACTIVE` (initial activation or reactivation)
- `SUBSCRIPTION_INACTIVATED` - Subscription deactivated
- `SUBSCRIPTION_CANCELED` - Subscription canceled
- `SUBSCRIPTION_FROZEN` - Subscription frozen
- `SUBSCRIPTION_CYCLE_RENEWED_SUCCESSFULLY` - Renewal payment succeeded and the subscription was renewed
- `SUBSCRIPTION_CYCLE_RENEWAL_FAILED` - Automated/tokenized renewal payment failed
- `SUBSCRIPTION_CANCEL_AT_PERIOD_END` - Subscription scheduled to cancel at period end
- `SUBSCRIPTION_FREEZE_NOW` - Subscription frozen immediately
- `SUBSCRIPTION_UNFREEZE_NOW` - Subscription unfrozen immediately
- `SUBSCRIPTION_UNFREEZE_FUTURE` - Subscription scheduled to unfreeze in future
- `SUBSCRIPTION_FREEZE_CANCEL` - Subscription freeze canceled
- `SUBSCRIPTION_PLAN_CHANGE_SCHEDULED` - A plan change was scheduled to take effect at `current_period_end`.
- `SUBSCRIPTION_PLAN_CHANGE_CANCELED` - A previously scheduled plan change was canceled before it took effect.
- `SUBSCRIPTION_PLAN_CHANGED` - The scheduled plan change was actually applied — items, coupons, interval, and amount are now live on the subscription.
- `SUBSCRIPTION_PLAN_CHANGE_INVOICE_REISSUED` - While scheduling a plan change, an existing prepared next-cycle invoice was canceled and regenerated from the new target plan. This is triggered alongside `SUBSCRIPTION_PLAN_CHANGE_SCHEDULED` if it affects the plan's invoice.
- `SUBSCRIPTION_PLAN_UPDATED` - Subscription plan change was applied immediately. This applies for changing seats, adding add-ons, and changing number of subscription cycles.

### Payment Link Events

- `PAYMENT_LINK_PAY_ATTEMPT_FAILED` - Payment attempt failed for a payment link

  **Note:** This webhook is sent when a payment link payment fails. Unlike regular payment failures, no invoice, payment, or subscription entities are created on failure, so `PAYMENT_FAILED` webhook cannot be sent. This event exists specifically to notify about payment link failures when no entities exist.

## Webhook Payload

The webhook POST request will have a JSON body like:

```json
{
  "event_type": "PAYMENT_SUCCEEDED",
  "entity_type": "PAYMENT",
  "entity_id": "uuid",
  "entity_url": "<https://stream-app-service.streampay.sa/api/v2/payments/{id}>",
  "status": "SUCCEEDED",
  "data": { /* payment or event-specific data */ },
  "timestamp": "2025-07-15T14:41:21.705Z"
}

```

## Webhook Payload Example

```json
{
  "data": {
    "invoice": {
      "id": "2df0f7e0-2634-46ab-829a-bfcb0a797d87",
      "url": "https://stream-app-service.streampay.sa/api/v2/invoices/2df0f7e0-2634-46ab-829a-bfcb0a797d87"
    },
    "payment": {
      "id": "e2182d3d-b4cf-4972-bcc0-ec6d963c066d",
      "url": "https://stream-app-service.streampay.sa/api/v2/payments/e2182d3d-b4cf-4972-bcc0-ec6d963c066d"
    },
    "payment_link": {
      "id": "6361941e-3a81-4aa5-aaa6-60d6e052883a",
      "url": "https://stream-app-service.streampay.sa/api/v2/payment_links/6361941e-3a81-4aa5-aaa6-60d6e052883a"
    },
    "metadata": {
      "customer_id": "cust_12345",
      "nested_data": {
        "sub_field": "sub_value",
        "sub_number": 678
      },
      "affiliate_id": "aff_987",
      "custom_field_1": "value_1",
      "custom_field_2": 12345,
      "campaign_source": "email_marketing"
    }
  },
  "status": "SUCCEEDED",
  "entity_id": "e2182d3d-b4cf-4972-bcc0-ec6d963c066d",
  "timestamp": "2025-07-22T14:40:31.485576",
  "entity_url": "https://stream-app-service.streampay.sa/api/v2/payments/e2182d3d-b4cf-4972-bcc0-ec6d963c066d",
  "event_type": "PAYMENT_SUCCEEDED",
  "entity_type": "PAYMENT"
}
```

## Webhook Request Headers

- `Content-Type: application/json`
- `User-Agent: StreamApp-Webhook/1.0`
- `X-Webhook-Event`: Event type (e.g., `PAYMENT_SUCCEEDED`)
- `X-Webhook-Entity-Type`: Entity type (e.g., `PAYMENT`)
- `X-Webhook-Entity-ID`: Entity UUID
- `X-Webhook-Signature`:
Format: `t={timestamp},v1={signature}`
    - `timestamp` is the UNIX timestamp when the signature was generated.
    - `signature` is an HMAC-SHA256 of `{timestamp}.{payload}` using your webhook’s `secret_key`.
- `X-Webhook-Timestamp`: The timestamp used in the signature.

## Verifying Webhook Authenticity

:::warning

Always verify the `X-Webhook-Signature` before treating a webhook as authentic or updating your system (fulfillment, access, financial state). Reject requests with a missing or invalid signature. Unsigned or unverified payloads could be forged; never trust the JSON body alone.

:::

To verify a webhook:

1. Extract the `X-Webhook-Signature` header and split into timestamp and signature.
2. Compute the HMAC-SHA256 of `{timestamp}.{raw_request_body}` using your webhook’s `secret_key`.
3. Compare your computed signature to the value in the header.

Example (Python):

```python

def verify_webhook_signature(secret: str, raw_body: bytes, signature_header: str):
    # signature_header: "t=TIMESTAMP,v1=SIGNATURE"
    parts = dict(x.split('=') for x in signature_header.split(','))
    timestamp = parts['t']
    signature = parts['v1']
    message = f"{timestamp}.{raw_body.decode()}"
    computed = hmac.new(secret.encode(), message.encode(), hashlib.sha256).hexdigest()
    return hmac.compare_digest(computed, signature)

```

## Webhook Delivery & Retry Logic

- Delivery Attempts:

    Every webhook event triggers a delivery record. Each delivery attempt and its status (pending, delivered, failed, retrying) is tracked for auditing.

- Retry Schedule:

    If your endpoint does not respond with a 2xx status, Stream will retry delivery up to 5 times.

    The default retry delays (in minutes) are:

    1. 1st retry: 5 minutes after the first failure
    2. 2nd retry: 30 minutes after the second failure
    3. 3rd retry: 2 hours (120 minutes) after the third failure
    4. 4th retry: 6 hours (360 minutes) after the fourth failure
    5. 5th retry: 12 hours (720 minutes) after the fifth failure

    After the fifth attempt, if delivery is still unsuccessful, the webhook delivery is marked as failed and no further attempts will be made.

- Auditing:

    All delivery attempts, responses, and errors are logged and can be audited.

---

## Testing Cards

## Testing Environment

In order to test your application without having to go live with cards and accounts, you can use [Moyasar's testing cards](https://docs.moyasar.com/guides/card-payments/test-cards/)) to simulate different transaction outcomes.

The test cards should be used in a sandbox environment. This is also applicable if you are using the Stream's UI in sandbox mode and want to test the flow without having to use actual cards.

## Required Card Fields

Below are the values that need to be entered for the non-card number fields when testing:

| Field | Value |
| :--- | :--- |
| **Name** | Any name made of two words separated by a space (e.g., John Doe) |
| **Year** | Any **future** year |
| **Month** | Any month (or a future month if using the current year) |
| **CVC** | Any 3 digits (4 digits for American Express (AMEX)) |

---

## List of Test Cards and Expected Outcomes

Below is the list of test card numbers you can use in your test environment to simulate specific transaction statuses (Success/Failure) according to the card network.

### Mada

| Card Number | Status | Message | Response Code | 3DS Note |
| :--- | :--- | :--- | :--- | :--- |
| `4201320111111010` | **paid** | APPROVED | 00 | ---- |
| `4201320000013020` | **failed** | UNSPECIFIED FAILURE | 99 | ---- |
| `4201320000311101` | **failed** | INSUFFICIENT FUNDS | 51 | ---- |
| `4201320131000508` | **failed** | DECLINED: LOST CARD | 41 | ---- |
| `4201321234411220` | **failed** | DECLINED | 05 | ---- |
| `4201322267774310` | **failed** | DECLINED: EXPIRED CARD | 54 | ---- |
| `4201326324640570` | **failed** | DECLINED: EXCEEDS WITHDRAWAL LIMIT | 61 | ---- |
| `4201321144311528` | **failed** | DECLINED: STOLEN CARD | 43 | ---- |

### Visa

| Card Number | Status | Message | Response Code | 3DS Note |
| :--- | :--- | :--- | :--- | :--- |
| `4111114005765430` | **paid** | APPROVED | 00 | Frictionless Authentication |
| `4111111111111111` | **paid** | APPROVED | 00 | ---- |
| `4123120000000000` | **failed** | UNSPECIFIED FAILURE | 99 | ---- |
| `4123120001090000` | **failed** | INSUFFICIENT FUNDS | 51 | ---- |
| `4123450131000508` | **failed** | DECLINED: LOST CARD | 41 | ---- |
| `4123120001090109` | **failed** | DECLINED | 05 | ---- |
| `4123128518640738` | **failed** | DECLINED: EXPIRED CARD | 54 | ---- |
| `4123123033308648` | **failed** | DECLINED: EXCEEDS WITHDRAWAL LIMIT | 61 | ---- |
| `4123125276780003` | **failed** | DECLINED: STOLEN CARD | 43 | ---- |
| `4111118250252531` | **failed** | 3DS: attempted but not available, please ensure that you have enabled Online Purchase from your bank portal. | ---- | ECI 06 |
| `4111113343111067` | **failed** | 3DS service error occurred. | ---- | 3DS fails during enrollement check |
| `4111116611600661` | **failed** | The card is not enrolled in 3DS service. | ---- | ---- |
| `4111112205628150` | **failed** | 3DS service error occurred. | ---- | 3DS fails during authentication attempt |
| `4111115784228433` | **failed** | The authentication attempt was rejected by the issuer bank. | ---- | ---- |
| `4111115620358287` | **failed** | The authentication is unavailable, please try again later or contact issuer bank if problem persisted. | ---- | ---- |

### Mastercard

| Card Number | Status | Message | Response Code | 3DS Note |
| :--- | :--- | :--- | :--- | :--- |
| `5421080101000000` | **paid** | APPROVED | 00 | ---- |
| `5105105105105100` | **failed** | UNSPECIFIED FAILURE | 99 | ---- |
| `5457210001000092` | **failed** | INSUFFICIENT FUNDS | 51 | ---- |
| `5204010101000000` | **failed** | DECLINED: LOST CARD | 41 | ---- |
| `5204730000002514` | **failed** | DECLINED | 05 | ---- |
| `5105107550274126` | **failed** | DECLINED: EXPIRED CARD | 54 | ---- |
| `5105106475101067` | **failed** | DECLINED: EXCEEDS WITHDRAWAL LIMIT | 61 | ---- |
| `5105107304607225` | **failed** | DECLINED: STOLEN CARD | 43 | ---- |

### American Express (AMEX)

| Card Number | Status | Message | Response Code | 3DS Note |
| :--- | :--- | :--- | :--- | :--- |
| `340000000900000` | **paid** | APPROVED | 00 | ---- |
| `371111111111114` | **failed** | UNSPECIFIED FAILURE | 99 | ---- |
| `340033000000000` | **failed** | INSUFFICIENT FUNDS | 51 | ---- |
| `340012340501000` | **failed** | DECLINED: LOST CARD | 41 | ---- |
| `340033000000133` | **failed** | DECLINED | 05 | ---- |
| `340000018441278` | **failed** | DECLINED: EXPIRED CARD | 54 | ---- |
| `340000753060788` | **failed** | DECLINED: EXCEEDS WITHDRAWAL LIMIT | 61 | ---- |
| `340000418501838` | **failed** | DECLINED: STOLEN CARD | 43 | ---- |

---

## Testing Apple Pay

Unlike card payments where specific test card numbers are used, testing **Apple Pay** payments in the Stream's sandbox environment is based on the **amount** sent to the API (according to [Moyassar](https://docs.moyasar.com/guides/apple-pay/testing/)).

A **real card** must be added to an Apple Pay Wallet to test the process, but you must be using the sandbox environment to ensure no actual payment is made.

The following amounts will simulate different payment outcomes:

| Amount (Minor Unit) | Amount (SAR) | Status | Message | Response Code |
| :--- | :--- | :--- | :--- | :--- |
| `20000` to `30000` | `200.00` to `300.00` | **paid** | APPROVED | 00 |
| `100000` to `110000` | `1000.00` to `1100.00` | **failed** | UNSPECIFIED FAILURE | 99 |
| `110100` to `120000` | `1101.00` to `1200.00` | **failed** | INSUFFICIENT FUNDS | 51 |
| `120100` to `130000` | `1201.00` to `1300.00` | **failed** | DECLINED: LOST CARD | 41 |
| `130100` to `140000` | `1301.00` to `1400.00` | **failed** | DECLINED | 05 |
| `140100` to `150000` | `1401.00` to `1500.00` | **failed** | DECLINED: EXPIRED CARD | 54 |
| `150100` to `160000` | `1501.00` to `1600.00` | **failed** | DECLINED: EXCEEDS WITHDRAWAL LIMIT | 61 |
| `160100` to `170000` | `1601.00` to `1700.00` | **failed** | DECLINED: STOLEN CARD | 43 |

> **Note:** Moyasar accepts the payment amount in the **minor currency unit** (e.g., cents), and the test environment uses this amount to return different results.
---
> **Tip:** Using any other amount range than the stated above will result in the payment failing.

---

## Installments


Installments allow customers to split a payment into multiple smaller payments over time. Customers can choose from available installment options (2, 3, or 4 installments) when paying an invoice or payment link.

> Note: Installments are only available for one-time products. They are automatically disabled for recurring products (subscriptions).

---

## How Installments Work

When a customer selects an installment option, Stream automatically calculates the amount for each installment and schedules them based on the split period. Each installment becomes a separate payment with its own due date.

![Customer selecting installment split option](/img/installment-split-selection.png)

**Example:** 1,000 SAR split into 3 monthly installments:
- Installment 1: 333.33 SAR (due on payment date)
- Installment 2: 333.33 SAR (due 1 month later)
- Installment 3: 333.34 SAR (due 2 months later)

---

## How Installment Amounts Are Calculated

Installment amounts are calculated by dividing the total payment by the number of installments. If the amount doesn't divide evenly, any rounding difference is added to the last installment to ensure the total always equals the original payment amount.

For example, 999.98 SAR split into 3 installments results in: 333.33 SAR, 333.33 SAR, and 333.32 SAR (the last installment is reduced by 0.01 SAR to account for the rounding difference).

> Note: The total of all installments always equals the original payment amount.

---

## Configuration

Configure installment settings in your [Payment Settings](https://app.streampay.sa/settings/payment-settings). Invoice and payment link settings are configured separately.

### Enable/Disable Installments

#### API (Payment Links)

When creating a payment link via the [Payment Links API](/api/v2-payment-links-create), you can enable or disable installments by including the `payment_methods` parameter in your request. Set `installment: true` to enable installments or `installment: false` to disable them for that specific payment link.

This setting overrides the organization's default payment link installment settings. If you don't include the `payment_methods` parameter, the organization's default settings will be used.

#### Settings Page

You can configure the default installment settings in your [Payment Settings](https://app.streampay.sa/settings/payment-settings):
- **For invoices**: Enable or disable installments in the invoice payment options (invoices can only be created from the UI)
- **For payment links**: Enable or disable installments in the payment link payment options (these defaults apply when creating payment links via the UI or when the API request doesn't specify `payment_methods`)

### Split Options

Configure which numbers of installments (2, 3, or 4) are available for customers to choose from.

Default split options:
- 2 installments, monthly
- 3 installments, monthly
- 4 installments, monthly

The split period (the interval between installments, e.g., monthly, quarterly, yearly) cannot be changed through the API or dashboard. Contact Stream support to modify the split period.

### Minimum Amount

The minimum installment amount is 100 SAR per installment. If the payment amount divided by the number of installments is less than 100 SAR, that installment option will not be available.

For example, with a payment of 250 SAR:
- 2 installments: 125 SAR each ✅ (available)
- 3 installments: 83.33 SAR each ❌ (not available, below minimum)

The minimum amount cannot be changed through the API or dashboard. Contact Stream support to modify this value.

---

## Authentication


Learn how to authenticate your API requests to the Stream platform.

## Overview

All API calls to Stream require authentication using your API Key Pair. Stream uses a simple but secure authentication method where you encode your credentials and include them in every request.

## Getting Your API Keys

1. Log in to your Stream dashboard
2. Navigate to [API Settings](https://app.streampay.sa/settings/api-keys)
3. Click **Create Key Pair**
4. Store your `api-key` and `api-secret` securely
5. Copy `x-api-key` to use in the APIs or you can gernerate later

:::warning Important
Your API secret should be kept secure and never exposed in client-side code or public repositories. Treat it like a password.
:::

## Authentication Methods

Stream uses HTTP Basic Authentication with Base64 encoding of your API credentials.

Encode your API key and secret as a Base64-encoded token:

```bash
echo -n 'api-key:api-secret' | base64
```

**Example:**

```bash
echo -n '038cb769-9ce3-49da-9d52-17fd49bf07e8:6ea68e79-8756-4be8-9bd2-307314e8d12c' | base64
# Output: MDM4Y2I3NjktOWNlMy00OWRhLTlkNTItMTdmZDQ5YmYwN2U4OjZlYTY4ZTc5LTg3NTYtNGJlOC05YmQyLTMwNzMxNGU4ZDEyYw==
```

#### Using the Token

Include the Base64-encoded token in the `x-api-key` header for all API requests:

```bash
curl -X POST https://stream-app-service.streampay.sa/api/v2/payment_links \
  -H "x-api-key: MDM4Y2I3NjktOWNlMy00OWRhLTlkNTItMTdmZDQ5YmYwN2U4OjZlYTY4ZTc5LTg3NTYtNGJlOC05YmQyLTMwNzMxNGU4ZDEyYw==" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Test Payment",
    "amount": 100.00
  }'
```

### Using SDKs

When using Stream SDKs, authentication is handled automatically. Simply provide your `x-api-key` during initialization:

#### TypeScript SDK

```typescript

const client = StreamSDK.init(process.env.STREAM_API_KEY!);
```

#### Express SDK

```typescript

app.get(
  "/checkout",
  Checkout({
    apiKey: process.env.STREAM_API_KEY!,
    // ... other config
  })
);
```

---

## Branches in the API


API requests are always scoped to a single branch. When creating an API key, you specify which branches it can access. For each request, you can select the target branch, which determines where resources are created and accessed.

## Creating API Keys with Branch Access

When creating an API key, you can specify:

- Branches: List of specific branches the API key can access
- Default Branch: Default branch used when `x-branch-id` header is not provided
- Is All Branches: If `true`, the API key has access to all branches, present and future

## Selecting a Branch in API Requests

Include the `x-branch-id` header to specify which branch to use for that request:

```bash
curl -X GET https://stream-app-service.streampay.sa/api/v2/user \
  -H "x-api-key: YOUR_API_KEY" \
  -H "x-branch-id: branch-uuid-here"
```

If `x-branch-id` is omitted, the API key's `default_branch_id` is used.

## Branch Access Validation

The API key must have access to the branch specified in `x-branch-id`:
- If `is_all_branches=true`: Access to all organization branches
- Otherwise: Only branches listed in `branch_ids`

Requests to unauthorized branches return a 4xx error.

---

## Customer Portal (Hosted Billing)

# Customer Portal (hosted billing)

The **customer portal** is Stream’s hosted web app ([billing.streampay.sa](https://billing.streampay.sa)) where your **consumers** sign in and manage their relationship with **you**, within limits you configure in Stream: subscriptions (plan changes, quantity adjustment, and add‑ons allowed by your catalog), invoices, saved cards, profile and language, and payment flows that use Stream checkout.

---

## Prerequisites

- **Consumer in Stream** — The person must exist as an **organization consumer** (Stream’s customer record). Create one with the [Create Consumer](/api/v2-consumers-create) API (or your existing consumer flow) and use the returned **`id`** as **`organization_consumer_id`** when creating a portal session.
- **Merchant API credentials** — Your backend calls Stream with **`x-api-key`**; see [Authentication](/authentication).

---

## Send a consumer to the portal

Call from your **server** only (never expose your API secret or full key pair in a browser or app) this [endpoint](/api/v2-consumer-portal-sessions-create) to get the one-time use token to open the customer portal for a specific consumer ID.

**Body (minimum)**

| Field | Required | Description |
| ----- | -------- | ----------- |
| `organization_consumer_id` | Yes | The consumer’s UUID in Stream (`id` from [Create Consumer](/api/v2-consumers-create) or [list consumers](/api/v2-consumers-list)). |

**Response**

On success (**HTTP 201**) the JSON includes a **`url`**. Return that **`url`** to your frontend and open it so the consumer lands on the billing portal.

You can optionally include **`return_url`** (query hint for “back to merchant”; Stream does not auto-redirect), **`subscription_id`** to open a specific subscription for that consumer, or other optional fields supported by the API—see the reference for the full request schema.

---

## What subscription self-service means

When your settings allow it, a customer can change an **active** subscription from the portal. Stream validates every change against your catalog and portal rules. Below is what each kind of change means in plain terms.

### Switching plans

**Plan switching** is when the customer moves from one **base** subscription product to another **member of the same product switch group** you defined in Stream. Only products you placed in that group can replace one another; the portal does not allow arbitrary jumps across unrelated products. Plans with different recurring cycles (e.g MONTHLY and YEARLY) can be added in the same switch group.

Typical shape of a switch: one billed **base** line is removed and another **base** line (the new plan) replaces it within the rules of that group. Whether this appears as an immediate change or is scheduled depends on billing setup and proration logic (see [Proration and timing](#proration-and-timing)).

:::note Coupons
Subscriptions with **coupon** locked at subscription level usually **cannot** be edited from the portal. Coupons on lines you keep can persist; lines you remove lose their coupons.
:::

### Add-ons

**Add-ons** are separate catalog products attached to an active subscription—not the main plan by itself. Each add-on is only available when the subscription’s **base** catalog products make it eligible. You declare that relationship in Stream (which bases may carry which add-ons).

Customers can subscribe or drop add-ons in the portal only when you enable **add / remove add-ons** for Customer Portal and the add-on mapping allows it.

When creating an add-on, you get to choose a list of recurring products for which the add-on is eligible. In case a subscription has multiple recurring products and the recurring products have different eligible add-ons, the customer will be able to add **all** of these add-ons.

### Changing quantity

Quantity changes behave differently depending on whether the line is part of your **switch group** (often “seat-like” bases) versus an **add-on**:

| Kind of line | What “quantity” means | How you control it |
| ------------ | --------------------- | ------------------ |
| **Products in switch groups** | How many seats or units apply to that **base plan** row | Toggle **switch-group quantity change** in Customer Portal settings. When enabled, you can constrain **minimum** and **maximum** quantities; when disabled, customers cannot freely change those quantities in the portal. |
| **Add-on lines** | How many units of that add-on are on the subscription | Toggle **add-on quantity change**. When quantity change is **off** for new add-ons, new add-ons are typically limited to quantity **one** until you widen the rule. |

The portal compares changes to **allowed** quantities only; anything outside configured bounds is rejected.

### Proration and timing {#proration-and-timing}

**Proration** is how billing adjusts when the subscription **mid-cycle** gains or loses value: Stream compares what was prepaid or owed for the current period against what the revised subscription implies, and settles the difference—often creating an invoice line or prompting payment **before** the next renewal. Proration does not include the current day in the new pricing. For example, if a monthly subscription (30 days) was created today and then in the same day an add-on gets added immediately through proration, the proration excludes the current day from the new bill (i.e. the user pays 29 / 30 days worth of add-on instead of 30/30.)

Roughly:

- **Adding add-ons**, **raising quantity**, or some **plan upgrades** commonly produce **immediate** charges (or payment steps) when money is owed, because billing value rises right away relative to what was invoiced.

- **Removing add-ons**, **lowering quantity**, or changing plans in directions that reduce or reshape future billing often take effect according to billing rules. For example at **period end** or as a **scheduled** change rather than forcing an instant upfront payment in every case.

- When a change crosses into a **different billing rhythm** than the subscription’s targets, moves are **often scheduled** for a future boundary rather than squeezed into an immediate payment-only flow inside the portal.

From the customer’s perspective, the portal either **confirms the change outright**, **shows a payment or card step** when an adjustment is due now, or **explains that the change applies later** in the billing period—depending on the scenario above. Until any required payment clears, billing may remain on the previous shape until reconciliation finishes.

Exact math and timing depend on your products’ recurrence and Stream’s reconciliation; you do **not** re-implement proration in your integration.

---

## Configure Customer Portal, branding, and catalog

Open the Stream dashboard, then **[Settings → Customer Portal](https://app.streampay.sa/settings/customer-portal)**. There you tune both **permissions** customers get and **branding** of [billing.streampay.sa](https://billing.streampay.sa).

### Portal permissions (toggles)

These settings mirror what you enable in Customer Portal Settings in the UI—they define what edits the hosted app even offers:

| Setting | Meaning for your customers |
| ------- | -------------------------- |
| **Product switch** | Can move between products you grouped in **product switch groups** (plan changes within your allowed set). |
| **Add / remove add-ons** | Can attach or remove add-ons you exposed through add-on eligibility. |
| **Switch-group quantity change** | Can change quantity on **base** lines that belong to switch groups, within optional **min** / **max** when enabled. |
| **Add-on quantity change** | Can change quantity on add-on lines, within optional **min** / **max** when enabled. |
| **Subscription cancellation** | Customer-led cancellation inside portal flows is on or off. |

### Branding

On the same **Customer Portal** settings area, you can personalize the hosted experience:

- **Primary color** and **secondary color** — Applied across the portal UI so it feels closer to your brand.
- **Favicon** — Shown in the browser tab when customers use the billing site.

Uploads and color pickers persist with your organization so every session link inherits the same look.

### Catalog prerequisites (beyond the toggles)

Customer Portal switches and add-ons only work if the **catalog** is set up to match:

| Goal | What to set up in Stream |
| ---- | ------------------------- |
| Allowed plan moves | Create **product switch groups** and assign which products belong to each group. Only members of the **same** group can replace one another. |
| Which add-ons exist for which bases | Maintain **add-on mappings**: for each add-on product, declare which **base** products make it eligible. |

Until those mappings exist, toggles alone will not expose meaningful switches or add-ons in the portal.

---

## Summary

| Role | Responsibility |
| ---- | ---------------- |
| **Your backend** | `POST /api/v2/consumer_portal/sessions` with `organization_consumer_id`, then return **`url`** to the client. |
| **Your frontend** | Open **`url`**; do not use the merchant API key in the browser. |
| **billing.streampay.sa** | Hosts the customer portal once the consumer opens **`url`. |

For API key setup and authentication, see [Authentication](/authentication).

---

## Embedded Checkout


Render a payment link checkout in-page with the Stream Embed SDK. Create a payment link via the API first, then pass the response **`url`** into `paymentLink`. Details on creating links (products, consumers, redirects): [Creating a Payment Link](/#creating-a-payment-link).

## Prerequisites

- Same setup as payment-link creation: API key pair, and at least one product ID. See [Creating a Payment Link](/#creating-a-payment-link).

- For using Apple Pay through our embedded checkouts, the following steps need to be done:
  - Get the text file from `https://streampay.sa/.well-known/apple-developer-merchantid-domain-association`
  -  Host the same exact text file under your domain through this path: `.well-known/apple-developer-merchantid-domain-association`
  - Reach out to support team on available communication methods to register you in the PGW system.

## Example

### 1. Create a payment link

`POST /api/v2/payment_links` returns an object whose **`url`** field is what you embed (same value you would redirect to).

```bash
curl -s -X POST https://stream-app-service.streampay.sa/api/v2/payment_links \
  -H "x-api-key: <your-base64-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Checkout",
    "items": [{ "product_id": "your-product-uuid-here", "quantity": 1 }],
    "contact_information_type": "PHONE",
    "currency": "SAR",
    "max_number_of_payments": 100
  }'
```

Example response (trimmed):

```json
{
  "url": "https://streampay.sa/ds/..."
}
```

Use that `url` as `paymentLink` in the next step. Build the request body you need (customer-specific links, metadata, redirect URLs, subscriptions, etc.) using the guide and [Create payment link](https://docs.streampay.sa/api/v2-payment-links-create).

### 2. Embed checkout

Load the default SDK, mount a container, call `Stream.Checkout` with the **`url`** from step 1. Inject the URL from your server—do not create payment links or expose API keys in frontend-only code.

```html
<script src="https://stream-embed.streampay.sa/sdk/embed.min.js"></script>

<script>
  Stream.Checkout({
    paymentLink: "https://streampay.sa/ds/XXXXXX", # the URL should be the created payment link URL
    container: "#stream-checkout",
  });
</script>
```

## Options

| Option | Type | Required | Description |
| ------ | ---- | -------- | ----------- |
| `paymentLink` | `string` | **Yes** | Full payment-link URL from the API (`url` field) or short ID Stream accepts |
| `container` | `string` \| `Element` | **Yes** | CSS selector or DOM element for the iframe |
| `minHeightPx` | `number` | No | Min iframe height (default **280**) |
| `maxHeightPx` | `number` | No | Max iframe height (default **920**) |
| `vhCapPx` | `number` | No | Viewport-relative height cap (default **800**) |
| `vhFraction` | `number` | No | Viewport fraction for fluid height (default **0.7**) |

## See also

- [Webhooks](/webhooks) — confirm payment server-side  
- [Public API reference](https://docs.streampay.sa/)

---

## Stream API Errors


This page documents the error response format and the standardized error codes returned by Stream API endpoints. The goal is to provide a stable, predictable contract for client applications and integrators.

## Error response envelope

All handled errors return a response body using the `StreamBaseResponse` envelope:

```json
{
  "error": {
    "code": "STREAM_ERROR",
    "message": "Something wrong happened, please contact support.",
    "additional_info": "Optional human-readable details"
  }
}
```

- `code`: A stable error code from `StreamErrorCodes`.
- `message`: A user‑facing message associated with the code.
- `additional_info`: Optional, best‑effort details to aid debugging.

## Common error classes and HTTP status codes

The following exception classes map to consistent HTTP status codes:

| Exception class | HTTP status |
| --- | --- |
| `BadRequestError` | 400 |
| `UnauthorizedError` | 401 |
| `ForbiddenError` | 403 |
| `PermissionForbiddenError` | 403 |
| `NotFoundError` | 404 |
| `GoneError` | 410 |
| `UnprocessableEntityError` | 422 |
| `DuplicateValueError` | 422 |

## Stream error codes

The following codes are used across all Stream API endpoints:

| Code | Message |
| --- | --- |
| `STREAM_ERROR` | Something wrong happened, please contact support. |
| `STREAM_UNKNOWN_ERROR` | Unknown exception happened; this exception will be handled as soon as possible. |
| `PHONE_ALREADY_REGISTERED` | Phone is already registered. |
| `INVALID_PARAMETERS` | Request input is not valid. |
| `INVOICE_FINALISED` | Invoice is finalised and cannot undergo this action. |
| `PAYMENT_REFUNDED_ALREADY` | Duplicate action; payment has already been refunded. |
| `PAYMENT_REFUNDED_FAILED` | Could not refund payment; processor failed. |
| `DUPLICATE_CONSUMER` | Consumer already exists. |
| `DUPLICATE_PAYMENT` | A payment with the given information already exists. |
| `PERMISSION_FORBIDDEN` | Permission forbidden. |
| `PRODUCT_USED_IN_FINALIZED_INVOICE` | Product cannot be updated; it is used by a finalized invoice. |
| `COUPON_USED_IN_FINALIZED_INVOICE` | Coupon cannot be updated; it is used by a finalized invoice. |

---

## Handling Your Own Notifications


This guide explains how to handle your own organization consumer notifications by disabling default notifications and using webhooks for event-based notifications or list APIs for scheduled notifications.

## Overview

By default, Stream sends notifications to your organization consumers (customers) for various events like payment confirmations, invoice updates, and subscription changes. If you want to handle these notifications yourself, you can:

1. Disable default org_consumer notifications - Contact support to enable the blocking setting
2. Subscribe to webhook events - For immediate, event-based notifications
3. Use list APIs - For scheduled notifications (reminders, overdue notices, etc.)

---

## Step 1: Disable Default Org Consumer Notifications

**Important:** Before disabling default notifications, you must contact our support team to disable default notifications for your organization. This prevents all default notifications from being sent to your organization consumers.

Once enabled, you can manage notifications through webhooks and list APIs as described below.

---

## Step 2: Subscribe to Webhook Events

For event-based notifications (immediate actions like payment succeeded, invoice accepted, etc.), subscribe to webhook events.

To create or manage your webhooks, go to [Webhook Settings](https://app.streampay.sa/settings/webhooks) and subscribe to the relevant event types.

For a complete list of available webhook events, payload structure, verification, and delivery details, see the [Webhooks Guide](/webhooks).

---

## Step 3: Use List APIs for Scheduled Notifications

For scheduled notifications (time-based reminders like payment due, overdue, etc.), use list APIs with appropriate filters to query for items that need notifications. For example, use the [List Payments API](/api/v2-payments-list), [List Invoices API](/api/v2-invoices-list), or [List Subscriptions API](/api/v2-subscriptions-list).

---

## Stream MCP Server


MCP (Model Context Protocol) is a standard way for AI clients to call tools and read resources from external systems.

The Stream MCP Server exposes Stream operations (payments, invoices, customers, products, etc.) as MCP tools so clients like Claude Desktop, Cursor, and VS Code can use them directly.

**Resources vs tools:** MCP **resources** (such as the OpenAPI documentation) do not require a Stream API key. **Tools** that call the Stream API—payments, customers, invoices, products, coupons, and the rest, **do** require a valid key in your client configuration.

## Main Feature: API Documentation Integration

The primary feature of this MCP server is direct integration with Stream API documentation.

- It exposes the full OpenAPI spec as an MCP resource.
- AI clients can read the latest API schema and stay aligned with current endpoints.
- This improves tool accuracy for request fields, validation, and endpoint usage.

## Hosted endpoint

Stream hosts the MCP server at:

`https://mcp.streampay.sa/mcp`

Configure your client to use this URL. Include `Authorization` when you use tools that hit the Stream API; you can omit it if you only read documentation resources.

Use the **Connect MCP** button at the top of this page to install the server in Cursor, VS Code, or LM Studio, or to copy the command, URL, or JSON config for other clients. Paste your Stream API key into the optional field in its menu to include the `Authorization` header in the generated config; the key stays in your browser and is never sent anywhere. Without a key, only documentation resources work.

---

## Client configuration (Claude Desktop / Cursor / VS Code)

Add this to your MCP config file (`claude_desktop_config.json` or `mcp.json`). Use the `headers` block whenever you rely on tools that require the Stream API (omit it for resources-only use, such as the OpenAPI spec).

```jsonc
{
  "mcpServers": {
    "stream": {
      "url": "https://mcp.streampay.sa/mcp",
      "headers": {
        // Required for operational tools (payments, customers, etc.); omit if you only read docs resources (e.g. OpenAPI).
        "Authorization": "Bearer stream_api_key_here"
      }
    }
  }
}
```

---

## Available Tools

### Payment Links

| Tool | Description |
|---|---|
| `create_payment_link` | Create a new checkout / payment link |
| `list_payment_links` | Paginated list with optional status filter |
| `get_payment_link` | Get a single payment link by ID |
| `deactivate_payment_link` | Deactivate / archive a payment link |

### Customers

| Tool | Description |
|---|---|
| `create_customer` | Create a customer with name, email, phone, metadata |
| `list_customers` | Paginated list of customers |
| `get_customer` | Get a single customer by ID |
| `update_customer` | Update customer fields |
| `delete_customer` | Soft-delete a customer |

### Products

| Tool | Description |
|---|---|
| `create_product` | Create a one-time or recurring product |
| `list_products` | List products with optional type filter |
| `get_product` | Get a single product by ID |
| `update_product` | Update product name, description, or price |
| `archive_product` | Archive a product |

### Coupons

| Tool | Description |
|---|---|
| `create_coupon` | Create a fixed or percentage discount coupon |
| `list_coupons` | List coupons with optional status filter |
| `get_coupon` | Get a single coupon by ID |
| `deactivate_coupon` | Deactivate a coupon |

### Invoices

| Tool | Description |
|---|---|
| `create_invoice` | Create a ZATCA-compliant invoice |
| `list_invoices` | List invoices with filters |
| `get_invoice` | Get a single invoice by ID |
| `send_invoice` | (Re)send an invoice via email / SMS |
| `void_invoice` | Void / cancel an unpaid invoice |

### Payments

| Tool | Description |
|---|---|
| `list_payments` | List payments with filters |
| `get_payment` | Get payment details |
| `refund_payment` | Issue a full or partial refund |

### Resources

Reading these resources does not require your Stream API key in the client (unlike the operational tools above).

| Resource URI | Description |
|---|---|
| `stream://docs/openapi` | Full Stream OpenAPI spec (cached, auto-refreshed) — main documentation integration feature |

---

## Accept Consent

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Accept Consent"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/accept"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Accept a payment consent and initiate the payment flow.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./accept-consent-api-v-2-consumer-portal-consent-consent-id-accept-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./accept-consent-api-v-2-consumer-portal-consent-consent-id-accept-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./accept-consent-api-v-2-consumer-portal-consent-consent-id-accept-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Accept Invoice Batch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Accept Invoice Batch"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/invoice-batches/{batch_id}/accept"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Accept Invoice Batch

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./accept-invoice-batch-api-v-2-invoice-batches-batch-id-accept-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./accept-invoice-batch-api-v-2-invoice-batches-batch-id-accept-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./accept-invoice-batch-api-v-2-invoice-batches-batch-id-accept-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Accept Scope Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Accept Scope Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/scope-requests/{scope_request_id}/accept"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Accept Scope Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./accept-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-accept-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./accept-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-accept-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./accept-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-accept-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Accounting Provider Oauth Callback

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Accounting Provider Oauth Callback"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/{provider}/callback"}
  context={"endpoint"}
>
  
</MethodEndpoint>

OAuth redirect target called by the provider itself -- authenticated via `state` alone, not a bearer token.

The caller here is the end user's browser, not an API client, so this always redirects to the
frontend (`status=success|failure&provider={name}`) rather than returning JSON -- even when
the exchange/verification fails.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./accounting-provider-oauth-callback-api-v-2-accounting-provider-callback-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./accounting-provider-oauth-callback-api-v-2-accounting-provider-callback-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./accounting-provider-oauth-callback-api-v-2-accounting-provider-callback-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Activate Accounting Provider

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Activate Accounting Provider"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/activate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Re-activate a configured provider after verifying its stored credentials still work.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./activate-accounting-provider-api-v-2-accounting-provider-activate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./activate-accounting-provider-api-v-2-accounting-provider-activate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./activate-accounting-provider-api-v-2-accounting-provider-activate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Activate Pgw Provider

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Activate Pgw Provider"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/organization-settings/pgw-providers/activate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Switch this organization's active payment gateway.

Only ever toggles an existing PgwOrganizationConfig row — rejects if this org has
no configuration for the requested provider yet (contact support to provision it).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./activate-pgw-provider-api-v-2-organization-settings-pgw-providers-activate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./activate-pgw-provider-api-v-2-organization-settings-pgw-providers-activate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Activate Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Activate Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/pricing_tables/{pricing_table_id}/activate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Activate Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./activate-pricing-table-api-v-2-pricing-tables-pricing-table-id-activate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./activate-pricing-table-api-v-2-pricing-tables-pricing-table-id-activate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./activate-pricing-table-api-v-2-pricing-tables-pricing-table-id-activate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Activate Subscription With Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Activate Subscription With Payment"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/activate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Activate an inactive subscription by paying its latest invoice with the attached card token.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./activate-subscription-with-payment-api-v-2-consumer-portal-profile-subscription-subscription-id-activate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./activate-subscription-with-payment-api-v-2-consumer-portal-profile-subscription-subscription-id-activate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./activate-subscription-with-payment-api-v-2-consumer-portal-profile-subscription-subscription-id-activate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Activities

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Activities"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/invoices/{invoice_id}/activities"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get activity history for an invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./activities-api-v-1-invoices-invoice-id-activities-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./activities-api-v-1-invoices-invoice-id-activities-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./activities-api-v-1-invoices-invoice-id-activities-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Add Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Add Card"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/profile/cards"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Add a new card for the authenticated consumer. Two gateway-dependent flows share this endpoint.

Moyasar (pgw_payment_id set): the frontend already ran a 1 riyal verification
transaction client-side and hands back its payment id. This:
1. Fetches and validates the Moyasar payment transaction
2. Extracts card details from the payment response
3. Creates card token record with organization consumer ID
4. Voids the 1 riyal verification amount
5. Returns the new card ID

MyFatoorah (pgw_payment_id omitted): there's no payment yet, so this instead creates a
zero-charge MyFatoorah Verify session and returns session_id/session_expiry for the
frontend to embed in MyFatoorah's session-based payment SDK. The card isn't saved yet --
completion happens later, asynchronously, via MyFatoorah's redirect, callback, or webhook
(see ConsumerPortalService.complete_myfatoorah_card_tokenization). Only supported for
organizations on a gateway with a native verify operation (currently MyFatoorah).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./add-card-api-v-2-consumer-portal-profile-cards-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./add-card-api-v-2-consumer-portal-profile-cards-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Add Product Price

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Add Product Price"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/products/{product_id}/prices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Add a new price to a product in a different currency.

Each product can have one active price per currency. The currency must be
enabled in the organization's currency configuration.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./add-product-price-api-v-2-products-product-id-prices-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./add-product-price-api-v-2-products-product-id-prices-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./add-product-price-api-v-2-products-product-id-prices-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Approve Connection Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Approve Connection Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/connection-requests/{request_id}/approve"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Approve Connection Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./approve-connection-request-api-v-2-connected-apps-connection-requests-request-id-approve-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./approve-connection-request-api-v-2-connected-apps-connection-requests-request-id-approve-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./approve-connection-request-api-v-2-connected-apps-connection-requests-request-id-approve-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Auto Charge On Demand

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Auto Charge On Demand"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/auto-charge-on-demand/{payment_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Charge a payment using the consumer's latest tokenized card.

This endpoint allows organizations to charge a payment using the consumer's latest
active tokenized card. The following conditions must be met:

- The consumer must have at least one active tokenized card.
- The payment must be in an unpaid status (PENDING, PROCESSING, FAILED, etc.).

**This is a restricted API and is only available to some organizations.**

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./auto-charge-on-demand-api-v-2-payments-auto-charge-on-demand-payment-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./auto-charge-on-demand-api-v-2-payments-auto-charge-on-demand-payment-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./auto-charge-on-demand-api-v-2-payments-auto-charge-on-demand-payment-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Callback

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Callback"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoices-consent/callback"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle callback from open banking payment consent flow.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./callback-api-v-2-invoices-consent-callback-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./callback-api-v-2-invoices-consent-callback-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v1/invoices/{invoice_id}/cancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancel an invoice and optionally cancel its related subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-api-v-1-invoices-invoice-id-cancel-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-api-v-1-invoices-invoice-id-cancel-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-api-v-1-invoices-invoice-id-cancel-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel an invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel an invoice"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/invoices/{invoice_id}/cancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancels an invoice and marks it as `CANCELED`. Use this when the invoice should no longer be collected or shown as payable.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-invoice-api-v-2-invoices-invoice-id-cancel-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-invoice-api-v-2-invoices-invoice-id-cancel-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-invoice-api-v-2-invoices-invoice-id-cancel-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel Metered Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel Metered Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/metered_subscription/{metered_subscription_id}/cancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancel a metered subscription from the consumer side.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-metered-subscription-api-v-2-consumer-portal-metered-subscription-metered-subscription-id-cancel-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-metered-subscription-api-v-2-consumer-portal-metered-subscription-metered-subscription-id-cancel-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-metered-subscription-api-v-2-consumer-portal-metered-subscription-metered-subscription-id-cancel-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel Pending Change

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel Pending Change"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/pending-change"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancel a previously-scheduled deferred plan change for the authenticated consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-pending-change-api-v-2-consumer-portal-profile-subscription-subscription-id-pending-change-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-pending-change-api-v-2-consumer-portal-profile-subscription-subscription-id-pending-change-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-pending-change-api-v-2-consumer-portal-profile-subscription-subscription-id-pending-change-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel Scheduled Subscription Plan Change

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel Scheduled Subscription Plan Change"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/subscriptions/{subscription_id}/pending-change"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancel a previously-scheduled deferred plan change.

No-op (still 200) when no SCHEDULED pending change exists. If the original
schedule call had already re-issued the next-cycle invoice (Arm B), the new
invoice remains unchanged — it represents the upcoming cycle the consumer was
notified about.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-scheduled-subscription-plan-change-api-v-2-subscriptions-subscription-id-pending-change-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-scheduled-subscription-plan-change-api-v-2-subscriptions-subscription-id-pending-change-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-scheduled-subscription-plan-change-api-v-2-subscriptions-subscription-id-pending-change-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel Subscription (POST /api/v2/consumer_portal/subscription/{subscription_id}/cancel)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/subscription/{subscription_id}/cancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Cancel a subscription from the consumer side.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-subscription-api-v-2-consumer-portal-subscription-subscription-id-cancel-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-subscription-api-v-2-consumer-portal-subscription-subscription-id-cancel-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-subscription-api-v-2-consumer-portal-subscription-subscription-id-cancel-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Cancel Subscription (POST /api/v2/subscriptions/{subscription_id}/cancel)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Cancel Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/subscriptions/{subscription_id}/cancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Schedule or complete cancellation and optionally cancel related invoices.

Behavior depends on subscription **status**:

- **ACTIVE**: Cancellation is **scheduled for the end of the current billing period** (the subscription
  stays active until then; it is not moved to ``CANCELED`` immediately).
- **INACTIVE**, **TRIALING**, **TRIAL_PENDING**: The subscription is **canceled immediately**
  (status becomes ``CANCELED``).

Use ``cancel_related_invoices`` to also cancel ongoing invoices tied to this subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./cancel-subscription-api-v-2-subscriptions-subscription-id-cancel-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./cancel-subscription-api-v-2-subscriptions-subscription-id-cancel-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./cancel-subscription-api-v-2-subscriptions-subscription-id-cancel-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Change Invoice Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Change Invoice Card"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/invoice/{invoice_id}/change-card"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Change the card used for auto-renewal payments on an invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./change-invoice-card-api-v-2-consumer-portal-profile-invoice-invoice-id-change-card-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./change-invoice-card-api-v-2-consumer-portal-profile-invoice-invoice-id-change-card-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./change-invoice-card-api-v-2-consumer-portal-profile-invoice-invoice-id-change-card-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Change Metered Subscription Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Change Metered Subscription Card"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/metered_subscriptions/{metered_subscription_id}/change-card"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Change the card used for a metered subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./change-metered-subscription-card-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-change-card-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./change-metered-subscription-card-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-change-card-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./change-metered-subscription-card-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-change-card-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Change Password

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Change Password"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/user/change-password"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Change user password.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./change-password-api-v-2-user-change-password-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./change-password-api-v-2-user-change-password-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Change Subscription Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Change Subscription Card"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/change-card"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Change the card used for auto-renewal payments on a subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./change-subscription-card-api-v-2-consumer-portal-profile-subscription-subscription-id-change-card-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./change-subscription-card-api-v-2-consumer-portal-profile-subscription-subscription-id-change-card-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./change-subscription-card-api-v-2-consumer-portal-profile-subscription-subscription-id-change-card-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Check Eligibility

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Check Eligibility"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/bnpl/eligibility"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check Eligibility

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./check-eligibility-api-v-2-bnpl-eligibility-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./check-eligibility-api-v-2-bnpl-eligibility-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Check Nafath Verification Request Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Check Nafath Verification Request Status"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/on-boarding/check-nafath-verification-status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check the status of a Nafath identity verification request.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./check-nafath-verification-request-status-api-v-2-public-on-boarding-check-nafath-verification-status-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./check-nafath-verification-request-status-api-v-2-public-on-boarding-check-nafath-verification-status-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Check Payment Link Bnpl Eligibility

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Check Payment Link Bnpl Eligibility"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment-link/{payment_link_id}/bnpl/eligibility"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check Payment Link Bnpl Eligibility

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./check-payment-link-bnpl-eligibility-api-v-2-consumer-portal-payment-link-payment-link-id-bnpl-eligibility-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./check-payment-link-bnpl-eligibility-api-v-2-consumer-portal-payment-link-payment-link-id-bnpl-eligibility-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./check-payment-link-bnpl-eligibility-api-v-2-consumer-portal-payment-link-payment-link-id-bnpl-eligibility-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Check a referral code

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Check a referral code"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/referral/codes/{code}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Used by the sign-up form to validate a code before the merchant can submit. Returns 404 for an unknown code and 400 for one that is no longer active.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./check-referral-code-api-v-2-referral-codes-code-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./check-referral-code-api-v-2-referral-codes-code-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./check-referral-code-api-v-2-referral-codes-code-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Consumer Profile Generate Mfa For Login

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Consumer Profile Generate Mfa For Login"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/consumer-profile/generate-login-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Generate MFA code for consumer profile login.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./consumer-profile-generate-mfa-for-login-api-v-2-authentication-consumer-profile-generate-login-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./consumer-profile-generate-mfa-for-login-api-v-2-authentication-consumer-profile-generate-login-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Consumer Profile Login Mfa For Access Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Consumer Profile Login Mfa For Access Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/consumer-profile/submit-login-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Verify consumer profile MFA code and receive access token.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./consumer-profile-login-mfa-for-access-token-api-v-2-authentication-consumer-profile-submit-login-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./consumer-profile-login-mfa-for-access-token-api-v-2-authentication-consumer-profile-submit-login-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Consumer Update Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Consumer Update Subscription"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Consumer-only subscription update flow (items/quantities only).

This endpoint is intentionally stricter than merchant update:
- accepts only ``items`` (no description, coupons, interval, cancellation, or payment-method overrides)
- rejects the update if the subscription currently has subscription-level coupons
- preserves existing item-level coupons for items that stay, and drops them when
  the item is removed/switched out
- applies add-on/switch/quantity validation via consumer_profile feature flags

Execution is all-or-none:
- if payment is required, neither the live subscription nor pending change is
  mutated yet; response is ``status=payment_required`` with ``payment_request`` and a
  plan preview (what is immediate after payment vs what remains scheduled)
- after successful payment reconciliation (redirect/webhook), immediate + deferred
  targets are applied idempotently
- if no payment is required, the update is applied immediately/scheduled per rules
  and response is ``status=update_scheduled`` with the updated subscription payload

Billing-cycle rules:
- same-cycle switch + add-on addition can require immediate proration for add-ons
  while keeping the product switch scheduled
- cross-cycle switch (e.g. monthly -> yearly) with compatible target items is fully
  scheduled (no immediate payment)
- incompatible target cycle mixes are rejected

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./consumer-update-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./consumer-update-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./consumer-update-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Account

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Account"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounts"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new bank account for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-account-api-v-2-accounts-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-account-api-v-2-accounts-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v1/invoices)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v1/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-1-invoices-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-1-invoices-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v2/api-keys)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/api-keys"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new API key for programmatic access.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-2-api-keys-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-2-api-keys-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v2/payments)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new payment for an invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-api-v-2-payments-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-2-payments-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-2-payments-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v2/public/waitlist)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/waitlist"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Add a user to the waitlist.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-api-v-2-public-waitlist-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-2-public-waitlist-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-2-public-waitlist-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v2/support)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/support"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new support ticket.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-2-support-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-2-support-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create (POST /api/v2/webhooks)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/webhooks"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new webhook endpoint to receive event notifications.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-api-v-2-webhooks-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-api-v-2-webhooks-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Branch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Branch"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/branch"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new branch for the organization.

If a branch with the same name already exists, returns the existing branch.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-branch-api-v-2-branch-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-branch-api-v-2-branch-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Consumer (POST /api/v1/consumers)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Consumer"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v1/consumers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new consumer with contact information and payment details.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-consumer-api-v-1-consumers-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-consumer-api-v-1-consumers-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Consumer (POST /api/v2/consumers)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Consumer"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new consumer with contact information and payment details.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-consumer-api-v-2-consumers-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-consumer-api-v-2-consumers-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Coupon

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Coupon"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/coupons"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new coupon with discount details and active/inactive status.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-coupon-api-v-2-coupons-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-coupon-api-v-2-coupons-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Discount Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Discount Rule"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/organization-settings/discount-rules"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create Discount Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-discount-rule-api-v-2-organization-settings-discount-rules-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-discount-rule-api-v-2-organization-settings-discount-rules-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Form (POST /api/v2/forms)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Form"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/forms"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-form-api-v-2-forms-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-form-api-v-2-forms-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Form (POST /api/v2/payment_link_forms)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Form"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payment_link_forms"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-form-api-v-2-payment-link-forms-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-form-api-v-2-payment-link-forms-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Installment Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Installment Rule"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/organization-settings/installment-rules"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create Installment Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-installment-rule-api-v-2-organization-settings-installment-rules-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-installment-rule-api-v-2-organization-settings-installment-rules-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Invite For A User To Join The Organization By Email

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Invite For A User To Join The Organization By Email"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/organization/invite"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Send an email invitation for a user to join the organization.

An invitation email will be sent to the specified address with a link to accept the invitation.
Organization admins can invite users to any branch, while branch admins can only invite to their own branches.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-invite-for-a-user-to-join-the-organization-by-email-api-v-2-organization-invite-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-invite-for-a-user-to-join-the-organization-by-email-api-v-2-organization-invite-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-invite-for-a-user-to-join-the-organization-by-email-api-v-2-organization-invite-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Invoice"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new invoice with items and payment details.

Important: For most use cases, use the Checkout/Payment Link API (`/v2/payment_links`) instead.
It generates a payment link that you can embed in your own web page or redirect to.

Use Cases:
- Create an invoice and manually mark it as paid for reference
- Automated invoice generation

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-invoice-api-v-2-invoices-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-invoice-api-v-2-invoices-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Metered Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Metered Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/metered_subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new metered subscription linking a METERED product to an organization consumer. The subscription is active immediately when its start time is reached. Usage can begin as soon as the subscription exists, and billing will use the subscription's billable window.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-metered-subscription-api-v-2-metered-subscriptions-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-metered-subscription-api-v-2-metered-subscriptions-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Organization

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Organization"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/organization"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new organization and associate it with the current user.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-organization-api-v-2-organization-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-organization-api-v-2-organization-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Payment Intent

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Payment Intent"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment-intent"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a payment intent before calling Moyasar.

The frontend calls this endpoint first to create an intent and get an intent_id.
This intent_id is then passed to Moyasar in the metadata.
When webhook/redirect happens, we extract payment_ids from the intent.
Requested installment settings are validated here and stored on the intent.

Validations:
- All payment IDs exist
- All payments belong to the same invoice
- All payments are unpaid (PENDING, PROCESSING, FAILED, FAILED_INITIATION)

Args:
    request: HTTP request (required by rate limiter)
    payment_intent_request: Request containing payment_ids
    payment_intent_service: Injected service instance

Returns:
    PaymentIntentResponse with intent_id and payment_ids

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-payment-intent-api-v-2-consumer-portal-payment-intent-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-payment-intent-api-v-2-consumer-portal-payment-intent-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Payment Link

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Payment Link"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payment_links"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new checkout/payment link for collecting payments.

- **One-time products**: Creates an invoice (with its associated payment) when paid.
- **Recurring products**: Creates a subscription (with its associated invoice and payment) when paid.

**Notes:**
- Cannot mix one-time and recurring products in the same payment link.
- Installments are automatically disabled for recurring products (subscriptions).
- Invoices, subscriptions and payments are created only after a successful payment.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-payment-link-api-v-2-payment-links-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-payment-link-api-v-2-payment-links-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Payment Link Form Submission

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Payment Link Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment-link/{payment_link_id}/form-submissions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a DRAFT form submission for a payment link so the payer can resume via submission id.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-payment-link-form-submission-api-v-2-consumer-portal-payment-link-payment-link-id-form-submissions-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-payment-link-form-submission-api-v-2-consumer-portal-payment-link-payment-link-id-form-submissions-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-payment-link-form-submission-api-v-2-consumer-portal-payment-link-payment-link-id-form-submissions-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Payment Link Intent

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Payment Link Intent"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment-link-intent"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a payment link intent before calling payment gateway.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-payment-link-intent-api-v-2-consumer-portal-payment-link-intent-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-payment-link-intent-api-v-2-consumer-portal-payment-link-intent-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create a consumer portal session

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create a consumer portal session"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/sessions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Creates a short-lived, single-use portal session token for a merchant-owned consumer. The returned URL can be used to redirect the consumer or embed the portal in an iframe.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-portal-session-api-v-2-consumer-portal-sessions-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-portal-session-api-v-2-consumer-portal-sessions-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/pricing_tables"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create an embeddable pricing table backed by existing products + prices.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-pricing-table-api-v-2-pricing-tables-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-pricing-table-api-v-2-pricing-tables-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Pricing Table Checkout

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Pricing Table Checkout"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/pricing_tables/{pricing_table_id}/checkout"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a checkout session backed by a one-shot Moyasar PaymentLink.

On success returns the consumer-portal `checkout_url`. If the resolved consumer
already has an active subscription and the table's `subscription_collision_policy`
is `BLOCK_WITH_MANAGE_URL`, returns 409 with `code: already_subscribed` and a
`manage_url` (when available).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-pricing-table-checkout-api-v-2-public-pricing-tables-pricing-table-id-checkout-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-pricing-table-checkout-api-v-2-public-pricing-tables-pricing-table-id-checkout-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-pricing-table-checkout-api-v-2-public-pricing-tables-pricing-table-id-checkout-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Pricing Table Customer Session

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Pricing Table Customer Session"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/pricing_tables/{pricing_table_id}/customer_sessions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Issue a short-lived signed `client_secret` for the embed.

The frontend SDK passes the returned token as `customer-session-client-secret`
on `<stream-pricing-table>` to enable viewer-aware features (current plan,
upgrade/downgrade hints, manage URL, "block if already subscribed").

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-pricing-table-customer-session-api-v-2-pricing-tables-pricing-table-id-customer-sessions-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-pricing-table-customer-session-api-v-2-pricing-tables-pricing-table-id-customer-sessions-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-pricing-table-customer-session-api-v-2-pricing-tables-pricing-table-id-customer-sessions-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Product

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Product"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/products"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new product with pricing and description.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-product-api-v-2-products-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-product-api-v-2-products-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Product Switch Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Product Switch Group"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/product-switch-groups"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a product switch group and optional initial product memberships.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-product-switch-group-api-v-2-product-switch-groups-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-product-switch-group-api-v-2-product-switch-groups-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Quantity Change Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Quantity Change Group"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/quantity-changes"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create Quantity Change Group

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-quantity-change-group-api-v-2-quantity-changes-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-quantity-change-group-api-v-2-quantity-changes-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Scope Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Scope Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/connections/{connection_id}/scope-requests"}
  context={"endpoint"}
>
  
</MethodEndpoint>

201 for a new request; 200 with the pending one, unchanged, when there already is one.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./create-scope-request-api-v-2-connected-apps-connections-connection-id-scope-requests-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-scope-request-api-v-2-connected-apps-connections-connection-id-scope-requests-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-scope-request-api-v-2-connected-apps-connections-connection-id-scope-requests-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Scope Request From App

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Scope Request From App"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/scope-requests"}
  context={"endpoint"}
>
  
</MethodEndpoint>

The assistant asks for write access on the connection it is calling under.

The one route in this package for a delegated caller. It goes through the general
``get_current_user`` so that the delegated resolver runs with all of its gates (live
grant, admission, allow-list); the service then refuses any caller that did not
arrive as a delegated one. No permission is checked, so a read-only connection can ask.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-scope-request-from-app-api-v-2-connected-apps-scope-requests-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-scope-request-from-app-api-v-2-connected-apps-scope-requests-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Create Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Create Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create a new subscription with items, coupons, and payment methods.

Important: For most use cases, use the Checkout/Payment Link API (`/v2/payment_links`) instead.
It generates a payment link that you can embed in your own web page or redirect to.

Use Cases:
- Create a subscription and manually marking it as paid for reference
- Automated subscription creation

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./create-subscription-api-v-2-subscriptions-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./create-subscription-api-v-2-subscriptions-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Data Entry

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Data Entry"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/data-entry"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit confirmed business/owner data (data entry step).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./data-entry-api-v-2-kyb-data-entry-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./data-entry-api-v-2-kyb-data-entry-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Deactivate Accounting Provider

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Deactivate Accounting Provider"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/deactivate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Deactivate a configured provider. Stream will never push to it while inactive.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./deactivate-accounting-provider-api-v-2-accounting-provider-deactivate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./deactivate-accounting-provider-api-v-2-accounting-provider-deactivate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./deactivate-accounting-provider-api-v-2-accounting-provider-deactivate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Deactivate Metered Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Deactivate Metered Subscription"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/metered_subscriptions/{subscription_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Deactivate a metered subscription by setting its end time to now. This subscription stops being billable after this exact time. Note: deactivated subscriptions can still have usage recorded; it won't be billed.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./deactivate-metered-subscription-api-v-2-metered-subscriptions-subscription-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./deactivate-metered-subscription-api-v-2-metered-subscriptions-subscription-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./deactivate-metered-subscription-api-v-2-metered-subscriptions-subscription-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Deactivate Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Deactivate Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/pricing_tables/{pricing_table_id}/deactivate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Deactivate Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./deactivate-pricing-table-api-v-2-pricing-tables-pricing-table-id-deactivate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./deactivate-pricing-table-api-v-2-pricing-tables-pricing-table-id-deactivate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./deactivate-pricing-table-api-v-2-pricing-tables-pricing-table-id-deactivate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Account

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Account"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/accounts/{account_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a bank account from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-account-api-v-2-accounts-account-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-account-api-v-2-accounts-account-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-account-api-v-2-accounts-account-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/webhooks/{webhook_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a webhook endpoint.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-api-v-2-webhooks-webhook-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-api-v-2-webhooks-webhook-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-api-v-2-webhooks-webhook-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Branch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Branch"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/branch/{branch_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a branch from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-branch-api-v-2-branch-branch-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-branch-api-v-2-branch-branch-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-branch-api-v-2-branch-branch-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete By Api Key

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete By Api Key"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/api-keys/{api_key}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Revoke an API key.

Organization admins can revoke any API key in the organization.
Regular users can only revoke API keys they created.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-by-api-key-api-v-2-api-keys-api-key-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-by-api-key-api-v-2-api-keys-api-key-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-by-api-key-api-v-2-api-keys-api-key-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Connection

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Connection"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/connected-apps/connections/{connection_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Connection

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-connection-api-v-2-connected-apps-connections-connection-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-connection-api-v-2-connected-apps-connections-connection-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-connection-api-v-2-connected-apps-connections-connection-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Consumer (DELETE /api/v1/consumers/{org_consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Consumer"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v1/consumers/{org_consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a consumer from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-consumer-api-v-1-consumers-org-consumer-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-consumer-api-v-1-consumers-org-consumer-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-consumer-api-v-1-consumers-org-consumer-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Consumer (DELETE /api/v2/consumers/{consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Consumer"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/consumers/{consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a consumer from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-consumer-api-v-2-consumers-consumer-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-consumer-api-v-2-consumers-consumer-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-consumer-api-v-2-consumers-consumer-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Consumer Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Consumer Card"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/consumer_portal/profile/cards/{card_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a card if it's not associated with active subscriptions or ongoing installment invoices.

This performs a soft delete by setting is_deleted=True and deleted_at timestamp.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-consumer-card-api-v-2-consumer-portal-profile-cards-card-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-consumer-card-api-v-2-consumer-portal-profile-cards-card-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-consumer-card-api-v-2-consumer-portal-profile-cards-card-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Coupon

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Coupon"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/coupons/{coupon_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a coupon from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-coupon-api-v-2-coupons-coupon-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-coupon-api-v-2-coupons-coupon-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-coupon-api-v-2-coupons-coupon-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Discount Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Discount Rule"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/organization-settings/discount-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Discount Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Form (DELETE /api/v2/forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Form"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-form-api-v-2-forms-form-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-form-api-v-2-forms-form-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-form-api-v-2-forms-form-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Form (DELETE /api/v2/payment_link_forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Form"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/payment_link_forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-form-api-v-2-payment-link-forms-form-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-form-api-v-2-payment-link-forms-form-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-form-api-v-2-payment-link-forms-form-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Installment Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Installment Rule"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/organization-settings/installment-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Installment Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Invoices

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Invoices"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete all invoices (non-production environments only).

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-invoices-api-v-2-invoices-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-invoices-api-v-2-invoices-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Payment"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/payments/{payment_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a payment record.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-payment-api-v-2-payments-payment-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-payment-api-v-2-payments-payment-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-payment-api-v-2-payments-payment-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Payment Link Document

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Payment Link Document"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/payment_links/documents/{document_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a payment link document (attached or not yet attached).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-payment-link-document-api-v-2-payment-links-documents-document-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-payment-link-document-api-v-2-payment-links-documents-document-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-payment-link-document-api-v-2-payment-links-documents-document-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/pricing_tables/{pricing_table_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-pricing-table-api-v-2-pricing-tables-pricing-table-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-pricing-table-api-v-2-pricing-tables-pricing-table-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-pricing-table-api-v-2-pricing-tables-pricing-table-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Product

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Product"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/products/{product_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete a product from the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-product-api-v-2-products-product-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-product-api-v-2-products-product-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-product-api-v-2-products-product-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Product Price

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Product Price"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/products/{product_id}/prices/{price_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Archive (soft delete) a product price.

Cannot delete the last active price for a product. Each product must
have at least one active price.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-product-price-api-v-2-products-product-id-prices-price-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-product-price-api-v-2-products-product-id-prices-price-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-product-price-api-v-2-products-product-id-prices-price-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Product Switch Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Product Switch Group"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/product-switch-groups/{group_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Soft-delete a product switch group and remove product memberships.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-product-switch-group-api-v-2-product-switch-groups-group-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-product-switch-group-api-v-2-product-switch-groups-group-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-product-switch-group-api-v-2-product-switch-groups-group-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Quantity Change Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Quantity Change Group"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/quantity-changes/{group_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete Quantity Change Group

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-quantity-change-group-api-v-2-quantity-changes-group-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-quantity-change-group-api-v-2-quantity-changes-group-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-quantity-change-group-api-v-2-quantity-changes-group-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Subscription Freeze

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Subscription Freeze"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/subscriptions/{subscription_id}/freeze/{freeze_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Remove a freeze period from a subscription.

Deletes the specified freeze period, allowing the subscription to resume normal invoice
generation immediately (if the freeze period was active).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./delete-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Delete Subscriptions

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Delete Subscriptions"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Delete all subscriptions (non-production environments only).

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./delete-subscriptions-api-v-2-subscriptions-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./delete-subscriptions-api-v-2-subscriptions-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Document Upload

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Document Upload"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/document-upload"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit business documents for onboarding (document upload step).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./document-upload-api-v-2-kyb-document-upload-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./document-upload-api-v-2-kyb-document-upload-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Document Upload Extraction Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Document Upload Extraction Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/kyb/document-upload/status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Poll the async extraction job queued by the last document-upload call.

Returns None if no job was ever queued, or it has expired, a PENDING/PROCESSING status while
the extraction is still running, or SUCCESS/FAILED once it's done.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./document-upload-extraction-status-api-v-2-kyb-document-upload-status-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./document-upload-extraction-status-api-v-2-kyb-document-upload-status-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Esign Webhook

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Esign Webhook"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/esign/webhook"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle e-signature webhook notifications for envelope status updates.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./esign-webhook-api-v-2-esign-webhook-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./esign-webhook-api-v-2-esign-webhook-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./esign-webhook-api-v-2-esign-webhook-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Exchange a portal session token for a consumer access token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Exchange a portal session token for a consumer access token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/sessions/exchange"}
  context={"endpoint"}
>
  
</MethodEndpoint>

The portal frontend calls this endpoint to exchange a short-lived, single-use session token for a standard consumer JWT. The token is invalidated after first use.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./exchange-portal-session-token-api-v-2-consumer-portal-sessions-exchange-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./exchange-portal-session-token-api-v-2-consumer-portal-sessions-exchange-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Export Task

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Export Task"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/export"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create an export task to generate reports in various formats.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./export-task-api-v-2-export-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./export-task-api-v-2-export-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Export Task Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Export Task Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/export/{export_task_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the status and download link of an export task.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./export-task-status-api-v-2-export-export-task-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./export-task-status-api-v-2-export-export-task-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./export-task-status-api-v-2-export-export-task-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Forgot Password

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Forgot Password"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/forgot-password"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Initiate password reset process by sending verification code to user email.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./forgot-password-api-v-2-authentication-forgot-password-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./forgot-password-api-v-2-authentication-forgot-password-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Freeze Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Freeze Subscription"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/subscriptions/{subscription_id}/freeze"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Freeze a subscription to pause invoice generation for a specific period.

During the freeze period, no invoices will be generated for the subscription. The subscription
will automatically resume after the freeze period ends.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./freeze-subscription-api-v-2-subscriptions-subscription-id-freeze-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./freeze-subscription-api-v-2-subscriptions-subscription-id-freeze-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./freeze-subscription-api-v-2-subscriptions-subscription-id-freeze-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Generate An Mfa For Verifying An Identifier

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Generate An Mfa For Verifying An Identifier"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/on-boarding/generate-identification-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Generate a multi-factor authentication code for identity verification.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./generate-an-mfa-for-verifying-an-identifier-api-v-2-public-on-boarding-generate-identification-mfa-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./generate-an-mfa-for-verifying-an-identifier-api-v-2-public-on-boarding-generate-identification-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./generate-an-mfa-for-verifying-an-identifier-api-v-2-public-on-boarding-generate-identification-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Generate Mfa For Login

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Generate Mfa For Login"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/generate-login-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Generate and send multi-factor authentication code for login.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./generate-mfa-for-login-api-v-2-authentication-generate-login-mfa-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./generate-mfa-for-login-api-v-2-authentication-generate-login-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./generate-mfa-for-login-api-v-2-authentication-generate-login-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Generate Mfa For Phone Verification

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Generate Mfa For Phone Verification"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/user/generate-phone-verification-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Generate and send multi-factor authentication code for phone verification.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./generate-mfa-for-phone-verification-api-v-2-user-generate-phone-verification-mfa-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./generate-mfa-for-phone-verification-api-v-2-user-generate-phone-verification-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./generate-mfa-for-phone-verification-api-v-2-user-generate-phone-verification-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Generate Nafath Verification Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Generate Nafath Verification Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/on-boarding/initiate-nafath-verification"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Initiate Nafath identity verification request.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./generate-nafath-verification-request-api-v-2-public-on-boarding-initiate-nafath-verification-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./generate-nafath-verification-request-api-v-2-public-on-boarding-initiate-nafath-verification-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Accounting Provider Branch Mappings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Accounting Provider Branch Mappings"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/{provider}/branches"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Read back this organization's saved Stream-branch -&gt; platform-branch mappings.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Accounting Provider Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Accounting Provider Config"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/{provider}/config"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Read back this organization's stored config field values. Never includes credentials/tokens.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-accounting-provider-config-api-v-2-accounting-provider-config-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-accounting-provider-config-api-v-2-accounting-provider-config-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-accounting-provider-config-api-v-2-accounting-provider-config-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Accounting Provider Metadata

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Accounting Provider Metadata"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/{provider}/metadata"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Describe what fields an accounting provider needs, driving the frontend's setup form.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-accounting-provider-metadata-api-v-2-accounting-provider-metadata-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-accounting-provider-metadata-api-v-2-accounting-provider-metadata-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-accounting-provider-metadata-api-v-2-accounting-provider-metadata-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Accounts

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Accounts"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounts"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all bank accounts configured for the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-accounts-api-v-2-accounts-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-accounts-api-v-2-accounts-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All (GET /api/v1/invoices)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all invoices with pagination, filtering, and sorting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-api-v-1-invoices-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-api-v-1-invoices-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-api-v-1-invoices-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All (GET /api/v2/api-keys)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/api-keys"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all API keys for the organization.

Organization admins see all API keys.
Regular users see only API keys they created.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-api-v-2-api-keys-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-api-v-2-api-keys-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All (GET /api/v2/bank-transfer)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bank-transfer"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all bank transfer settlements with pagination, filtering, and sorting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-api-v-2-bank-transfer-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-api-v-2-bank-transfer-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-api-v-2-bank-transfer-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All (GET /api/v2/webhooks)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/webhooks"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all webhooks configured for the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-api-v-2-webhooks-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-api-v-2-webhooks-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Branches

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Branches"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/branch"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all branches for the organization.

Returns branches based on user role:
- Organization admins see all branches in the organization
- Branch admins and branch users see only branches they're assigned to

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-branches-api-v-2-branch-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-branches-api-v-2-branch-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Consumers (GET /api/v1/consumers)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Consumers"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/consumers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all consumers with filtering options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-consumers-api-v-1-consumers-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-consumers-api-v-1-consumers-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-consumers-api-v-1-consumers-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Consumers (GET /api/v2/consumers)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Consumers"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List consumers with pagination, sorting, and optional filters.

**Query filters** (all optional; combine as needed):
- `search_term` — partial match on name, email, phone, alias, external_id,
  associated entity name, or associated entity field values

**External metadata filters** (optional, combine with other filters):
- Use any external metadata key you stored on create/update as a query parameter: `external_metadata.<key>=<value>`
- Exact match, case-sensitive. Multiple keys are ANDed.
- Example: if a consumer was created with `"external_metadata": {"segment": "enterprise", "tier": "gold"}`, filter with
  `?external_metadata.segment=enterprise&external_metadata.tier=gold`

**Pagination**: `page` (default 1), `limit` (default 10, max 100)

**Sorting**: `sort_field` (`name`, `created_at`, `email`, `phone_number`, `external_id`; default `created_at`),
`sort_direction` (`asc` or `desc`; default `desc`)

**Example**: `/api/v2/consumers?search_term=Acme&external_metadata.segment=enterprise&page=1&limit=20`

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-consumers-api-v-2-consumers-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-consumers-api-v-2-consumers-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-consumers-api-v-2-consumers-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Invoices

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Invoices"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all invoices for the authenticated consumer with pagination, filtering, and sorting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-invoices-api-v-2-consumer-portal-profile-invoices-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-invoices-api-v-2-consumer-portal-profile-invoices-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-invoices-api-v-2-consumer-portal-profile-invoices-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Organization Users

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Organization Users"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization/users"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all users who are members of the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-organization-users-api-v-2-organization-users-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-organization-users-api-v-2-organization-users-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get All Subscriptions

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get All Subscriptions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all subscriptions for the authenticated consumer with pagination, filtering, and sorting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-all-subscriptions-api-v-2-consumer-portal-profile-subscriptions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-all-subscriptions-api-v-2-consumer-portal-profile-subscriptions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-all-subscriptions-api-v-2-consumer-portal-profile-subscriptions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get (GET /api/v1/invoices/{invoice_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/invoices/{invoice_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get invoice by ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-api-v-1-invoices-invoice-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-api-v-1-invoices-invoice-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-api-v-1-invoices-invoice-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get (GET /api/v2/short-url/{short_url_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/short-url/{short_url_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Redirect from short URL to the original destination URL.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-api-v-2-short-url-short-url-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-api-v-2-short-url-short-url-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-api-v-2-short-url-short-url-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get (GET /api/v2/webhooks/{webhook_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/webhooks/{webhook_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific webhook by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-api-v-2-webhooks-webhook-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-api-v-2-webhooks-webhook-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-api-v-2-webhooks-webhook-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Available Events

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Available Events"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/webhooks/events"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all available webhook events that can be subscribed to.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-available-events-api-v-2-webhooks-events-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-available-events-api-v-2-webhooks-events-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Bnpl Order Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Bnpl Order Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/bnpl/orders/{order_id}/status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Bnpl Order Status

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-bnpl-order-status-api-v-2-consumer-portal-consent-consent-id-bnpl-orders-order-id-status-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-bnpl-order-status-api-v-2-consumer-portal-consent-consent-id-bnpl-orders-order-id-status-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-bnpl-order-status-api-v-2-consumer-portal-consent-consent-id-bnpl-orders-order-id-status-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Branch By Id

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Branch By Id"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/branch/{branch_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific branch by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-branch-by-id-api-v-2-branch-branch-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-branch-by-id-api-v-2-branch-branch-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-branch-by-id-api-v-2-branch-branch-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get By Id

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get By Id"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounts/{account_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific bank account by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-by-id-api-v-2-accounts-account-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-by-id-api-v-2-accounts-account-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-by-id-api-v-2-accounts-account-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Connected Apps Authorization Server Metadata

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Connected Apps Authorization Server Metadata"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/.well-known/oauth-authorization-server/api/v2/connected-apps"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Connected Apps Authorization Server Metadata

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-connected-apps-authorization-server-metadata-well-known-oauth-authorization-server-api-v-2-connected-apps-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-connected-apps-authorization-server-metadata-well-known-oauth-authorization-server-api-v-2-connected-apps-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Connected Apps Key Set

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Connected Apps Key Set"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/oauth/jwks"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Connected Apps Key Set

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-connected-apps-key-set-api-v-2-connected-apps-oauth-jwks-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-connected-apps-key-set-api-v-2-connected-apps-oauth-jwks-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Connection Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Connection Request"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/connection-requests/{request_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Connection Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-connection-request-api-v-2-connected-apps-connection-requests-request-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-connection-request-api-v-2-connected-apps-connection-requests-request-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-connection-request-api-v-2-connected-apps-connection-requests-request-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consent Payment Pdf Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consent Payment Pdf Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/payment-pdf"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return payment invoice PDF status for a consent; starts generation when not completed.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-consent-payment-pdf-status-api-v-2-consumer-portal-consent-consent-id-payment-pdf-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consent-payment-pdf-status-api-v-2-consumer-portal-consent-consent-id-payment-pdf-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consent-payment-pdf-status-api-v-2-consumer-portal-consent-consent-id-payment-pdf-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer (GET /api/v1/consumers/{consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/consumers/{consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific consumer by their ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-consumer-api-v-1-consumers-consumer-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-api-v-1-consumers-consumer-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-api-v-1-consumers-consumer-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer (GET /api/v2/consumers/{consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumers/{consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific consumer by their ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-consumer-api-v-2-consumers-consumer-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-api-v-2-consumers-consumer-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-api-v-2-consumers-consumer-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer Card List

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer Card List"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/cards"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get a list of cards for a consumer.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-card-list-api-v-2-consumer-portal-profile-cards-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-card-list-api-v-2-consumer-portal-profile-cards-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer Insights

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer Insights"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumers/{org_consumer_id}/insights"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get analytics and insights for a specific consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-consumer-insights-api-v-2-consumers-org-consumer-id-insights-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-insights-api-v-2-consumers-org-consumer-id-insights-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-insights-api-v-2-consumers-org-consumer-id-insights-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer Me

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer Me"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/consumer/me"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get profile information for the currently logged-in consumer.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-me-api-v-2-consumer-portal-profile-consumer-me-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-me-api-v-2-consumer-portal-profile-consumer-me-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Consumer Portal Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Consumer Portal Config"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/config"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get public consumer portal configuration by lookup ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-consumer-portal-config-api-v-2-consumer-portal-config-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-consumer-portal-config-api-v-2-consumer-portal-config-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-consumer-portal-config-api-v-2-consumer-portal-config-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Conversion Rates

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Conversion Rates"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/conversion-rates"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get conversion rates payload for the frontend consumer portal.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-conversion-rates-api-v-2-consumer-portal-conversion-rates-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-conversion-rates-api-v-2-consumer-portal-conversion-rates-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Coupon

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Coupon"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/coupons/{coupon_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific coupon including redemption history.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-coupon-api-v-2-coupons-coupon-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-coupon-api-v-2-coupons-coupon-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-coupon-api-v-2-coupons-coupon-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Deliveries

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Deliveries"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/webhook-deliveries/by-webhook/{webhook_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get all deliveries for a webhook. Limited to latest 100 deliveries only.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-deliveries-api-v-2-webhook-deliveries-by-webhook-webhook-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-deliveries-api-v-2-webhook-deliveries-by-webhook-webhook-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-deliveries-api-v-2-webhook-deliveries-by-webhook-webhook-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Delivery By Id

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Delivery By Id"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/webhook-deliveries/{webhook_delivery_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get a webhook delivery by ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-delivery-by-id-api-v-2-webhook-deliveries-webhook-delivery-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-delivery-by-id-api-v-2-webhook-deliveries-webhook-delivery-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-delivery-by-id-api-v-2-webhook-deliveries-webhook-delivery-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Details (GET /api/v1/invoices/{invoice_id}/details)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/invoices/{invoice_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get detailed information about an invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-details-api-v-1-invoices-invoice-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-details-api-v-1-invoices-invoice-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-details-api-v-1-invoices-invoice-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Details (GET /api/v2/consumer_portal/consent/{consent_id}/details)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get detailed information about a payment consent including invoice and payment options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-details-api-v-2-consumer-portal-consent-consent-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-details-api-v-2-consumer-portal-consent-consent-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-details-api-v-2-consumer-portal-consent-consent-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Discount Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Discount Rule"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/discount-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Discount Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Email Template Configuration

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Email Template Configuration"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/email-template"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return the organization's notification email template configuration.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-email-template-configuration-api-v-2-email-template-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-email-template-configuration-api-v-2-email-template-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Form (GET /api/v2/forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Form"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-form-api-v-2-forms-form-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-form-api-v-2-forms-form-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-form-api-v-2-forms-form-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Form (GET /api/v2/payment_link_forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Form"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_link_forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-form-api-v-2-payment-link-forms-form-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-form-api-v-2-payment-link-forms-form-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-form-api-v-2-payment-link-forms-form-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Form Submission (GET /api/v2/consumer_portal/form-submissions/{submission_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/form-submissions/{submission_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Resume a form submission (answers + uploaded documents with short-lived URLs).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Form Submission (GET /api/v2/forms/{form_id}/submissions/{submission_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/forms/{form_id}/submissions/{submission_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Form Submission

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-form-submission-api-v-2-forms-form-id-submissions-submission-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-form-submission-api-v-2-forms-form-id-submissions-submission-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-form-submission-api-v-2-forms-form-id-submissions-submission-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Form Submission (GET /api/v2/payment_link_forms/{form_id}/submissions/{submission_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_link_forms/{form_id}/submissions/{submission_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Form Submission

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-form-submission-api-v-2-payment-link-forms-form-id-submissions-submission-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-form-submission-api-v-2-payment-link-forms-form-id-submissions-submission-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-form-submission-api-v-2-payment-link-forms-form-id-submissions-submission-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Installment Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Installment Rule"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/installment-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Installment Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Invoice"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoices/{invoice_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific invoice by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-invoice-api-v-2-invoices-invoice-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-invoice-api-v-2-invoices-invoice-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-invoice-api-v-2-invoices-invoice-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Invoice Batch Example Csv

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Invoice Batch Example Csv"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoice-batches/example"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Invoice Batch Example Csv

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-invoice-batch-example-csv-api-v-2-invoice-batches-example-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-invoice-batch-example-csv-api-v-2-invoice-batches-example-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Invoice Consent Url

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Invoice Consent Url"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoices/{invoice_id}/consent_url"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the payment consent URL for an invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-invoice-consent-url-api-v-2-invoices-invoice-id-consent-url-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-invoice-consent-url-api-v-2-invoices-invoice-id-consent-url-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-invoice-consent-url-api-v-2-invoices-invoice-id-consent-url-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Invoice Details

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Invoice Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/invoice/{invoice_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get detailed information about an invoice for the authenticated consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-invoice-details-api-v-2-consumer-portal-profile-invoice-invoice-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-invoice-details-api-v-2-consumer-portal-profile-invoice-invoice-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-invoice-details-api-v-2-consumer-portal-profile-invoice-invoice-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Metered Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Metered Subscription"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/metered_subscriptions/{subscription_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve a metered subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-metered-subscription-api-v-2-metered-subscriptions-subscription-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-metered-subscription-api-v-2-metered-subscriptions-subscription-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-metered-subscription-api-v-2-metered-subscriptions-subscription-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Metered Subscription Details

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Metered Subscription Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/metered_subscriptions/{metered_subscription_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get details for a consumer's metered subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-metered-subscription-details-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-metered-subscription-details-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-metered-subscription-details-api-v-2-consumer-portal-profile-metered-subscriptions-metered-subscription-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Org All Payments

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Org All Payments"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization/payments"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all payments across the organization with pagination, filtering, and sorting.

Note: When `view` is provided, filter parameters (statuses, from_date, to_date) are ignored
and determined by the view, but search_term is preserved.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-org-all-payments-api-v-2-organization-payments-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-org-all-payments-api-v-2-organization-payments-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-org-all-payments-api-v-2-organization-payments-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Organization Accounting Posting Behavior

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Organization Accounting Posting Behavior"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization/posting-behavior"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the organization's accounting posting settings.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-organization-accounting-posting-behavior-api-v-2-organization-posting-behavior-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-organization-accounting-posting-behavior-api-v-2-organization-posting-behavior-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Organization Address

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Organization Address"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/address"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the organization's national address; fields are null until it is set.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-organization-address-api-v-2-organization-settings-address-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-organization-address-api-v-2-organization-settings-address-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Organization Refund Policy

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Organization Refund Policy"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization/refund-policy"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the latest refund policy for the current organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-organization-refund-policy-api-v-2-organization-refund-policy-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-organization-refund-policy-api-v-2-organization-refund-policy-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Own Connection

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Own Connection"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/connections/current"}
  context={"endpoint"}
>
  
</MethodEndpoint>

A connected app reads the connection its credential belongs to, branches included.

For a connected app only, with either credential. Like the assistant's scope-request
route it goes through ``get_current_user`` so the resolver runs with all of its gates,
and the service refuses any caller that did not arrive as a connected app. No permission
is checked, so it works whatever the connection's scopes are.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-own-connection-api-v-2-connected-apps-connections-current-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-own-connection-api-v-2-connected-apps-connections-current-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payments/{payment_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific payment by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-payment-api-v-2-payments-payment-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-api-v-2-payments-payment-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-api-v-2-payments-payment-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment Gateway Activities

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment Gateway Activities"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payments/{payment_id}/gateway-activities"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List distinct payment gateway statuses for a payment, newest first.

Duplicate reports of the same status for one gateway payment are collapsed into one activity.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-payment-gateway-activities-api-v-2-payments-payment-id-gateway-activities-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-gateway-activities-api-v-2-payments-payment-id-gateway-activities-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-gateway-activities-api-v-2-payments-payment-id-gateway-activities-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment Link

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment Link"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_links/{payment_link_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific payment link by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-payment-link-api-v-2-payment-links-payment-link-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-link-api-v-2-payment-links-payment-link-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-link-api-v-2-payment-links-payment-link-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment Link Details

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment Link Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/payment-link/{payment_link_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get detailed information about a payment link.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-payment-link-details-api-v-2-consumer-portal-payment-link-payment-link-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-link-details-api-v-2-consumer-portal-payment-link-payment-link-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-link-details-api-v-2-consumer-portal-payment-link-payment-link-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment Link Insights

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment Link Insights"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_links/{payment_link_id}/insights"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get analytics and insights for a specific payment link.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-payment-link-insights-api-v-2-payment-links-payment-link-id-insights-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-link-insights-api-v-2-payment-links-payment-link-id-insights-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-link-insights-api-v-2-payment-links-payment-link-id-insights-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Payment Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Payment Request"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/payment-request"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get payment request configuration for consumer with amount 1 and save_card=true.

This endpoint returns a payment request object similar to invoice payment requests
but with fixed amount of 1 and save_card always true for both credit card and Apple Pay.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-payment-request-api-v-2-consumer-portal-profile-payment-request-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-payment-request-api-v-2-consumer-portal-profile-payment-request-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/pricing_tables/{pricing_table_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-pricing-table-api-v-2-pricing-tables-pricing-table-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-pricing-table-api-v-2-pricing-tables-pricing-table-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-pricing-table-api-v-2-pricing-tables-pricing-table-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Product

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Product"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/products/{product_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific product by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-product-api-v-2-products-product-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-product-api-v-2-products-product-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-product-api-v-2-products-product-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Product Insights

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Product Insights"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/products/{product_id}/insights"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get analytics and insights for a specific product.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-product-insights-api-v-2-products-product-id-insights-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-product-insights-api-v-2-products-product-id-insights-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-product-insights-api-v-2-products-product-id-insights-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Product Switch Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Product Switch Group"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/product-switch-groups/{group_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get a single product switch group with product IDs.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-product-switch-group-api-v-2-product-switch-groups-group-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-product-switch-group-api-v-2-product-switch-groups-group-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-product-switch-group-api-v-2-product-switch-groups-group-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Public Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Public Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/public/pricing_tables/{pricing_table_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get Public Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-public-pricing-table-api-v-2-public-pricing-tables-pricing-table-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-public-pricing-table-api-v-2-public-pricing-tables-pricing-table-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-public-pricing-table-api-v-2-public-pricing-tables-pricing-table-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Public Pricing Table With Viewer

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Public Pricing Table With Viewer"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/public/pricing_tables/{pricing_table_id}/me"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Same as GET / but `Authorization: Bearer <client_secret>` is required.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-public-pricing-table-with-viewer-api-v-2-public-pricing-tables-pricing-table-id-me-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-public-pricing-table-with-viewer-api-v-2-public-pricing-tables-pricing-table-id-me-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-public-pricing-table-with-viewer-api-v-2-public-pricing-tables-pricing-table-id-me-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Related Companies

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Related Companies"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/user/related-companies"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get all companies/organizations that the user belongs to.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-related-companies-api-v-2-user-related-companies-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-related-companies-api-v-2-user-related-companies-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Subscribers By Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Subscribers By Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v1/subscribers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get list of subscribers filtered by their subscription status.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-subscribers-by-status-api-v-1-subscribers-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-subscribers-by-status-api-v-1-subscribers-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-subscribers-by-status-api-v-1-subscribers-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Subscription"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/subscriptions/{subscription_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve detailed information about a specific subscription by its ID.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-subscription-api-v-2-subscriptions-subscription-id-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-subscription-api-v-2-subscriptions-subscription-id-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-subscription-api-v-2-subscriptions-subscription-id-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Subscription Details

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Subscription Details"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/details"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get detailed information about a subscription for the authenticated consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-subscription-details-api-v-2-consumer-portal-profile-subscription-subscription-id-details-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-subscription-details-api-v-2-consumer-portal-profile-subscription-subscription-id-details-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-subscription-details-api-v-2-consumer-portal-profile-subscription-subscription-id-details-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Subscription Insights

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Subscription Insights"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/subscriptions/{subscription_id}/insights"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get analytics and insights for a specific subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-subscription-insights-api-v-2-subscriptions-subscription-id-insights-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-subscription-insights-api-v-2-subscriptions-subscription-id-insights-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-subscription-insights-api-v-2-subscriptions-subscription-id-insights-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Template Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Template Config"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoice-template"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get invoice template configuration.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-template-config-api-v-2-invoice-template-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-template-config-api-v-2-invoice-template-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Top Used Products

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Top Used Products"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/products/top-used"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return the most frequently used products.

Uses the same filters as list products, plus `n`.

**Query filters** (all optional; combine as needed):
- `search_term` — partial match on product name or description
- `active` — `true` for active products only, `false` for inactive only
- `type` — product type: `RECURRING`, `ONE_OFF`, or `METERED` (when enabled)
- `currency` — only products with an active price in this ISO currency code (e.g. `SAR`)
- `n` — number of results to return (1-10, default 9)

**External metadata filters** (optional, combine with other filters):
- Use any external metadata key you stored on create/update as a query parameter: `external_metadata.<key>=<value>`
- Exact match, case-sensitive. Multiple keys are ANDed.
- Example: if a consumer was created with `"external_metadata": {"segment": "enterprise", "tier": "gold"}`, filter with
  `?external_metadata.segment=enterprise&external_metadata.tier=gold`

**Sorting**: `sort_field` (`price`, `name`, `created_at`; default `created_at`),
`sort_direction` (`asc` or `desc`; default `desc`)

**Example**: `/api/v2/products/top-used?n=5&active=true&external_metadata.plan=pro`

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-top-used-products-api-v-2-products-top-used-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-top-used-products-api-v-2-products-top-used-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-top-used-products-api-v-2-products-top-used-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Total Settlement Sum

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Total Settlement Sum"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bank-transfer/total-sum"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the total sum of all settlements based on filters.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-total-settlement-sum-api-v-2-bank-transfer-total-sum-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-total-settlement-sum-api-v-2-bank-transfer-total-sum-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-total-settlement-sum-api-v-2-bank-transfer-total-sum-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Total Unsettled Sum

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Total Unsettled Sum"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bank-transfer/total-unsettled-sum"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the total sum of all unsettled transfers based on filters.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./get-total-unsettled-sum-api-v-2-bank-transfer-total-unsettled-sum-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-total-unsettled-sum-api-v-2-bank-transfer-total-unsettled-sum-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-total-unsettled-sum-api-v-2-bank-transfer-total-unsettled-sum-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get User And Organization Info

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get User And Organization Info"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/me"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Retrieve information about the authenticated user and their organization.

It requires a valid authentication token and can be used to verify API
connectivity and retrieve user context. This endpoint returns details about the currently
authenticated user and their associated organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-user-and-organization-info-api-v-2-me-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-user-and-organization-info-api-v-2-me-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get User"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/user"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get current user profile information.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-user-api-v-2-user-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-user-api-v-2-user-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get User Roles Permission

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get User Roles Permission"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/authorization/permissions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get all permissions granted to the user based on their roles.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-user-roles-permission-api-v-2-authorization-permissions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-user-roles-permission-api-v-2-authorization-permissions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Get Zendesk Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Get Zendesk Token"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/zendesk/token"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get a Zendesk token for the authenticated user.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./get-zendesk-token-api-v-2-zendesk-token-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./get-zendesk-token-api-v-2-zendesk-token-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Gmv

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Gmv"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/past-gmv"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set the past GMV for organization before Stream.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./gmv-api-v-2-organization-past-gmv-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./gmv-api-v-2-organization-past-gmv-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Health check endpoint

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Health check endpoint"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/health"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check the health status of MongoDB, PostgreSQL, and Redis connections

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./health-check-health-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./health-check-health-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Iban Verification

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Iban Verification"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/iban-verification"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Confirm IBAN and beneficiary name (IBAN verification step).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./iban-verification-api-v-2-kyb-iban-verification-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./iban-verification-api-v-2-kyb-iban-verification-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Initiate

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Initiate"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/invoices-consent/initiate"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Initiate an invoice payment consent flow for open banking.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./initiate-api-v-2-invoices-consent-initiate-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./initiate-api-v-2-invoices-consent-initiate-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./initiate-api-v-2-invoices-consent-initiate-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Invoice Is Subscription Cancellable

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Invoice Is Subscription Cancellable"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoices/{invoice_id}/subscription/cancellable"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check if the subscription related to an invoice can be canceled.

Returns:
    - `is_subscription_cancellable=True`: The invoice is associated with a
      subscription AND that subscription is in a cancelable state.
    - `is_subscription_cancellable=False`: Either the invoice has no associated
      subscription, or the subscription is not in a cancelable state.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./invoice-is-subscription-cancellable-api-v-2-invoices-invoice-id-subscription-cancellable-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./invoice-is-subscription-cancellable-api-v-2-invoices-invoice-id-subscription-cancellable-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./invoice-is-subscription-cancellable-api-v-2-invoices-invoice-id-subscription-cancellable-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Issue Connected App Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Issue Connected App Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/oauth/token"}
  context={"endpoint"}
>
  
</MethodEndpoint>

The token endpoint: code, refresh and, for a service acting as itself, token exchange.

The form is read off the request rather than declared, so that a missing or repeated
parameter is answered by Authlib in the OAuth error shape and not by a 422.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./issue-connected-app-token-api-v-2-connected-apps-oauth-token-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./issue-connected-app-token-api-v-2-connected-apps-oauth-token-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Kyb Documents

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Kyb Documents"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/kyb/{organization_id}/documents"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Kyb Documents

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./kyb-documents-api-v-2-kyb-organization-id-documents-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./kyb-documents-api-v-2-kyb-organization-id-documents-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./kyb-documents-api-v-2-kyb-organization-id-documents-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Kyb Information

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Kyb Information"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/kyb"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the current onboarding state for the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./kyb-information-api-v-2-kyb-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./kyb-information-api-v-2-kyb-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Kyb Profile

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Kyb Profile"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/kyb/{organization_id}/profile"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Kyb Profile

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./kyb-profile-api-v-2-kyb-organization-id-profile-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./kyb-profile-api-v-2-kyb-organization-id-profile-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./kyb-profile-api-v-2-kyb-organization-id-profile-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Kyb Review Result

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Kyb Review Result"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/{organization_id}/review-result"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Receive the KYB review outcome from zendesk.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./kyb-review-result-api-v-2-kyb-organization-id-review-result-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./kyb-review-result-api-v-2-kyb-organization-id-review-result-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./kyb-review-result-api-v-2-kyb-organization-id-review-result-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Accounting Provider Branch Options

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Accounting Provider Branch Options"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/{provider}/branches/options"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List this provider's branches/locations available to map Stream branches onto.

Raises ACCOUNTING_BRANCHES_NOT_SUPPORTED if this provider/org has no branches/locations
concept -- the frontend should catch that code and skip branch mapping entirely.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-accounting-provider-branch-options-api-v-2-accounting-provider-branches-options-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-accounting-provider-branch-options-api-v-2-accounting-provider-branches-options-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-accounting-provider-branch-options-api-v-2-accounting-provider-branches-options-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Accounting Providers

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Accounting Providers"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List every known accounting provider and this organization's configuration status for each.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-accounting-providers-api-v-2-accounting-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-accounting-providers-api-v-2-accounting-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Add Ons

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Add Ons"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/add-ons"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List add-on eligibility mappings for the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-add-ons-api-v-2-add-ons-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-add-ons-api-v-2-add-ons-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List An Invoice'S Accounting Sync Attempts

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List An Invoice'S Accounting Sync Attempts"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/invoices/{invoice_id}/sync-attempts"}
  context={"endpoint"}
>
  
</MethodEndpoint>

The sync attempts of an invoice, newest first, with the provider request/response of each.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-an-invoice-s-accounting-sync-attempts-api-v-2-accounting-invoices-invoice-id-sync-attempts-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-an-invoice-s-accounting-sync-attempts-api-v-2-accounting-invoices-invoice-id-sync-attempts-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-an-invoice-s-accounting-sync-attempts-api-v-2-accounting-invoices-invoice-id-sync-attempts-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Connection Activity

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Connection Activity"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/connections/{connection_id}/activity"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Connection Activity

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-connection-activity-api-v-2-connected-apps-connections-connection-id-activity-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-connection-activity-api-v-2-connected-apps-connections-connection-id-activity-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-connection-activity-api-v-2-connected-apps-connections-connection-id-activity-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Connections

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Connections"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/connections"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Connections

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-connections-api-v-2-connected-apps-connections-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-connections-api-v-2-connected-apps-connections-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-connections-api-v-2-connected-apps-connections-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Coupons

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Coupons"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/coupons"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all coupons with pagination, filtering, and sorting options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-coupons-api-v-2-coupons-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-coupons-api-v-2-coupons-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-coupons-api-v-2-coupons-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Currencies

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Currencies"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/currencies"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get all active currencies.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-currencies-api-v-2-currencies-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-currencies-api-v-2-currencies-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Discount Rules

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Discount Rules"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/discount-rules"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Discount Rules

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-discount-rules-api-v-2-organization-settings-discount-rules-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-discount-rules-api-v-2-organization-settings-discount-rules-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Form Submissions (GET /api/v2/forms/{form_id}/submissions)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Form Submissions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/forms/{form_id}/submissions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Form Submissions

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-form-submissions-api-v-2-forms-form-id-submissions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-form-submissions-api-v-2-forms-form-id-submissions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-form-submissions-api-v-2-forms-form-id-submissions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Form Submissions (GET /api/v2/payment_link_forms/{form_id}/submissions)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Form Submissions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_link_forms/{form_id}/submissions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Form Submissions

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-form-submissions-api-v-2-payment-link-forms-form-id-submissions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-form-submissions-api-v-2-payment-link-forms-form-id-submissions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-form-submissions-api-v-2-payment-link-forms-form-id-submissions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Form Submissions For Consumer

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Form Submissions For Consumer"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/form_submissions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Form Submissions For Consumer

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-form-submissions-for-consumer-api-v-2-form-submissions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-form-submissions-for-consumer-api-v-2-form-submissions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-form-submissions-for-consumer-api-v-2-form-submissions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Forms (GET /api/v2/forms)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Forms"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/forms"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Forms

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-forms-api-v-2-forms-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-forms-api-v-2-forms-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-forms-api-v-2-forms-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Forms (GET /api/v2/payment_link_forms)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Forms"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_link_forms"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Forms

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-forms-api-v-2-payment-link-forms-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-forms-api-v-2-payment-link-forms-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-forms-api-v-2-payment-link-forms-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Installment Rules

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Installment Rules"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/installment-rules"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Installment Rules

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-installment-rules-api-v-2-organization-settings-installment-rules-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-installment-rules-api-v-2-organization-settings-installment-rules-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-installment-rules-api-v-2-organization-settings-installment-rules-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Invoice Batch Rows

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Invoice Batch Rows"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoice-batches/{batch_id}/rows"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Invoice Batch Rows

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-invoice-batch-rows-api-v-2-invoice-batches-batch-id-rows-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-invoice-batch-rows-api-v-2-invoice-batches-batch-id-rows-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-invoice-batch-rows-api-v-2-invoice-batches-batch-id-rows-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Invoice Batches

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Invoice Batches"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoice-batches"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Invoice Batches

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-invoice-batches-api-v-2-invoice-batches-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-invoice-batches-api-v-2-invoice-batches-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-invoice-batches-api-v-2-invoice-batches-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Invoices Accounting Sync Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Invoices Accounting Sync Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/accounting/invoices-sync-status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Invoices with their accounting sync status and, inline, the records that status is made of.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-invoices-accounting-sync-status-api-v-2-accounting-invoices-sync-status-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-invoices-accounting-sync-status-api-v-2-accounting-invoices-sync-status-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-invoices-accounting-sync-status-api-v-2-accounting-invoices-sync-status-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Invoices

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Invoices"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all invoices with pagination, filtering, and sorting options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-invoices-api-v-2-invoices-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-invoices-api-v-2-invoices-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-invoices-api-v-2-invoices-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Metered Subscriptions

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Metered Subscriptions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/metered_subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List metered subscriptions.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-metered-subscriptions-api-v-2-metered-subscriptions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-metered-subscriptions-api-v-2-metered-subscriptions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-metered-subscriptions-api-v-2-metered-subscriptions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Organization Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Organization Config"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bnpl/organization-config"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Organization Config

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-organization-config-api-v-2-bnpl-organization-config-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-organization-config-api-v-2-bnpl-organization-config-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Override Installment Rules

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Override Installment Rules"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/installment-rules/override"}
  context={"endpoint"}
>
  
</MethodEndpoint>

OVERRIDE rules a bill collector can pick as an installment override when creating an invoice or payment link.

Pass the invoice or link ``currency`` to list only rules that can be assigned to it.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-override-installment-rules-api-v-2-organization-settings-installment-rules-override-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-override-installment-rules-api-v-2-organization-settings-installment-rules-override-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-override-installment-rules-api-v-2-organization-settings-installment-rules-override-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Payment Links

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Payment Links"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payment_links"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all payment links with pagination, filtering, and sorting options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-payment-links-api-v-2-payment-links-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-payment-links-api-v-2-payment-links-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-payment-links-api-v-2-payment-links-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Payments

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Payments"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/payments"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all payments with pagination, filtering, and sorting options.

Payments can be filtered by invoice IDs, statuses, date ranges, or search terms.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-payments-api-v-2-payments-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-payments-api-v-2-payments-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-payments-api-v-2-payments-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Pgw Providers

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Pgw Providers"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/pgw-providers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List available payment gateways and which one is active for this organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-pgw-providers-api-v-2-organization-settings-pgw-providers-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-pgw-providers-api-v-2-organization-settings-pgw-providers-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Pricing Tables

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Pricing Tables"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/pricing_tables"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Pricing Tables

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-pricing-tables-api-v-2-pricing-tables-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-pricing-tables-api-v-2-pricing-tables-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-pricing-tables-api-v-2-pricing-tables-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Product Switch Groups

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Product Switch Groups"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/product-switch-groups"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List product switch groups for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-product-switch-groups-api-v-2-product-switch-groups-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-product-switch-groups-api-v-2-product-switch-groups-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-product-switch-groups-api-v-2-product-switch-groups-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Products

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Products"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/products"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List products with pagination, sorting, and optional filters.

**Query filters** (all optional; combine as needed):
- `search_term` — partial match on product name or description
- `active` — `true` for active products only, `false` for inactive only
- `type` — product type: `RECURRING`, `ONE_OFF`, or `METERED` (when enabled)
- `currency` — only products with an active price in this ISO currency code (e.g. `SAR`)

**External metadata filters** (optional, combine with other filters):
- Use any external metadata key you stored on create/update as a query parameter: `external_metadata.<key>=<value>`
- Exact match, case-sensitive. Multiple keys are ANDed.
- Example: if a consumer was created with `"external_metadata": {"segment": "enterprise", "tier": "gold"}`, filter with
  `?external_metadata.segment=enterprise&external_metadata.tier=gold`

**Pagination**: `page` (default 1), `limit` (default 10, max 100)

**Sorting**: `sort_field` (`price`, `name`, `created_at`; default `created_at`),
`sort_direction` (`asc` or `desc`; default `desc`)

**Example**: `/api/v2/products?active=true&type=RECURRING&external_metadata.category=saas&currency=SAR`

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-products-api-v-2-products-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-products-api-v-2-products-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-products-api-v-2-products-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Providers

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Providers"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bnpl/providers"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Providers

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-providers-api-v-2-bnpl-providers-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-providers-api-v-2-bnpl-providers-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Quantity Change Groups

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Quantity Change Groups"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/quantity-changes"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Quantity Change Groups

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-quantity-change-groups-api-v-2-quantity-changes-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-quantity-change-groups-api-v-2-quantity-changes-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Resource Field Definitions

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Resource Field Definitions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/resource-fields"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Resource Field Definitions

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-resource-field-definitions-api-v-2-resource-fields-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-resource-field-definitions-api-v-2-resource-fields-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-resource-field-definitions-api-v-2-resource-fields-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Scope Requests

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Scope Requests"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/scope-requests"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Scope Requests

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-scope-requests-api-v-2-connected-apps-scope-requests-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-scope-requests-api-v-2-connected-apps-scope-requests-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-scope-requests-api-v-2-connected-apps-scope-requests-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Settlements

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Settlements"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/bnpl/settlements"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List Settlements

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-settlements-api-v-2-bnpl-settlements-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-settlements-api-v-2-bnpl-settlements-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-settlements-api-v-2-bnpl-settlements-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Subscription Freezes

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Subscription Freezes"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/subscriptions/{subscription_id}/freeze"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all freeze periods for a specific subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-subscription-freezes-api-v-2-subscriptions-subscription-id-freeze-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-subscription-freezes-api-v-2-subscriptions-subscription-id-freeze-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-subscription-freezes-api-v-2-subscriptions-subscription-id-freeze-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Subscriptions

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Subscriptions"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/subscriptions"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List all subscriptions with pagination, filtering, and sorting options.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-subscriptions-api-v-2-subscriptions-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-subscriptions-api-v-2-subscriptions-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-subscriptions-api-v-2-subscriptions-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List Switchable Subscription Products

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List Switchable Subscription Products"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/switchable-products"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List per-line switch options for every item on the consumer's subscription.

Each entry in ``items`` corresponds to a current subscription line; lines whose
product is not part of any switch group come back with an empty
``switchable_products`` so the UI can render the full subscription consistently.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./list-switchable-subscription-products-api-v-2-consumer-portal-profile-subscription-subscription-id-switchable-products-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-switchable-subscription-products-api-v-2-consumer-portal-profile-subscription-subscription-id-switchable-products-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-switchable-subscription-products-api-v-2-consumer-portal-profile-subscription-subscription-id-switchable-products-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## List User Organizations

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"List User Organizations"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/user/organizations"}
  context={"endpoint"}
>
  
</MethodEndpoint>

List organizations the authenticated user is a member of.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./list-user-organizations-api-v-2-user-organizations-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./list-user-organizations-api-v-2-user-organizations-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Liveness probe endpoint

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Liveness probe endpoint"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/livez"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Process-alive check with no dependency calls; used by the k8s livenessProbe so transient DB/Mongo/Redis slowness can't restart an otherwise-healthy pod.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./liveness-check-livez-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./liveness-check-livez-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Login For Access Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Login For Access Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/login"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Authenticate user with email and password and return access tokens.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./login-for-access-token-api-v-2-authentication-login-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./login-for-access-token-api-v-2-authentication-login-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Login Mfa For Access Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Login Mfa For Access Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/submit-login-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Verify MFA code and complete login to receive access tokens.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./login-mfa-for-access-token-api-v-2-authentication-submit-login-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./login-mfa-for-access-token-api-v-2-authentication-submit-login-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Logo Upload

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Logo Upload"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/logo_upload"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Upload and set the organization logo.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./logo-upload-api-v-2-organization-logo-upload-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./logo-upload-api-v-2-organization-logo-upload-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Lower Connection

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Lower Connection"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/connected-apps/connections/{connection_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Lower Connection

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./lower-connection-api-v-2-connected-apps-connections-connection-id-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./lower-connection-api-v-2-connected-apps-connections-connection-id-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./lower-connection-api-v-2-connected-apps-connections-connection-id-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Mark Account As Default

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Mark Account As Default"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/accounts/{account_id}/default"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set a bank account as the default account for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./mark-account-as-default-api-v-2-accounts-account-id-default-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./mark-account-as-default-api-v-2-accounts-account-id-default-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./mark-account-as-default-api-v-2-accounts-account-id-default-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Mark Failed

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Mark Failed"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/{payment_id}/reject_bank_transfer"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Reject a bank transfer payment and mark it as failed.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./mark-failed-api-v-2-payments-payment-id-reject-bank-transfer-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./mark-failed-api-v-2-payments-payment-id-reject-bank-transfer-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./mark-failed-api-v-2-payments-payment-id-reject-bank-transfer-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Mark Payment As Paid

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Mark Payment As Paid"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/{payment_id}/mark-paid"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Manually mark a payment as paid (full or partial).

Record a payment received through manual methods (CASH, BANK_TRANSFER, CARD, or QURRAH).

**Full:** omit ``amount`` or pass ``amount == payment.amount``.
**Partial:** pass ``amount < payment.amount`` with remainder greater than 1 in the
payment currency (not allowed while UNDER_REVIEW).
  - Selected payment amount is reduced and marked SUCCEEDED.
  - A new PENDING ``SPLIT_REMAINDER`` payment is created for the remainder.
  - ``invoice.type`` is unchanged (ONE_OFF stays ONE_OFF).
  - Invoice completes only when every payment is paid.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./mark-payment-as-paid-api-v-2-payments-payment-id-mark-paid-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./mark-payment-as-paid-api-v-2-payments-payment-id-mark-paid-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./mark-payment-as-paid-api-v-2-payments-payment-id-mark-paid-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Moyasar Payment Webhook

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Moyasar Payment Webhook"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/moyasar/webhook/{organization_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Receive and process payment webhooks from Moyasar payment gateway.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./moyasar-payment-webhook-api-v-2-payments-moyasar-webhook-organization-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./moyasar-payment-webhook-api-v-2-payments-moyasar-webhook-organization-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./moyasar-payment-webhook-api-v-2-payments-moyasar-webhook-organization-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Moyasar Redirect

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Moyasar Redirect"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/moyasar/redirect"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle redirect from Moyasar payment gateway after payment completion.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./moyasar-redirect-api-v-2-consumer-portal-moyasar-redirect-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./moyasar-redirect-api-v-2-consumer-portal-moyasar-redirect-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./moyasar-redirect-api-v-2-consumer-portal-moyasar-redirect-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Myfatoorah Payment Webhook

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Myfatoorah Payment Webhook"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/myfatoorah/webhook/{organization_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Receive and process server-to-server webhooks from the MyFatoorah payment gateway.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./my-fatoorah-payment-webhook-api-v-2-payments-myfatoorah-webhook-organization-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./my-fatoorah-payment-webhook-api-v-2-payments-myfatoorah-webhook-organization-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./my-fatoorah-payment-webhook-api-v-2-payments-myfatoorah-webhook-organization-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Myfatoorah Settlement Webhook

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Myfatoorah Settlement Webhook"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/myfatoorah/webhook"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Receive MyFatoorah settlement (BALANCE_TRANSFERRED) webhooks, resolving the organization from the payload.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./my-fatoorah-settlement-webhook-api-v-2-payments-myfatoorah-webhook-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./my-fatoorah-settlement-webhook-api-v-2-payments-myfatoorah-webhook-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./my-fatoorah-settlement-webhook-api-v-2-payments-myfatoorah-webhook-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Myfatoorah Payment Callback

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Myfatoorah Payment Callback"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/myfatoorah/callback/{organization_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Receive and process payment callbacks from the MyFatoorah payment gateway.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./myfatoorah-payment-callback-api-v-2-payments-myfatoorah-callback-organization-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./myfatoorah-payment-callback-api-v-2-payments-myfatoorah-callback-organization-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./myfatoorah-payment-callback-api-v-2-payments-myfatoorah-callback-organization-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Myfatoorah Redirect

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Myfatoorah Redirect"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/myfatoorah/redirect"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle redirect from MyFatoorah payment gateway after payment completion.

Reuses the exact same generic redirection logic as moyasar_redirect — the
org's active PGW adapter (resolved from organization_id) determines whether
the payment is verified via Moyasar's API or MyFatoorah's decrypt/GetPaymentDetails.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./myfatoorah-redirect-api-v-2-consumer-portal-myfatoorah-redirect-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./myfatoorah-redirect-api-v-2-consumer-portal-myfatoorah-redirect-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./myfatoorah-redirect-api-v-2-consumer-portal-myfatoorah-redirect-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Oauth Authorize

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Oauth Authorize"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/authentication/oauth/{provider}/authorize"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Redirect the browser straight to the OAuth provider's consent screen.

No recaptcha here -- this is a plain browser navigation (e.g. a link/button), which can't
carry a token. The provider's own consent screen plus the callback's state check are the
abuse guards for this leg.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./oauth-authorize-api-v-2-authentication-oauth-provider-authorize-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./oauth-authorize-api-v-2-authentication-oauth-provider-authorize-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./oauth-authorize-api-v-2-authentication-oauth-provider-authorize-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Oauth Callback

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Oauth Callback"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/authentication/oauth/{provider}/callback"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle the provider's redirect back, then always hand the browser to the frontend.

Never returns an error response to the browser -- handle_oauth_callback never raises, so
every outcome becomes a `status=...` query param on the redirect. That includes the user
denying consent: Google then redirects here with `error=access_denied` and no `code` at
all, so `code` is an optional query param rather than a required one (a required, missing
`code` would otherwise fail FastAPI's own request validation before this handler runs,
surfacing a raw JSON 422 instead of the frontend redirect every other failure gets).
`state` is optional for the same reason -- Google itself always echoes it back, but a
malformed or bot-issued hit on this URL might not carry one at all.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./oauth-callback-api-v-2-authentication-oauth-provider-callback-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./oauth-callback-api-v-2-authentication-oauth-provider-callback-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./oauth-callback-api-v-2-authentication-oauth-provider-callback-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Oauth Complete Signup

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Oauth Complete Signup"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/oauth/complete-signup"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Finish a brand-new OAuth signup: fill in the profile fields and become VERIFIED.

`pending_signup_id`/`verification_code` (from the callback's redirect) are this request's
only auth -- same trust model as the existing GET /user/verify email-link flow.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./oauth-complete-signup-api-v-2-authentication-oauth-complete-signup-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./oauth-complete-signup-api-v-2-authentication-oauth-complete-signup-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization Collection Stats

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization Collection Stats"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/collection"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get collection statistics grouped by time frame.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./organization-collection-stats-api-v-2-analytics-collection-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-collection-stats-api-v-2-analytics-collection-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-collection-stats-api-v-2-analytics-collection-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization Revenue

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization Revenue"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/revenue"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get organization revenue analytics with time-based filtering.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./organization-revenue-api-v-2-analytics-revenue-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-revenue-api-v-2-analytics-revenue-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-revenue-api-v-2-analytics-revenue-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization'S Invoiced Amount In Time Range

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization'S Invoiced Amount In Time Range"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/invoiced-amount"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get total invoiced amount statistics with comparison to previous period.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./organization-s-invoiced-amount-in-time-range-api-v-2-analytics-invoiced-amount-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-s-invoiced-amount-in-time-range-api-v-2-analytics-invoiced-amount-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-s-invoiced-amount-in-time-range-api-v-2-analytics-invoiced-amount-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization'S Latest Invoices

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization'S Latest Invoices"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/latest-invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the most recent invoices for the organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-s-latest-invoices-api-v-2-analytics-latest-invoices-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-s-latest-invoices-api-v-2-analytics-latest-invoices-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization'S Outstanding Amount In Time Range

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization'S Outstanding Amount In Time Range"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/outstanding-amount"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get unpaid invoice amount statistics with comparison to previous period.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./organization-s-outstanding-amount-in-time-range-api-v-2-analytics-outstanding-amount-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-s-outstanding-amount-in-time-range-api-v-2-analytics-outstanding-amount-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-s-outstanding-amount-in-time-range-api-v-2-analytics-outstanding-amount-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization'S Total Overdue Amount

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization'S Total Overdue Amount"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/overdue-amount"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get total overdue invoice amount.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-s-total-overdue-amount-api-v-2-analytics-overdue-amount-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-s-total-overdue-amount-api-v-2-analytics-overdue-amount-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Organization'S Total Paid Amount (And Breakdown By Payment Method) In Time Range

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Organization'S Total Paid Amount (And Breakdown By Payment Method) In Time Range"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/paid-amount"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get total paid amount with breakdown by payment method.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./organization-s-total-paid-amount-and-breakdown-by-payment-method-in-time-range-api-v-2-analytics-paid-amount-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./organization-s-total-paid-amount-and-breakdown-by-payment-method-in-time-range-api-v-2-analytics-paid-amount-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./organization-s-total-paid-amount-and-breakdown-by-payment-method-in-time-range-api-v-2-analytics-paid-amount-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Paid Amount Metrics

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Paid Amount Metrics"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/paid-amount-metrics"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get paid amount metrics over time for charting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./paid-amount-metrics-api-v-2-analytics-paid-amount-metrics-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./paid-amount-metrics-api-v-2-analytics-paid-amount-metrics-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./paid-amount-metrics-api-v-2-analytics-paid-amount-metrics-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Pause Schedulers

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Pause Schedulers"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/test-support/schedulers/pause"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Pause all Temporal core schedules so background cron does not fight E2E runs.

Does not cancel in-flight workflows. Manual ``POST /v2/schedulers/...`` triggers
still work for intentional suite sweeps.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./pause-schedulers-api-v-2-test-support-schedulers-pause-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./pause-schedulers-api-v-2-test-support-schedulers-pause-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./pause-schedulers-api-v-2-test-support-schedulers-pause-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Pay By Qurrah

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Pay By Qurrah"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment/{payment_id}/pay-by-qurrah"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit a Qurrah payment with optional receipt file upload.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./pay-by-qurrah-api-v-2-consumer-portal-payment-payment-id-pay-by-qurrah-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./pay-by-qurrah-api-v-2-consumer-portal-payment-payment-id-pay-by-qurrah-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./pay-by-qurrah-api-v-2-consumer-portal-payment-payment-id-pay-by-qurrah-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Pay Subscription Update Intent With Attached Card

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Pay Subscription Update Intent With Attached Card"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/profile/subscription/update-intent/pay-attached-card"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Pay a pending subscription update intent using the subscription's attached card.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./pay-subscription-update-intent-with-attached-card-api-v-2-consumer-portal-profile-subscription-update-intent-pay-attached-card-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./pay-subscription-update-intent-with-attached-card-api-v-2-consumer-portal-profile-subscription-update-intent-pay-attached-card-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Plan Choice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Plan Choice"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/plan-choice"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Select billing plan and submit for review (plan choice step).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./plan-choice-api-v-2-kyb-plan-choice-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./plan-choice-api-v-2-kyb-plan-choice-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Preferred Language

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Preferred Language"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumers/preferred_language"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set the preferred language for a consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./preferred-language-api-v-2-consumers-preferred-language-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./preferred-language-api-v-2-consumers-preferred-language-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Preview Automatic Discount

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Preview Automatic Discount"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/discount-rules/automatic-discount"}
  context={"endpoint"}
>
  
</MethodEndpoint>

What the invoice screen shows before the invoice exists.

Returns the coupon (if any) an active discount rule suggests for this beneficiary/product in
this currency. Nothing is applied automatically: the invoice-creation flow uses this same
resolution (with the invoice's actual currency) only to reject the invoice if the suggested
coupon isn't included, so the caller must fetch this first and pass it explicitly when
creating the invoice. `currency` is required so the suggestion always matches what invoice
creation will actually enforce -- a coupon fixed to a currency the invoice isn't in is never
"applicable", the same as an inactive or otherwise ineligible one.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./preview-automatic-discount-api-v-2-organization-settings-discount-rules-automatic-discount-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./preview-automatic-discount-api-v-2-organization-settings-discount-rules-automatic-discount-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./preview-automatic-discount-api-v-2-organization-settings-discount-rules-automatic-discount-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Preview Installment Payment Calendar

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Preview Installment Payment Calendar"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization-settings/installment-rules/preview"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Payment calendar shown while raising an invoice or configuring a payment link.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./preview-installment-payment-calendar-api-v-2-organization-settings-installment-rules-preview-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./preview-installment-payment-calendar-api-v-2-organization-settings-installment-rules-preview-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./preview-installment-payment-calendar-api-v-2-organization-settings-installment-rules-preview-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Preview Invoice Batch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Preview Invoice Batch"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/invoice-batches/preview"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Preview Invoice Batch

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./preview-invoice-batch-api-v-2-invoice-batches-preview-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./preview-invoice-batch-api-v-2-invoice-batches-preview-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Preview Payment Link Installment Options

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Preview Payment Link Installment Options"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/payment-link/{payment_link_id}/installment-options"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Preview installment options for a payment link after quantity changes.

Recomputes the cart total from item_quantities (same pricing path as intent create)
and returns installment options that apply to that total. Does not create an intent.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./preview-payment-link-installment-options-api-v-2-consumer-portal-payment-link-payment-link-id-installment-options-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./preview-payment-link-installment-options-api-v-2-consumer-portal-payment-link-payment-link-id-installment-options-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./preview-payment-link-installment-options-api-v-2-consumer-portal-payment-link-payment-link-id-installment-options-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Print Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Print Invoice"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/print"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return download link for a completed consent invoice PDF.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./print-invoice-api-v-2-consumer-portal-consent-consent-id-print-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./print-invoice-api-v-2-consumer-portal-consent-consent-id-print-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./print-invoice-api-v-2-consumer-portal-consent-consent-id-print-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Print Payment Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Print Payment Invoice"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/pdf/invoice/{invoice_id}/payment/{payment_id}/download"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get download link for invoice PDF with payment details.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./print-payment-invoice-api-v-2-consumer-portal-pdf-invoice-invoice-id-payment-payment-id-download-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./print-payment-invoice-api-v-2-consumer-portal-pdf-invoice-invoice-id-payment-payment-id-download-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./print-payment-invoice-api-v-2-consumer-portal-pdf-invoice-invoice-id-payment-payment-id-download-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Print Payment Link Pgw Payment Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Print Payment Link Pgw Payment Invoice"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/payment_link/invoice/{invoice_id}/print"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return download link for a payment-link invoice PDF.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./print-payment-link-pgw-payment-invoice-api-v-2-consumer-portal-payment-link-invoice-invoice-id-print-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./print-payment-link-pgw-payment-invoice-api-v-2-consumer-portal-payment-link-invoice-invoice-id-print-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./print-payment-link-pgw-payment-invoice-api-v-2-consumer-portal-payment-link-invoice-invoice-id-print-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Print Proforma Invoice Pdf

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Print Proforma Invoice Pdf"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/consumer_portal/invoice/{invoice_id}/proforma-pdf"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Return proforma invoice PDF status and URL; creates a pending row and starts generation when missing.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./print-proforma-invoice-pdf-api-v-2-consumer-portal-invoice-invoice-id-proforma-pdf-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./print-proforma-invoice-pdf-api-v-2-consumer-portal-invoice-invoice-id-proforma-pdf-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./print-proforma-invoice-pdf-api-v-2-consumer-portal-invoice-invoice-id-proforma-pdf-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Print Vat Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Print Vat Invoice"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/pdf/{payment_id}/download"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get download link for VAT-compliant invoice PDF.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./print-vat-invoice-api-v-2-pdf-payment-id-download-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./print-vat-invoice-api-v-2-pdf-payment-id-download-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./print-vat-invoice-api-v-2-pdf-payment-id-download-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Profile Completion (GET /api/v2/organization/profile-completion)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Profile Completion"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/organization/profile-completion"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get the remaining complete profile steps for the current organization.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./profile-completion-api-v-2-organization-profile-completion-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./profile-completion-api-v-2-organization-profile-completion-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Profile Completion (PUT /api/v2/organization/profile-completion)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Profile Completion"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/profile-completion"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set one of the specified steps as completed.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./profile-completion-api-v-2-organization-profile-completion-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./profile-completion-api-v-2-organization-profile-completion-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Record Metered Usage

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Record Metered Usage"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/metered_subscriptions/record"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Record metered usage events in bulk

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./record-metered-usage-api-v-2-metered-subscriptions-record-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./record-metered-usage-api-v-2-metered-subscriptions-record-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Refresh Access Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Refresh Access Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/refresh"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Refresh access token using refresh token from cookies.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./refresh-access-token-api-v-2-authentication-refresh-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./refresh-access-token-api-v-2-authentication-refresh-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Refund Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Refund Payment"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payments/{payment_id}/refund"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Process a refund for a payment.

Refunds settle the requested amount or the remaining refundable balance for the selected payment.
If that payment is part of a shared Moyasar charge, set
``payment_is_part_of_related_set`` to true to distribute the refund across related payments in
invoice order.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./refund-payment-api-v-2-payments-payment-id-refund-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./refund-payment-api-v-2-payments-payment-id-refund-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./refund-payment-api-v-2-payments-payment-id-refund-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Register A Bank Transfer For An Organization

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Register A Bank Transfer For An Organization"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/bank-transfer/{organization_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Register a bank transfer from external banking systems via webhook.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./register-a-bank-transfer-for-an-organization-api-v-2-bank-transfer-organization-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./register-a-bank-transfer-for-an-organization-api-v-2-bank-transfer-organization-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./register-a-bank-transfer-for-an-organization-api-v-2-bank-transfer-organization-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Register Connected App Client

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Register Connected App Client"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/oauth/register"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Register Connected App Client

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./register-connected-app-client-api-v-2-connected-apps-oauth-register-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./register-connected-app-client-api-v-2-connected-apps-oauth-register-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Register Invited User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Register Invited User"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/register-invited-user"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Accept an organization invite. Existing users send invite_id + Bearer token; new users send profile fields.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./register-invited-user-api-v-2-authentication-register-invited-user-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./register-invited-user-api-v-2-authentication-register-invited-user-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Register Pending User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Register Pending User"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/user/register"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Register a new user and send email verification code.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./register-pending-user-api-v-2-authentication-user-register-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./register-pending-user-api-v-2-authentication-user-register-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./register-pending-user-api-v-2-authentication-user-register-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Register User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Register User"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/register"}
  context={"endpoint"}
>
  
</MethodEndpoint>

:::caution[deprecated]

This endpoint has been deprecated and may be replaced or removed in future versions of the API.

:::

Register a new user account (deprecated, use /user/register instead).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./register-user-api-v-2-authentication-register-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./register-user-api-v-2-authentication-register-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./register-user-api-v-2-authentication-register-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Reject Connection Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Reject Connection Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/connection-requests/{request_id}/reject"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Reject Connection Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./reject-connection-request-api-v-2-connected-apps-connection-requests-request-id-reject-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./reject-connection-request-api-v-2-connected-apps-connection-requests-request-id-reject-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./reject-connection-request-api-v-2-connected-apps-connection-requests-request-id-reject-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Reject Scope Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Reject Scope Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/scope-requests/{scope_request_id}/reject"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Reject Scope Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./reject-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-reject-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./reject-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-reject-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./reject-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-reject-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Renew Zatca Production Csid

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Renew Zatca Production Csid"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/zatca/renew"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Renew Zatca Production Csid

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./renew-zatca-production-csid-api-v-2-zatca-renew-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./renew-zatca-production-csid-api-v-2-zatca-renew-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Reopen Form Submission

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Reopen Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/form-submissions/{submission_id}/reopen"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Convert SUBMITTED back to DRAFT when the payer goes back to edit before paying.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./reopen-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-reopen-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./reopen-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-reopen-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./reopen-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-reopen-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Replay Webhook Delivery

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Replay Webhook Delivery"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/webhook-deliveries/{webhook_delivery_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Replay a webhook delivery.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./replay-webhook-delivery-api-v-2-webhook-deliveries-webhook-delivery-id-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./replay-webhook-delivery-api-v-2-webhook-deliveries-webhook-delivery-id-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./replay-webhook-delivery-api-v-2-webhook-deliveries-webhook-delivery-id-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Reschedule Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Reschedule Payment"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/test-support/payments/{payment_id}/scheduled-on"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set a payment's `scheduled_on` without the posted-invoice validation.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./reschedule-payment-api-v-2-test-support-payments-payment-id-scheduled-on-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./reschedule-payment-api-v-2-test-support-payments-payment-id-scheduled-on-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./reschedule-payment-api-v-2-test-support-payments-payment-id-scheduled-on-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Resend Verify Email Pending User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Resend Verify Email Pending User"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/authentication/user/verify/resend"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Resend email verification code to a pending user.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./resend-verify-email-pending-user-api-v-2-authentication-user-verify-resend-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./resend-verify-email-pending-user-api-v-2-authentication-user-verify-resend-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./resend-verify-email-pending-user-api-v-2-authentication-user-verify-resend-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Reset Password

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Reset Password"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/reset-password"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set new password using verified reset token.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./reset-password-api-v-2-authentication-reset-password-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./reset-password-api-v-2-authentication-reset-password-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Resolve Accounting Provider Post-Auth Field Values

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Resolve Accounting Provider Post-Auth Field Values"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/fields/values"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Resolve dependent POST_AUTH fields tier-by-tier (e.g. Zoho's org id -&gt; payment account).

Submit known values, get back everything resolved so far this session plus which fields
are still pending an unmet dependency -- call again with newly-picked values to unlock
the next tier. Purely a staging/resolution aid; never writes to the persisted config.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./resolve-accounting-provider-post-auth-field-values-api-v-2-accounting-provider-fields-values-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./resolve-accounting-provider-post-auth-field-values-api-v-2-accounting-provider-fields-values-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./resolve-accounting-provider-post-auth-field-values-api-v-2-accounting-provider-fields-values-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Resume Schedulers

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Resume Schedulers"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/test-support/schedulers/resume"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Unpause all Temporal core schedules after E2E cleanup.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./resume-schedulers-api-v-2-test-support-schedulers-resume-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./resume-schedulers-api-v-2-test-support-schedulers-resume-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./resume-schedulers-api-v-2-test-support-schedulers-resume-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Revoke Connected App Token

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Revoke Connected App Token"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/oauth/revoke"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Revoke Connected App Token

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./revoke-connected-app-token-api-v-2-connected-apps-oauth-revoke-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./revoke-connected-app-token-api-v-2-connected-apps-oauth-revoke-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Set Connection All Branches

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Set Connection All Branches"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/connected-apps/connections/{connection_id}/all-branches"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Turn a connection's reach to every branch of the organization on or off. Organization admin only.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./set-connection-all-branches-api-v-2-connected-apps-connections-connection-id-all-branches-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./set-connection-all-branches-api-v-2-connected-apps-connections-connection-id-all-branches-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./set-connection-all-branches-api-v-2-connected-apps-connections-connection-id-all-branches-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Set Payment Flow

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Set Payment Flow"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/payment-flow"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set the payment flow configuration for a consent.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./set-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./set-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./set-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Set Subscription Period

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Set Subscription Period"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/test-support/subscriptions/{subscription_id}/period"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Set a subscription's current period so renewal or cycle-push sweeps see it as due.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./set-subscription-period-api-v-2-test-support-subscriptions-subscription-id-period-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./set-subscription-period-api-v-2-test-support-subscriptions-subscription-id-period-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./set-subscription-period-api-v-2-test-support-subscriptions-subscription-id-period-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Settlement Sum Metrics

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Settlement Sum Metrics"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/settlement-sum-metrics"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get total settlement sum statistics with comparison to previous period.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./settlement-sum-metrics-api-v-2-analytics-settlement-sum-metrics-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./settlement-sum-metrics-api-v-2-analytics-settlement-sum-metrics-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./settlement-sum-metrics-api-v-2-analytics-settlement-sum-metrics-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Skip Getting Started

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Skip Getting Started"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/kyb/skip-getting-started"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Skip the getting-started screen.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./skip-getting-started-api-v-2-kyb-skip-getting-started-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./skip-getting-started-api-v-2-kyb-skip-getting-started-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Start Accounting Provider Oauth

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Start Accounting Provider Oauth"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/authorize"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Store pre-auth field values and return the provider's OAuth authorization URL.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./start-accounting-provider-oauth-api-v-2-accounting-provider-authorize-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./start-accounting-provider-oauth-api-v-2-accounting-provider-authorize-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./start-accounting-provider-oauth-api-v-2-accounting-provider-authorize-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Start Bnpl Checkout

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Start Bnpl Checkout"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/bnpl/checkout"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Start Bnpl Checkout

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./start-bnpl-checkout-api-v-2-consumer-portal-consent-consent-id-bnpl-checkout-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./start-bnpl-checkout-api-v-2-consumer-portal-consent-consent-id-bnpl-checkout-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./start-bnpl-checkout-api-v-2-consumer-portal-consent-consent-id-bnpl-checkout-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Start Connected App Authorization

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Start Connected App Authorization"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/connected-apps/oauth/authorize"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Start sign-in in the merchant's browser.

A request whose client or redirect URI cannot be trusted gets a page, never a redirect:
the only address available to redirect to is the one that failed validation.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./start-connected-app-authorization-api-v-2-connected-apps-oauth-authorize-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./start-connected-app-authorization-api-v-2-connected-apps-oauth-authorize-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Start Zatca Onboarding

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Start Zatca Onboarding"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/zatca/onboard"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Start Zatca Onboarding

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./start-zatca-onboarding-api-v-2-zatca-onboard-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./start-zatca-onboarding-api-v-2-zatca-onboard-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Store And Send Contact Us Email

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Store And Send Contact Us Email"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/contact_us"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit a contact us form and send notification email.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./store-and-send-contact-us-email-api-v-2-public-contact-us-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./store-and-send-contact-us-email-api-v-2-public-contact-us-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./store-and-send-contact-us-email-api-v-2-public-contact-us-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Submit Accounting Provider Credentials

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Submit Accounting Provider Credentials"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/credentials"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit non-OAuth credentials (API key or username/password) for a provider and verify them.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./submit-accounting-provider-credentials-api-v-2-accounting-provider-credentials-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./submit-accounting-provider-credentials-api-v-2-accounting-provider-credentials-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./submit-accounting-provider-credentials-api-v-2-accounting-provider-credentials-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Submit Accounting Provider Post-Auth Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Submit Accounting Provider Post-Auth Config"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/{provider}/config"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Submit post-auth field values (e.g. which chart-of-accounts entry payments should post to).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./submit-accounting-provider-post-auth-config-api-v-2-accounting-provider-config-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./submit-accounting-provider-post-auth-config-api-v-2-accounting-provider-config-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./submit-accounting-provider-post-auth-config-api-v-2-accounting-provider-config-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Submit Mfa For Phone Verification

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Submit Mfa For Phone Verification"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/user/submit-phone-verification-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Generate and send multi-factor authentication code for phone verification.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./submit-mfa-for-phone-verification-api-v-2-user-submit-phone-verification-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./submit-mfa-for-phone-verification-api-v-2-user-submit-phone-verification-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Subscribers Metrics

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Subscribers Metrics"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/analytics/subscribers-metrics"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Get subscriber count metrics over time for charting.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./subscribers-metrics-api-v-2-analytics-subscribers-metrics-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./subscribers-metrics-api-v-2-analytics-subscribers-metrics-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./subscribers-metrics-api-v-2-analytics-subscribers-metrics-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Subscription Are Invoices Cancellable

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Subscription Are Invoices Cancellable"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/subscriptions/{subscription_id}/invoices/cancellable"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Check if a subscription has any cancelable ongoing invoices.

Returns:
    - `are_invoices_cancellable=True`: The subscription has one or more ongoing
      invoices that are cancellable.
    - `are_invoices_cancellable=False`: The subscription has no ongoing invoices
      (all invoices are completed, canceled, or no invoices exist).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./subscription-are-invoices-cancellable-api-v-2-subscriptions-subscription-id-invoices-cancellable-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./subscription-are-invoices-cancellable-api-v-2-subscriptions-subscription-id-invoices-cancellable-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./subscription-are-invoices-cancellable-api-v-2-subscriptions-subscription-id-invoices-cancellable-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Switch Branch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Switch Branch"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/switch-branch"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Switch the active branch for the current user session.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./switch-branch-api-v-2-authentication-switch-branch-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./switch-branch-api-v-2-authentication-switch-branch-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Switch Organization

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Switch Organization"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/switch-organization"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Switch the active organization for the current user session.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./switch-organization-api-v-2-authentication-switch-organization-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./switch-organization-api-v-2-authentication-switch-organization-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Sync Invoices To The Accounting Platform

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Sync Invoices To The Accounting Platform"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/accounting/invoices/sync"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Sync the unsynced / failed records of these invoices (at most one page worth), in order.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./sync-invoices-to-the-accounting-platform-api-v-2-accounting-invoices-sync-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./sync-invoices-to-the-accounting-platform-api-v-2-accounting-invoices-sync-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Uncancel Subscription (PUT /api/v2/consumer_portal/profile/subscription/{subscription_id}/uncancel)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Uncancel Subscription"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/uncancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Withdraw a pending cancellation so the subscription continues after the current billing period.

If the subscription is not scheduled to be cancelled, succeeds as a no-op.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./uncancel-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-uncancel-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./uncancel-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-uncancel-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./uncancel-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-uncancel-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Uncancel Subscription (PUT /api/v2/subscriptions/{subscription_id}/uncancel)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Uncancel Subscription"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/subscriptions/{subscription_id}/uncancel"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Withdraw a pending cancellation so the subscription continues after the current billing period.

Only **ACTIVE** subscriptions are accepted.
If the subscription is not scheduled to be cancelled, the request succeeds as a no-op.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./uncancel-subscription-api-v-2-subscriptions-subscription-id-uncancel-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./uncancel-subscription-api-v-2-subscriptions-subscription-id-uncancel-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./uncancel-subscription-api-v-2-subscriptions-subscription-id-uncancel-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Unfreeze Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Unfreeze Subscription"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/unfreeze"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Unfreeze a subscription for the logged-in organization consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./unfreeze-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-unfreeze-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./unfreeze-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-unfreeze-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./unfreeze-subscription-api-v-2-consumer-portal-profile-subscription-subscription-id-unfreeze-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Unifonic Sms Webhook Endpoint

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Unifonic Sms Webhook Endpoint"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/notifications/unifonic/sms"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle SMS notification status webhooks from Unifonic.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./unifonic-sms-webhook-endpoint-api-v-2-notifications-unifonic-sms-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./unifonic-sms-webhook-endpoint-api-v-2-notifications-unifonic-sms-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./unifonic-sms-webhook-endpoint-api-v-2-notifications-unifonic-sms-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Unifonic Whatsapp Webhook Endpoint

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Unifonic Whatsapp Webhook Endpoint"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/notifications/unifonic/whatsapp"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Handle WhatsApp webhooks from Unifonic.

For message.received events: triggers invoice auto-response flow.
For other event types (message.sent, message.delivered, etc.): handles notification status updates.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./unifonic-whatsapp-webhook-endpoint-api-v-2-notifications-unifonic-whatsapp-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./unifonic-whatsapp-webhook-endpoint-api-v-2-notifications-unifonic-whatsapp-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./unifonic-whatsapp-webhook-endpoint-api-v-2-notifications-unifonic-whatsapp-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Account

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Account"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/accounts/{account_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update bank account details.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-account-api-v-2-accounts-account-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-account-api-v-2-accounts-account-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-account-api-v-2-accounts-account-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Accounting Provider Branch Mappings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Accounting Provider Branch Mappings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/accounting/{provider}/branches"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Replace the saved branch mappings with the given full set. Omitted branches are unmapped.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-accounting-provider-branch-mappings-api-v-2-accounting-provider-branches-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Accounting Provider Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Accounting Provider Config"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/accounting/{provider}/config"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update existing config field values. Never accepts credentials/tokens through this endpoint.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-accounting-provider-config-api-v-2-accounting-provider-config-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-accounting-provider-config-api-v-2-accounting-provider-config-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-accounting-provider-config-api-v-2-accounting-provider-config-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Add Ons

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Add Ons"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/add-ons"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Overwrite eligible products for a single add-on product.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-add-ons-api-v-2-add-ons-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-add-ons-api-v-2-add-ons-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update (PUT /api/v1/invoices/{invoice_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v1/invoices/{invoice_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update an existing invoice.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-api-v-1-invoices-invoice-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-api-v-1-invoices-invoice-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-api-v-1-invoices-invoice-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update (PUT /api/v2/public/waitlist/{waitlist_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/public/waitlist/{waitlist_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update waitlist entry information.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-api-v-2-public-waitlist-waitlist-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-api-v-2-public-waitlist-waitlist-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-api-v-2-public-waitlist-waitlist-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update (PUT /api/v2/webhooks/{webhook_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/webhooks/{webhook_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update webhook configuration such as URL or event types.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-api-v-2-webhooks-webhook-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-api-v-2-webhooks-webhook-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-api-v-2-webhooks-webhook-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Branch

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Branch"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/branch/{branch_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update branch information.

If a branch with the same name already exists, returns an error.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-branch-api-v-2-branch-branch-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-branch-api-v-2-branch-branch-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-branch-api-v-2-branch-branch-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Cards Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Cards Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/cards"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update credit card payment settings for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-cards-settings-api-v-2-organization-settings-cards-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-cards-settings-api-v-2-organization-settings-cards-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer (PUT /api/v1/consumers/{org_consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v1/consumers/{org_consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update consumer information such as contact details or payment methods.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-consumer-api-v-1-consumers-org-consumer-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-api-v-1-consumers-org-consumer-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-api-v-1-consumers-org-consumer-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer (PUT /api/v2/consumer_portal/profile/consumer)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/consumer"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update consumer information for the logged-in consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-api-v-2-consumer-portal-profile-consumer-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-api-v-2-consumer-portal-profile-consumer-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer (PUT /api/v2/consumers/{consumer_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumers/{consumer_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update consumer information such as contact details or payment methods.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-consumer-api-v-2-consumers-consumer-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-api-v-2-consumers-consumer-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-api-v-2-consumers-consumer-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer Communication Methods

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer Communication Methods"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/consumer/communication-methods"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update consumer communication methods for the logged-in consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-communication-methods-api-v-2-consumer-portal-profile-consumer-communication-methods-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-communication-methods-api-v-2-consumer-portal-profile-consumer-communication-methods-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer Language

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer Language"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/consumer/language"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the preferred language for the logged-in consumer.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-language-api-v-2-consumer-portal-profile-consumer-language-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-language-api-v-2-consumer-portal-profile-consumer-language-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Consumer Profile Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Consumer Profile Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/consumer-profile"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Replace organization consumer profile settings using full PUT semantics.

This endpoint expects the complete ``UpdateConsumerProfileSettings`` payload.
Omitted fields are not preserved and will cause validation errors because the body
is treated as a full replacement, not a partial patch.

``null`` for non-nullable fields is rejected by validation.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-consumer-profile-settings-api-v-2-organization-settings-consumer-profile-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-consumer-profile-settings-api-v-2-organization-settings-consumer-profile-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Contact Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Contact Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/contact"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update organization contact information settings.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-contact-settings-api-v-2-organization-settings-contact-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-contact-settings-api-v-2-organization-settings-contact-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Coupon

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Coupon"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/coupons/{coupon_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update coupon details such as discount amount or active status.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-coupon-api-v-2-coupons-coupon-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-coupon-api-v-2-coupons-coupon-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-coupon-api-v-2-coupons-coupon-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Customer Portal Branding Configuration

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Customer Portal Branding Configuration"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/consumer-portal-branding"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update customer portal branding colors.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-customer-portal-branding-configuration-api-v-2-organization-settings-consumer-portal-branding-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-customer-portal-branding-configuration-api-v-2-organization-settings-consumer-portal-branding-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Customer Portal Branding Favicon

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Customer Portal Branding Favicon"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/consumer-portal-branding/favicon"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update customer portal favicon image.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-customer-portal-branding-favicon-api-v-2-organization-settings-consumer-portal-branding-favicon-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-customer-portal-branding-favicon-api-v-2-organization-settings-consumer-portal-branding-favicon-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Discount Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Discount Rule"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/discount-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Discount Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-discount-rule-api-v-2-organization-settings-discount-rules-rule-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Email Template Configuration

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Email Template Configuration"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/email-template"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update notification email colours, header mode, and nested sections.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-email-template-configuration-api-v-2-email-template-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-email-template-configuration-api-v-2-email-template-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Email Template Header Image

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Email Template Header Image"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/email-template/header-image"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Upload a full-width header image and switch off logo-strip mode.

The file is stored ``public-read``; only PNG, JPEG, WebP, or GIF (up to 5MB) are accepted
after PIL decode validation so arbitrary HTML/SVG/scripts cannot be hosted.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-email-template-header-image-api-v-2-email-template-header-image-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-email-template-header-image-api-v-2-email-template-header-image-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Form (PATCH /api/v2/forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Form"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-form-api-v-2-forms-form-id-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-form-api-v-2-forms-form-id-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-form-api-v-2-forms-form-id-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Form (PATCH /api/v2/payment_link_forms/{form_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Form"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/payment_link_forms/{form_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Form

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-form-api-v-2-payment-link-forms-form-id-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-form-api-v-2-payment-link-forms-form-id-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-form-api-v-2-payment-link-forms-form-id-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Form Submission

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Form Submission"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/consumer_portal/form-submissions/{submission_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Autosave form answers while the submission is a draft.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-form-submission-api-v-2-consumer-portal-form-submissions-submission-id-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Installment Rule

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Installment Rule"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/installment-rules/{rule_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Installment Rule

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-installment-rule-api-v-2-organization-settings-installment-rules-rule-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Installment Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Installment Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/installment"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update installment payment settings for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-installment-settings-api-v-2-organization-settings-installment-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-installment-settings-api-v-2-organization-settings-installment-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Invoice

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Invoice"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/invoices/{invoice_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update invoice details such as items, consumer, due date, or payment methods.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-invoice-api-v-2-invoices-invoice-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-invoice-api-v-2-invoices-invoice-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-invoice-api-v-2-invoices-invoice-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Invoice In Place

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Invoice In Place"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/invoices/{invoice_id}/inplace"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Partially update specific invoice fields in-place.

This endpoint allows updating only the fields specified in the request.
Use for quick changes such as updating the description or scheduled date.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-invoice-in-place-api-v-2-invoices-invoice-id-inplace-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-invoice-in-place-api-v-2-invoices-invoice-id-inplace-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-invoice-in-place-api-v-2-invoices-invoice-id-inplace-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Organization Accounting Posting Behavior

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Organization Accounting Posting Behavior"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/posting-behavior"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the organization's accounting posting settings (only the fields sent).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-organization-accounting-posting-behavior-api-v-2-organization-posting-behavior-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-organization-accounting-posting-behavior-api-v-2-organization-posting-behavior-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Organization Address

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Organization Address"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/address"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Create or replace the organization's national address (used as the seller address on ZATCA invoices).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-organization-address-api-v-2-organization-settings-address-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-organization-address-api-v-2-organization-settings-address-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Organization Name

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Organization Name"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/name"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the organization name.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-organization-name-api-v-2-organization-name-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-organization-name-api-v-2-organization-name-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Organization Preferences

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Organization Preferences"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/bnpl/organization-config/{provider_id}/preferences"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Organization Preferences

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-organization-preferences-api-v-2-bnpl-organization-config-provider-id-preferences-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-organization-preferences-api-v-2-bnpl-organization-config-provider-id-preferences-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-organization-preferences-api-v-2-bnpl-organization-config-provider-id-preferences-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Organization Refund Policy

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Organization Refund Policy"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/refund-policy"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the organization refund policy by creating a new policy version.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-organization-refund-policy-api-v-2-organization-refund-policy-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-organization-refund-policy-api-v-2-organization-refund-policy-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment (PUT /api/v2/consumer_portal/card/payment)

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/card/payment"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update payment information for a card payment.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-api-v-2-consumer-portal-card-payment-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-api-v-2-consumer-portal-card-payment-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-api-v-2-consumer-portal-card-payment-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment (PUT /api/v2/payments/{payment_id})

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/payments/{payment_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update payment details such as amount or payment method.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-api-v-2-payments-payment-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-api-v-2-payments-payment-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-api-v-2-payments-payment-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Flow

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Flow"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/consent/{consent_id}/payment-flow"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the payment flow configuration for a consent.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-flow-api-v-2-consumer-portal-consent-consent-id-payment-flow-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Link Coupons

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Link Coupons"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/payment_links/{payment_link_id}/coupons"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update link-level and item-level coupons on a payment link.

Recomputes totals. New checkouts use the updated coupons;
payments already in progress are unchanged.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-link-coupons-api-v-2-payment-links-payment-link-id-coupons-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-link-coupons-api-v-2-payment-links-payment-link-id-coupons-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-link-coupons-api-v-2-payment-links-payment-link-id-coupons-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Link Installment Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Link Installment Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/payment-link-installment-settings"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update payment link installment settings for the organization.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-link-installment-settings-api-v-2-organization-settings-payment-link-installment-settings-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-link-installment-settings-api-v-2-organization-settings-payment-link-installment-settings-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Link Payment

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Link Payment"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/payment-link/card/payment"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update payment information for a payment link card payment.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-link-payment-api-v-2-consumer-portal-payment-link-card-payment-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-link-payment-api-v-2-consumer-portal-payment-link-card-payment-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-link-payment-api-v-2-consumer-portal-payment-link-card-payment-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Link Payment Options

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Link Payment Options"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/payment-link-payment-options"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update organization payment link payment options settings.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-link-payment-options-api-v-2-organization-settings-payment-link-payment-options-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-link-payment-options-api-v-2-organization-settings-payment-link-payment-options-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Link Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Link Status"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/payment_links/{payment_link_id}/status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the status of a payment link.

Allows activating or deactivating a payment link. When deactivated, the link will no longer
accept new payments. Existing payments in progress are not affected.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-payment-link-status-api-v-2-payment-links-payment-link-id-status-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-link-status-api-v-2-payment-links-payment-link-id-status-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-link-status-api-v-2-payment-links-payment-link-id-status-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Payment Options

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Payment Options"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/payment-options"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update organization payment options settings.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-payment-options-api-v-2-organization-settings-payment-options-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-payment-options-api-v-2-organization-settings-payment-options-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Pricing Table

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Pricing Table"}
>
</Heading>

<MethodEndpoint
  method={"patch"}
  path={"/api/v2/pricing_tables/{pricing_table_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update Pricing Table

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-pricing-table-api-v-2-pricing-tables-pricing-table-id-patch.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-pricing-table-api-v-2-pricing-tables-pricing-table-id-patch.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-pricing-table-api-v-2-pricing-tables-pricing-table-id-patch.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Product

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Product"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/products/{product_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update product details such as name, price, or description.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-product-api-v-2-products-product-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-product-api-v-2-products-product-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-product-api-v-2-products-product-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Product Price

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Product Price"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/products/{product_id}/prices/{price_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update a product price.

This follows an immutable pricing pattern: the old price is archived
and a new price is created with the updated values.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-product-price-api-v-2-products-product-id-prices-price-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-product-price-api-v-2-products-product-id-prices-price-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-product-price-api-v-2-products-product-id-prices-price-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Product Switch Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Product Switch Group"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/product-switch-groups/{group_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Replace name and full product membership list.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-product-switch-group-api-v-2-product-switch-groups-group-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-product-switch-group-api-v-2-product-switch-groups-group-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-product-switch-group-api-v-2-product-switch-groups-group-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Quantity Change Group

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Quantity Change Group"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/quantity-changes/{group_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update a quantity-change group.

``product_ids`` fully replaces the group's existing product list.
Sending an empty ``product_ids`` list deletes the group.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-quantity-change-group-api-v-2-quantity-changes-group-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-quantity-change-group-api-v-2-quantity-changes-group-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-quantity-change-group-api-v-2-quantity-changes-group-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Risky Invoices Settings

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Risky Invoices Settings"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization-settings/risky-invoices"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Replace the organization's risky invoices buckets (low/medium/high).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-risky-invoices-settings-api-v-2-organization-settings-risky-invoices-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-risky-invoices-settings-api-v-2-organization-settings-risky-invoices-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Subscription

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Subscription"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/subscriptions/{subscription_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update subscription items, coupons, billing interval, description, auto-cancel cycles, or payment methods.

Updatable fields:

- **Items** (products and quantities) — deferred to the next cycle.
- **Subscription-level coupons** — same deferral as items.
- **Recurring interval / interval count** (e.g. monthly ↔ yearly) — deferred to the next cycle.
- **Description** — applied immediately.
- **Until cycle number** (auto-cancel) — applied immediately.
- **Payment method overrides** — applied immediately.

Any change to items, coupons, or interval is recorded as a *pending
change* that takes effect at ``current_period_end``. The response carries a
``pending_change`` block describing the deferred change, including a
``next_invoice_preview`` and the per-line diff. If the next-cycle invoice
has already been generated and is unpaid, it is automatically cancelled
and re-issued with the new amount.

To change anything else (e.g. the consumer / payer), cancel the
subscription and create a new one. Use ``DELETE /pending-change`` to
revert a previously scheduled change before it takes effect.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-subscription-api-v-2-subscriptions-subscription-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-subscription-api-v-2-subscriptions-subscription-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-subscription-api-v-2-subscriptions-subscription-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Subscription Auto Renewal

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Subscription Auto Renewal"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/profile/subscription/{subscription_id}/auto-renewal"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Enable or disable auto-renewal for a subscription.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-subscription-auto-renewal-api-v-2-consumer-portal-profile-subscription-subscription-id-auto-renewal-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-subscription-auto-renewal-api-v-2-consumer-portal-profile-subscription-subscription-id-auto-renewal-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-subscription-auto-renewal-api-v-2-consumer-portal-profile-subscription-subscription-id-auto-renewal-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Subscription Auto Renewal Public

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Subscription Auto Renewal Public"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/consumer_portal/subscription/{subscription_id}/consumer/{organization_consumer_id}/auto-renewal"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Public endpoint for consumers to enable/disable auto-renewal for their subscriptions without authentication.

Requires both subscription_id and organization_consumer_id to verify ownership.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-subscription-auto-renewal-public-api-v-2-consumer-portal-subscription-subscription-id-consumer-organization-consumer-id-auto-renewal-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-subscription-auto-renewal-public-api-v-2-consumer-portal-subscription-subscription-id-consumer-organization-consumer-id-auto-renewal-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-subscription-auto-renewal-public-api-v-2-consumer-portal-subscription-subscription-id-consumer-organization-consumer-id-auto-renewal-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Subscription Freeze

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Subscription Freeze"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/subscriptions/{subscription_id}/freeze/{freeze_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update an existing subscription freeze period.

Allows modifying the start and end dates of a freeze period. The subscription will remain
frozen during the updated period.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./update-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-subscription-freeze-api-v-2-subscriptions-subscription-id-freeze-freeze-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Template Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Template Config"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/invoice-template"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update invoice template configuration.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-template-config-api-v-2-invoice-template-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-template-config-api-v-2-invoice-template-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Update Template Header Image

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Update Template Header Image"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/invoice-template/header-image"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update invoice template header image.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./update-template-header-image-api-v-2-invoice-template-header-image-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./update-template-header-image-api-v-2-invoice-template-header-image-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Upload Form Submission Document

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Upload Form Submission Document"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/consumer_portal/form-submissions/{submission_id}/documents"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Upload a private document for a form submission (PDF/image, max 10MB, max 10 files).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./upload-form-submission-document-api-v-2-consumer-portal-form-submissions-submission-id-documents-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./upload-form-submission-document-api-v-2-consumer-portal-form-submissions-submission-id-documents-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./upload-form-submission-document-api-v-2-consumer-portal-form-submissions-submission-id-documents-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Upload Payment Link Document

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Upload Payment Link Document"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/payment_links/documents"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Upload a document (PDF or image, max 10MB) to attach to a payment link at creation time.

Returns the document id to pass in the payment link create payload as `document_ids`.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./upload-payment-link-document-api-v-2-payment-links-documents-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./upload-payment-link-document-api-v-2-payment-links-documents-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Upsert Organization Config

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Upsert Organization Config"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/bnpl/organization-config/{provider_id}"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Upsert Organization Config

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./upsert-organization-config-api-v-2-bnpl-organization-config-provider-id-put.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./upsert-organization-config-api-v-2-bnpl-organization-config-provider-id-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./upsert-organization-config-api-v-2-bnpl-organization-config-provider-id-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Vat Number

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Vat Number"}
>
</Heading>

<MethodEndpoint
  method={"put"}
  path={"/api/v2/organization/vat-number"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Update the organization vat number.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./vat-number-api-v-2-organization-vat-number-put.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./vat-number-api-v-2-organization-vat-number-put.StatusCodes.json")}
>
  
</StatusCodes>

---

## Verify An Mfa Against An Identifier

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Verify An Mfa Against An Identifier"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/public/on-boarding/verify-identification-mfa"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Verify the multi-factor authentication code for identity confirmation.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./verify-an-mfa-against-an-identifier-api-v-2-public-on-boarding-verify-identification-mfa-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./verify-an-mfa-against-an-identifier-api-v-2-public-on-boarding-verify-identification-mfa-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Verify Forgot Password

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Verify Forgot Password"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/authentication/verify-forgot-password"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Verify the password reset code sent to user email.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./verify-forgot-password-api-v-2-authentication-verify-forgot-password-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./verify-forgot-password-api-v-2-authentication-verify-forgot-password-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Verify Pending User

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Verify Pending User"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/authentication/user/verify"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Verify user email with verification code and complete registration.

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./verify-pending-user-api-v-2-authentication-user-verify-get.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./verify-pending-user-api-v-2-authentication-user-verify-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./verify-pending-user-api-v-2-authentication-user-verify-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Wipe Organization Data

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Wipe Organization Data"}
>
</Heading>

<MethodEndpoint
  method={"delete"}
  path={"/api/v2/test-support/organizations/{organization_id}/data"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Hard-delete transactional data for a test organization (E2E cleanup).

Inherits router gates: non-production + `x-test-support-key`, private schema only.
Org must have ``settings.is_test_organization=True`` (independent of sandbox).
Deletes invoices/payments, subscriptions, payment links, customers, products,
notifications, and related rows. Keeps the organization shell (users, branches,
settings, accounts).

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./wipe-organization-data-api-v-2-test-support-organizations-organization-id-data-delete.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./wipe-organization-data-api-v-2-test-support-organizations-organization-id-data-delete.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./wipe-organization-data-api-v-2-test-support-organizations-organization-id-data-delete.StatusCodes.json")}
>
  
</StatusCodes>

---

## Withdraw Scope Request

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Withdraw Scope Request"}
>
</Heading>

<MethodEndpoint
  method={"post"}
  path={"/api/v2/connected-apps/scope-requests/{scope_request_id}/withdraw"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Withdraw Scope Request

<Heading
  id={"request"}
  as={"h2"}
  className={"openapi-tabs__heading"}
>
  <Translate id="theme.openapi.request.title">Request</Translate>
</Heading>

<ParamsDetails
  {...require("./withdraw-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-withdraw-post.ParamsDetails.json")}
>
  
</ParamsDetails>

<RequestSchema
  {...require("./withdraw-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-withdraw-post.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./withdraw-scope-request-api-v-2-connected-apps-scope-requests-scope-request-id-withdraw-post.StatusCodes.json")}
>
  
</StatusCodes>

---

## Zatca Eligibility

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Zatca Eligibility"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/zatca/eligibility"}
  context={"endpoint"}
>
  
</MethodEndpoint>

What the organization must complete (VAT number, CR / FL number, national address) to connect ZATCA.

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./zatca-eligibility-api-v-2-zatca-eligibility-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./zatca-eligibility-api-v-2-zatca-eligibility-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Zatca Onboarding Status

<Heading
  as={"h1"}
  className={"openapi__heading"}
  children={"Zatca Onboarding Status"}
>
</Heading>

<MethodEndpoint
  method={"get"}
  path={"/api/v2/zatca/onboard/status"}
  context={"endpoint"}
>
  
</MethodEndpoint>

Zatca Onboarding Status

<ParamsDetails>
  
</ParamsDetails>

<RequestSchema
  {...require("./zatca-onboarding-status-api-v-2-zatca-onboard-status-get.RequestSchema.json")}
>
  
</RequestSchema>

<StatusCodes
  {...require("./zatca-onboarding-status-api-v-2-zatca-onboard-status-get.StatusCodes.json")}
>
  
</StatusCodes>

---

## Express SDK


For the complete Express SDK documentation, please visit our GitHub repository:

**[📦 @streamsdk/express on GitHub →](https://github.com/streampayments/streamsdk-express)**

## Quick Links

- **[Installation & Quick Start](https://github.com/streampayments/streamsdk-express#installation)**
- **[API Documentation](https://github.com/streampayments/streamsdk-express#api-documentation)**
- **[Code Examples](https://github.com/streampayments/streamsdk-express/tree/main/examples)**
- **[Demo Application](https://github.com/streampayments/stream-express-sdk-demo)**
- **[npm Package](https://www.npmjs.com/package/@streamsdk/express)**

## Overview

The Stream Express SDK provides a clean, declarative way to integrate Stream payments into your Express.js applications. Built on top of [@streamsdk/typescript](https://www.npmjs.com/package/@streamsdk/typescript), it offers drop-in handlers for checkout flows and webhook processing.

**Key Benefits:**

- 🚀 **Simple Integration** - Add payment processing in minutes
- 🔒 **Type-Safe** - Full TypeScript support with type definitions
- 🎯 **Event-Driven** - Clean event handlers for webhook processing
- 🔄 **Flexible** - Supports guest and authenticated checkout flows
- 📦 **Lightweight** - Minimal dependencies (~7KB)
- 🔗 **Auto-Updates** - Inherits stream-sdk updates automatically

## Installation

```bash
npm install @streamsdk/express
```

## Quick Example

```typescript

const app = express();
app.use(express.json());

// Payment link handler
app.get("/checkout", Checkout({
  apiKey: process.env.STREAM_API_KEY!,
  successUrl: "https://myapp.com/success",
  returnUrl: "https://myapp.com/cancel",
}));

// Webhook handler with events
app.post("/webhooks/stream", Webhooks({
  apiKey: process.env.STREAM_API_KEY!,
  onPaymentSucceeded: async (data) => {
    console.log("Payment succeeded:", data);
    // Update your database, send confirmation emails, etc.
  },
  onPaymentFailed: async (data) => {
    console.log("Payment failed:", data);
  },
  onInvoiceCreated: async (data) => {
    console.log("Invoice created:", data);
  },
}));

app.listen(3000);
```

For complete documentation, examples, and API reference, visit the [GitHub repository](https://github.com/streampayments/streamsdk-express).

## Demo Application

Want to see it in action? Clone and run the **[Express SDK demo repository](https://github.com/streampayments/stream-express-sdk-demo)** locally for a quick working example.

## Related SDKs

- **[TypeScript SDK](/sdks/typescript)** - Core SDK for Node.js/TypeScript
- **[API Reference](/api/v2-payment-links-create)** - REST API documentation
- **[Webhooks Guide](/webhooks)** - Webhook event reference

---

## TypeScript SDK


For the complete TypeScript SDK documentation, please visit our GitHub repository:

**[📦 @streamsdk/typescript on GitHub →](https://github.com/streampayments/streamsdk-typescript)**

## Quick Links

- **[Installation & Quick Start](https://github.com/streampayments/streamsdk-typescript#installation)**
- **[API Documentation](https://github.com/streampayments/streamsdk-typescript#api-documentation)**
- **[Code Examples](https://github.com/streampayments/streamsdk-typescript/tree/main/examples)**
- **[npm Package](https://www.npmjs.com/package/@streamsdk/typescript)**

## Overview

The Stream TypeScript SDK provides a complete Node.js/TypeScript interface for:

- 🔐 Secure API Key authentication
- 👥 Customer (Consumer) management
- 📦 Product catalog management
- 💳 Payment link creation
- 🔄 Subscription handling
- 🧾 Invoice generation
- 🎟️ Coupon & discount management

## Installation

```bash
npm install @streamsdk/typescript
```

## Quick Example

```typescript

const client = StreamSDK.init(process.env.STREAM_API_KEY!);

const result = await client.createSimplePaymentLink({
  name: "Monthly Subscription",
  amount: 99.99,
  consumer: {
    email: "customer@example.com",
    name: "Ahmad Ali",
    phone: "+966501234567",
  },
  product: {
    name: "Premium Plan",
    price: 99.99,
  },
  successRedirectUrl: "https://yourapp.com/success",
  failureRedirectUrl: "https://yourapp.com/failure",
});

console.log("Payment URL:", result.paymentUrl);
```

For complete documentation, examples, and API reference, visit the [GitHub repository](https://github.com/streampayments/streamsdk-typescript).

## Related SDKs

- **[Express.js SDK](/sdks/express)** - Framework adapter for Express.js applications
- **[API Reference](/api/v2-payment-links-create)** - REST API documentation