> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gr4vy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Smartpay

> Connect to Smartpay to accept bank payments in Japan.

Smartpay is a Japanese payment platform offering real-time bank payments and card payments. Smartpay uses a redirect flow where the buyer approves the payment on the Smartpay hosted page.

## Setup

Sign up for an account on the [Smartpay website](https://smartpay.co/en/). Once signed up, head over to the [Smartpay dashboard](https://dashboard.smartpay.co/settings/credentials) to get your API credentials.

## Credentials

When setting up Smartpay in the dashboard, configure the following credentials:

* **Secret key** - The secret key found in your [Smartpay dashboard](https://dashboard.smartpay.co/settings/credentials) under **Settings** > **Credentials**.

## Features

Smartpay supports the following features:

* **Delayed capture** - Authorize a payment and capture it at a later time
* **Partial capture** - Capture a portion of the authorized amount
* **Partial refunds** - Refund a portion of the captured amount
* **Refunds** - Refund transactions in full
* **Void** - Cancel an authorized transaction before capture

## Supported countries

Smartpay supports transactions from buyers in `JP`.

## Supported currencies

Smartpay supports processing payments in `JPY`.

## Limitations

The following features are not supported by this connector:

* **Payment method tokenization** - Storing payment methods for future use is not supported
* **Zero auth** - Zero-dollar verification transactions are not supported
* **Over capture** - Capturing more than the authorized amount is not supported
* **Partial authorization** - Accepting a partial amount when the full amount cannot be authorized is not supported
* **Settlement reporting** - Automatic settlement reporting is not supported

## Required fields

Smartpay requires the following fields to be set on every transaction:

* First name and last name
* Email address
* Billing and shipping address, including city, country, line 1, postal code, and state

Because of this, Smartpay only works with Embed when the shipping address has been set.

Optionally, you can pass up to 249 cart items with a transaction.

## Webhooks

Webhooks are required for Smartpay to function correctly. Set up webhooks in the [Smartpay dashboard](https://dashboard.smartpay.co/settings/credentials) and configure the webhook URL provided in the Gr4vy dashboard under your Smartpay connection.

## Integration

The default integration for Smartpay uses a redirect to a hosted payments page.

Start by creating a new transaction with the following required fields.

<CodeGroup>
  ```csharp C# theme={"system"}
  var transaction = await client.Transactions.CreateAsync(
    transactionCreate: new TransactionCreate()
    {
      Amount = 1299,
      Currency = "JPY",
      Country = "JP",
      PaymentMethod =
        TransactionCreatePaymentMethod.CreateCheckoutSessionWithUrlPaymentMethodCreate(
          new RedirectPaymentMethodCreate()
          {
            Method = "smartpay",
            RedirectUrl = "https://example.com/callback",
          }
        ),
    }
  );
  ```

  ```go Go theme={"system"}
  amount := int64(1299)
  currency := "JPY"
  country := "JP"
  method := "smartpay"
  redirectUrl := "https://example.com/callback"

  redirectPaymentMethodCreate := components.RedirectPaymentMethodCreate{
    Method: method,
    RedirectUrl: redirectUrl,
  }
  paymentMethod := components.CreateTransactionCreatePaymentMethodRedirectPaymentMethodCreate(redirectPaymentMethodCreate)

  transactionCreate := components.TransactionCreate{
    Amount:        amount,
    Currency:      currency,
    Country:       &country,
    PaymentMethod: &paymentMethod,
  }

  transaction, err := client.Transactions.Create(ctx, transactionCreate, nil, nil)
  ```

  ```java Java theme={"system"}
  CreateTransactionResponse transactionResponse = gr4vyClient.transactions().create()
    .transactionCreate(TransactionCreate.builder()
      .amount(1299L)
      .currency("JPY")
      .country("JP")
      .paymentMethod(TransactionCreatePaymentMethod.of(RedirectPaymentMethodCreate.builder()
        .method("smartpay")
        .redirectUrl("https://example.com/callback")
        .build()))
      .build())
    .call();

  Transaction transaction = transactionResponse.transaction().orElse(null);
  ```

  ```php PHP theme={"system"}
  $transactionCreate = new TransactionCreate(
    amount: 1299,
    currency: 'JPY',
    country: 'JP',
    paymentMethod: new RedirectPaymentMethodCreate(
      method: 'smartpay',
      redirectUrl: 'https://example.com/callback'
    )
  );
  $response = $client->transactions->create($transactionCreate);
  $transaction = $response->transaction;
  ```

  ```python Python theme={"system"}
  transaction: models.Transaction = client.transactions.create(
    amount=1299,
    currency="JPY",
    country="JP",
    payment_method={
      "method": "smartpay",
      "redirect_url": "https://example.com/callback",
    }
  )
  ```

  ```ts TypeScript theme={"system"}
  const transaction = await client.transactions.create({
    amount: 1299,
    currency: "JPY",
    country: "JP",
    paymentMethod: {
      method: "smartpay",
      redirectUrl: "https://example.com/callback"
    }
  })
  ```
</CodeGroup>

After the transaction is created, the API response includes a `payment_method.approval_url` and the status is set to `buyer_approval_pending`. The approval URL expires after 30 minutes.

```json theme={"system"}
{
  "type": "transaction",
  "id": "ea1efdd0-20f9-44d9-9b0b-0a3d71e9b625",
  "payment_method": {
    "type": "payment-method",
    "approval_url": "https://cdn.gr4vy.com/connectors/..."
  },
  "method": "smartpay"
}
```

Redirect the buyer to the `approval_url` (open in a browser or popup), where they can complete the payment. Once the buyer approves, the transaction progresses to an `authorization_succeeded` or `capture_succeeded` state.