# `Rapyd.Services.Collect`
[🔗](https://github.com/iamkanishka/rapyd/blob/v1.0.0/lib/rapyd/services/collect.ex#L1)

Rapyd Collect — accept payments globally.

Covers: Payments, Hosted Checkout Pages, Payment Links, Group Payments,
Refunds, Disputes, Customers, Plans, Subscriptions, Invoices, Coupons,
Orders, SKUs, Card Tokens, Payment Devices, and FX Rates.

All functions return `{:ok, map()}` or `{:error, %Rapyd.Error{}}`.
The map is the raw `"data"` field from the Rapyd response envelope;
cast it with the structs in `Rapyd.Types.*` as needed.

# `cancel_escrow`

```elixir
@spec cancel_escrow(Rapyd.Client.t(), String.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Cancel an escrow record.

# `cancel_payment`

```elixir
@spec cancel_payment(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Cancel a payment.

# `cancel_refund`

```elixir
@spec cancel_refund(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Cancel a pending refund.

# `cancel_subscription`

```elixir
@spec cancel_subscription(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Cancel a subscription.

# `capture_payment`

```elixir
@spec capture_payment(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Capture a previously authorized payment.

# `complete_payment`

```elixir
@spec complete_payment(Rapyd.Client.t(), String.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Complete a payment that requires a redirect (e.g. after 3DS).

`token` is the payment token; `param3` is the redirect param returned by the
payment method provider.

# `complete_refund`

```elixir
@spec complete_refund(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Simulate a refund completion (sandbox only).

# `create_address`

```elixir
@spec create_address(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create an address.

# `create_card_token`

```elixir
@spec create_card_token(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a card token (PCI vault).

# `create_checkout_page`

```elixir
@spec create_checkout_page(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a hosted checkout page.

# `create_coupon`

```elixir
@spec create_coupon(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a coupon.

# `create_customer`

```elixir
@spec create_customer(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a customer.

# `create_customer_payment_method`

```elixir
@spec create_customer_payment_method(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Add a payment method to a customer.

# `create_escrow_payment`

```elixir
@spec create_escrow_payment(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create an escrow payment.

# `create_group_payment`

```elixir
@spec create_group_payment(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a group payment.

# `create_group_refund`

```elixir
@spec create_group_refund(Rapyd.Client.t(), String.t(), float()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a refund for a group payment.

# `create_invoice`

```elixir
@spec create_invoice(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create an invoice.

# `create_invoice_item`

```elixir
@spec create_invoice_item(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create an invoice item.

# `create_order`

```elixir
@spec create_order(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create an order.

# `create_payment`

```elixir
@spec create_payment(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a payment.

# `create_payment_link`

```elixir
@spec create_payment_link(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a payment link.

# `create_plan`

```elixir
@spec create_plan(Rapyd.Client.t(), map()) :: {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a billing plan.

# `create_refund`

```elixir
@spec create_refund(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a refund.

# `create_sku`

```elixir
@spec create_sku(Rapyd.Client.t(), map()) :: {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a SKU.

# `create_subscription`

```elixir
@spec create_subscription(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Create a subscription.

# `delete_address`

```elixir
@spec delete_address(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete an address.

# `delete_checkout_page`

```elixir
@spec delete_checkout_page(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a checkout page.

# `delete_coupon`

```elixir
@spec delete_coupon(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a coupon.

# `delete_customer`

```elixir
@spec delete_customer(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a customer.

# `delete_customer_discount`

```elixir
@spec delete_customer_discount(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Remove the discount applied to a customer.

# `delete_customer_payment_method`

```elixir
@spec delete_customer_payment_method(Rapyd.Client.t(), String.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a customer's saved payment method.

# `delete_group_payment`

```elixir
@spec delete_group_payment(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a group payment.

# `delete_invoice`

```elixir
@spec delete_invoice(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete an invoice.

# `delete_invoice_item`

```elixir
@spec delete_invoice_item(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete an invoice item.

# `delete_payment_device`

```elixir
@spec delete_payment_device(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a payment device.

# `delete_payment_link`

```elixir
@spec delete_payment_link(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a payment link.

# `delete_plan`

```elixir
@spec delete_plan(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a plan.

# `delete_sku`

```elixir
@spec delete_sku(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Delete a SKU.

# `delete_subscription_discount`

```elixir
@spec delete_subscription_discount(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Remove the discount applied to a subscription.

# `finalize_invoice`

```elixir
@spec finalize_invoice(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Finalize a draft invoice (moves it to open status).

# `get_address`

```elixir
@spec get_address(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve an address.

# `get_card_token`

```elixir
@spec get_card_token(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a card token.

# `get_checkout_page`

```elixir
@spec get_checkout_page(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a checkout page by token.

# `get_coupon`

```elixir
@spec get_coupon(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a coupon.

# `get_customer`

```elixir
@spec get_customer(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a customer.

# `get_customer_payment_method`

```elixir
@spec get_customer_payment_method(Rapyd.Client.t(), String.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a customer's saved payment method.

# `get_dispute`

```elixir
@spec get_dispute(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a dispute.

# `get_group_payment`

```elixir
@spec get_group_payment(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a group payment.

# `get_invoice`

```elixir
@spec get_invoice(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve an invoice.

# `get_invoice_item`

```elixir
@spec get_invoice_item(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve an invoice item.

# `get_order`

```elixir
@spec get_order(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve an order.

# `get_payment`

```elixir
@spec get_payment(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a payment by ID.

# `get_payment_device`

```elixir
@spec get_payment_device(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a payment device.

# `get_payment_link`

```elixir
@spec get_payment_link(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a payment link.

# `get_payment_method_fields`

```elixir
@spec get_payment_method_fields(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Get the required fields for a payment method type.

# `get_payment_methods_by_country`

```elixir
@spec get_payment_methods_by_country(Rapyd.Client.t(), String.t(), String.t()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

Get available payment methods for a country and currency.

# `get_plan`

```elixir
@spec get_plan(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a plan.

# `get_refund`

```elixir
@spec get_refund(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a refund.

# `get_sku`

```elixir
@spec get_sku(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a SKU.

# `get_subscription`

```elixir
@spec get_subscription(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Retrieve a subscription.

# `list_coupons`

```elixir
@spec list_coupons(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List coupons.

# `list_customer_payment_methods`

```elixir
@spec list_customer_payment_methods(Rapyd.Client.t(), String.t()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List a customer's saved payment methods.

# `list_customers`

```elixir
@spec list_customers(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List customers.

# `list_disputes`

```elixir
@spec list_disputes(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List disputes.

# `list_invoice_items`

```elixir
@spec list_invoice_items(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List invoice items.

# `list_invoices`

```elixir
@spec list_invoices(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List invoices.

# `list_orders`

```elixir
@spec list_orders(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List orders.

# `list_payment_devices`

```elixir
@spec list_payment_devices(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List payment devices.

# `list_payment_links`

```elixir
@spec list_payment_links(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List payment links.

# `list_payments`

```elixir
@spec list_payments(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List payments with optional filters.

# `list_plans`

```elixir
@spec list_plans(Rapyd.Client.t(), map()) :: {:ok, list()} | {:error, Rapyd.Error.t()}
```

List plans.

# `list_refunds`

```elixir
@spec list_refunds(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List refunds.

# `list_skus`

```elixir
@spec list_skus(Rapyd.Client.t(), map()) :: {:ok, list()} | {:error, Rapyd.Error.t()}
```

List SKUs.

# `list_subscription_items`

```elixir
@spec list_subscription_items(Rapyd.Client.t(), String.t()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List a subscription's items.

# `list_subscriptions`

```elixir
@spec list_subscriptions(Rapyd.Client.t(), map()) ::
  {:ok, list()} | {:error, Rapyd.Error.t()}
```

List subscriptions.

# `pair_payment_device`

```elixir
@spec pair_payment_device(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Pair a payment device to a merchant terminal.

# `pay_invoice`

```elixir
@spec pay_invoice(Rapyd.Client.t(), String.t()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Pay an invoice immediately.

# `pay_order`

```elixir
@spec pay_order(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Pay / fulfil an order.

# `register_payment_device`

```elixir
@spec register_payment_device(Rapyd.Client.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Register a payment device (POS terminal).

# `release_escrow`

```elixir
@spec release_escrow(Rapyd.Client.t(), String.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Release escrowed funds on a specific escrow record.

# `release_escrow_payment`

```elixir
@spec release_escrow_payment(Rapyd.Client.t(), String.t(), [map()]) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Release escrowed funds to one or more wallets.

# `return_order`

```elixir
@spec return_order(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Return an order.

# `update_address`

```elixir
@spec update_address(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update an address.

# `update_checkout_page`

```elixir
@spec update_checkout_page(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a checkout page.

# `update_coupon`

```elixir
@spec update_coupon(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a coupon.

# `update_customer`

```elixir
@spec update_customer(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a customer.

# `update_customer_payment_method`

```elixir
@spec update_customer_payment_method(Rapyd.Client.t(), String.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a customer's saved payment method.

# `update_dispute`

```elixir
@spec update_dispute(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a dispute (submit evidence).

# `update_invoice`

```elixir
@spec update_invoice(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update an invoice.

# `update_order`

```elixir
@spec update_order(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update an order.

# `update_payment`

```elixir
@spec update_payment(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a payment.

# `update_payment_device`

```elixir
@spec update_payment_device(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a payment device.

# `update_payment_link`

```elixir
@spec update_payment_link(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a payment link.

# `update_plan`

```elixir
@spec update_plan(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a plan.

# `update_refund`

```elixir
@spec update_refund(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a refund.

# `update_sku`

```elixir
@spec update_sku(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a SKU.

# `update_subscription`

```elixir
@spec update_subscription(Rapyd.Client.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a subscription.

# `update_subscription_item`

```elixir
@spec update_subscription_item(Rapyd.Client.t(), String.t(), String.t(), map()) ::
  {:ok, map()} | {:error, Rapyd.Error.t()}
```

Update a subscription item.

---

*Consult [api-reference.md](api-reference.md) for complete listing*