canonical: https://jentic.com/apis/azupay.com.au/azupay

# Azupay Payments API

Jentic publishes the only available OpenAPI specification for Azupay Payments API, keeping it validated and agent-ready. Azupay provides Australian real-time account-to-account payments through the New Payments Platform (NPP) and PayTo rails. The API covers payment requests with PayID resolution, immediate payments, refunds, account and BSB reachability checks, balance enquiries, client management, and API key rotation. Settlement happens directly between bank accounts, so there is no card processing or interchange involved.

## For AI agents

Initiate, track, and refund Australian NPP and PayTo bank payments, resolve PayIDs, and check account reachability without touching card rails.

## Scope

Does not handle card processing, international payments, or merchant onboarding - use for Australian NPP and PayTo bank-rail payments only.

## Capabilities

- Create a payment request and resolve a PayID before money moves
- Issue a same-rail refund against a previously settled payment request
- Check whether a destination BSB and account are reachable on NPP or PayTo
- Retrieve the balance of an Azupay client float account on demand
- Search payments and payment requests by reference, status, or date range
- Rotate Azupay API keys and manage client records programmatically

## Use cases

### NPP Real-Time Collections

Collect funds from Australian customers in seconds using the New Payments Platform instead of card rails. The Azupay API issues a payment request linked to a PayID or BSB and account, the customer confirms in their banking app, and settlement reaches the merchant float account within seconds. There is no card surcharge, no chargeback exposure, and reconciliation uses a single end-to-end identifier.

Example prompt: Create a payment request for AUD 250.00 with reference INV-2031, poll its status until settled, and store the resulting paymentId against the invoice

### PayTo Recurring Authorisations

Set up customer-authorised recurring debits over the PayTo rail as an alternative to direct debit. The API takes a PayTo agreement reference and triggers payments against it, with each debit confirmed in real time and visible to the payer in their bank app. Suitable for subscription billing, instalment plans, and utility-style recurring collections in Australia.

Example prompt: Trigger a PayTo debit for AUD 49.95 against an existing PayTo agreement reference and record the payment status

### Refunds and Reconciliation

Reverse a previously settled NPP payment back to the original payer with a single call against the payment request. The `/paymentRequest/{paymentRequestId}/refund` endpoint issues a like-for-like refund on the same rail, and the search endpoints return paginated payment and payment request history for back-office reconciliation against the merchant ledger.

Example prompt: Refund payment request pr_5821 in full and write the refund identifier back to the order record

### Agent-Driven Australian Payments via Jentic

An AI agent orchestrating Australian commerce workflows can resolve a PayID, create an Azupay payment request, and confirm settlement without leaving the conversation. Jentic exposes Azupay operations behind intent search and isolates the API key in the credential vault, so the agent never sees the raw secret. Integration is one search-load-execute cycle instead of a manual PayID-to-payment flow.

Example prompt: Search Jentic for 'collect a NPP payment in Australia', load the Azupay create payment request schema, and execute it for AUD 120.00 to a supplied PayID

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/paymentRequest` | Create a payment request |
| GET | `/paymentRequest/{paymentRequestId}` | Get a payment request |
| POST | `/paymentRequest/{paymentRequestId}/refund` | Refund a payment request |
| POST | `/payment` | Make a payment |
| POST | `/payment/search` | Search payments |
| POST | `/accountEnquiry` | Check BSB reachability for NPP and PayTo |

## Key resources

- **Payment Requests** — Create, retrieve, refund, and search payment requests against PayIDs or BSB+account targets
- **Payments** — Trigger immediate payments, retrieve a payment by id, and search payment history
- **Account Enquiry** — Check NPP and PayTo reachability for a given BSB and account
- **Balance** — Retrieve the current balance of an Azupay client float account
- **Clients** — Manage Azupay client records under a merchant account
- **API Keys** — List and rotate the API keys used to authenticate API calls

## Why Jentic

- **Setup:** Wiring Azupay by hand means passing the secret key in the Authorization header, choosing between the UAT host api-uat.azupay.com.au and the production api.azupay.com.au, and building the payment-request lifecycle and refund flows yourself. Through Jentic you install once, import the Azupay Payments API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** Azupay puts the payment request id in the URL path (`/paymentRequest/{paymentRequestId}/...`) while the amount, reference, and target travel in the request body, so scoping is by operation. You limit the agent to the operations it needs, such as POST /paymentRequest or POST /accountEnquiry, so a refund or an API key rotation is not available unless you add it.
- **Credential handling:** Your Azupay API key is stored once, encrypted, by your own Jentic One instance and injected into the Authorization header at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'collect an NPP payment in Australia' or 'check if an account can receive PayTo', and Jentic returns the matching Azupay operation with its input schema so the agent calls the right endpoint without browsing the docs.

## Related APIs

- **Stripe API** — Card and wallet processing globally; covers Australia via card rails rather than NPP/PayTo.
- **Adyen Checkout Service** — Global enterprise payment processor with Australian acquiring; predominantly card and APM rails.
- **Stripe Stripe** — Use alongside Azupay for international card acceptance while Azupay handles domestic AU bank-rail collections.

## FAQ

### Why is there no official OpenAPI spec for Azupay Payments API?

Azupay does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Azupay Payments API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Azupay Payments API use?

The API uses an API key passed in the Authorization header. Through Jentic, the key is stored encrypted in your Jentic One instance credential vault and injected at execution time, so the raw key never enters the agent's context. Rotate keys with the API key endpoints when access changes.

### Can I refund an NPP payment with the Azupay Payments API?

Yes. POST `/paymentRequest/{paymentRequestId}/refund` issues a same-rail refund against a previously settled payment request, returning a refund identifier you can store against the original order.

### How do I check if an Australian bank account can receive a PayTo or NPP payment?

Use POST /accountEnquiry with the BSB and account number. The response indicates NPP and PayTo reachability before you create a payment request, which avoids failed transfers to non-participating institutions.

### What are the rate limits for the Azupay Payments API?

The OpenAPI spec does not declare numeric rate limits. Treat the API as production-grade for real-time settlement and contact Azupay support for limit increases if you exceed throughput on a sandbox or production tenant.

### How do I trigger an Azupay payment through Jentic?

Run pip install jentic, then search Jentic with the natural-language query 'collect a NPP payment in Australia'. Jentic returns the POST /paymentRequest operation, you load its input schema, then execute with amount, reference, and target PayID or BSB. The API key is resolved from the vault automatically.

### Can I limit what my agent is allowed to do with the Azupay Payments API?

Yes. Because Jentic One is self-hosted, you set the rules for which operations and credentials your agent may use, and Azupay scopes access by operation. You can allow only the endpoints the workflow needs, such as POST /paymentRequest to collect a payment or POST /accountEnquiry to check reachability, while withholding others. That means a refund via POST `/paymentRequest/{paymentRequestId}/refund` or an API key rotation stays unavailable to the agent unless you explicitly add it.