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

# Zip via the API

To handle Zip via the API directly, follow the [quick start guide](/guides/payments/direct-api/quick-start) on
direct API integrations, or use the steps below.

## Create a transactions

To create a Zip transaction, set the `method` to `zippay` and the `redirect_url` to the endpoint of your app that can handle the customer returning once they've completed approving the transaction on the Zip site.

See the [`POST /transactions`](/reference/transactions/new-transaction) API endpoint for more details.

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

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

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

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

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

  // handle response
  ```

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

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

  // handle response
  ```

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

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

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

If successful, the response of this transaction includes a `status` set to `buyer_approval_pending` as well as a `payment_method.approval_url`.

<CodeGroup>
  ```json Response theme={"system"}
  {
      "type": "transaction",
      "id": "0c41c8df-27f4-480e-97f0-9401558ae25e",
      "status": "buyer_approval_pending",
      "intent": "authorize",
      "payment_method": {
          "type": "payment-method",
          "method": "zippay",
          "mode": "redirect",
          "approval_url": "https://zip.co/checkout?co=c0_abc123&m=aaaa-bbbb-cccc",
         ...
      },
      "method": "zippay",
      ...
  }
  ```
</CodeGroup>

## About tokenization

If your Zip account supports recurring payment, then you can pass the `store=true` parameter to each request to vault a Zip agreement for future use.

Once stored, you can use the vaulted Zip agreement for future transactions without redirecting the buyer to Zip.

## Handle redirect to Zip

Your app needs to redirect your customer to Zip where they are required to approve the payment. To do so, redirect the customer to the `payment_method.approval_url`. After they've authenticated themselves, the customer is redirected back to the `redirect_url` that you set when creating the transaction.

<Warning>
  If the customer abandons the checkout or somehow experiences network
  connection issues, the transaction state can get out of sync between your
  application and ours. We recommend [the following best
  practices](/guides/best-practice) in handling these situations.
</Warning>

## Handle the return to your app

When the customer is redirected back to your app, the transaction status is not known. Your application will therefore need to call our API to get the latest transaction status. To do this, your `redirect_url` will be appended with the `transaction_id`.

```
[redirect_url]?transaction_id=2f37e0d0-5549-42c4-9c5c-e03d5fa97148&transaction_status=capture_succeeded
```

<Warning>
  Although we also provide the `transaction_status` in this callback, it's
  recommended to also fetch the latest status via the API, as the status may
  have changed since.
</Warning>

After you've handled the redirect, you can display a message to your customer letting them know the result of the transaction.

## Fetch the latest status

Finally, after the transaction has been created your application can get the
latest details and status using the transaction ID received via the callback to
the redirect URL, or on direct callback from the API.

<CodeGroup>
  ```js cURL theme={"system"}
  curl -i -X GET "https://api.example.gr4vy.app/transactions/fe26475d-ec3e-4884-9553-f7356683f7f9" \
      -H "Authorization: Bearer [JWT_TOKEN]"
  ```

  ```js Node theme={"system"}
  const response = await client.getTransaction(transaction_id);
  console.log(response.data);
  ```

  ```python Python theme={"system"}
  response = client.GetTransaction(transaction_id)
  print(response)
  ```

  ```php PHP theme={"system"}
  $result = $apiInstance->getTransaction($transaction_id);
  echo $result;
  ```
</CodeGroup>

The transaction includes details about the payment method used and the status
of the transaction.

```json theme={"system"}
{
  "type": "transaction",
  "id": "fe26475d-ec3e-4884-9553-f7356683f7f9",
  "status": "authorized",
  "amount": 1299,
  "currency": "AUD",
  "payment_method": {
    "type": "payment-method",
    "id": "77a76f7e-d2de-4bbc-ada9-d6a0015e6bd5",
    "method": "zippay",
    ...
  },
  ...
}
```

<Info>
  Visit the [API reference documentation](/reference) for full details about the
  transaction resource, and any other API.
</Info>