> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://beta-docs.payabli.com/developer-guides/devices-pax-a920-setup/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://beta-docs.payabli.com/_mcp/server.

# PAX A920 guide

The PAX A920 is an integrated portable payment device that lets you accept payments via magnetic stripe, EMV chip, and NFC contactless technology. This guide walks through the steps to set up your new PAX device and register it with Payabli so you can start processing transactions.

> **Note**
>
> The PAX A920 is supported only in production environments, and can't be used in sandbox.

## Setup

The next sections cover how to unbox and set up your PAX A920 device.

### Prepare the device

When you receive your PAX A920 device, follow these instructions to unbox and get the device ready to register in Payabli.

#### Unbox the Device

The PAX A920 comes with a USB power cord and 3 rolls of receipt paper (one roll preinstalled).

#### Power the Device

1. Plug the device in to a power source. You can plug into a wall or a computer using the included USB power adapter.
2. Fully charge the device before turning it on.
3. When the device is charged, power it on by pressing and holding the small rectangle button on the right side of the device for 2 to 4 seconds.

#### Connect to WiFi

After the device boots up, it automatically launches the WSPLink app. You can't use your own apps with the PAX device

1. Exit the WSPLink app by pressing the top left and bottom right corners of the screen at the same time.
2. Open the **Settings** app.
3. Toggle WiFi on, then press **Wi-Fi**. The device will detect nearby WiFi networks.
4. Select the network you want to connect to, enter password, and allow the device to connect.

> **Note**
>
> The PAX A920 connects only to 2.4Ghz WiFi networks, and can't connect to 5 GHz networks.

5. Press the circle icon at the bottom of the screen to go back to the home screen.

#### Let the Device Update

After the device connects to WiFi, it will cycle through updating the embedded software. This step can take up to 15 minutes, and the device may make some noises or alerts during this process.

> **Warning**
>
> Don't turn off the device, open any apps or disconnect WiFi during the update process.

When the updates have finished, the screen will be fully white.

#### Open WSPLink

WSPLink is the app that you use to make transactions. Press the WSPLink icon to open the app.

> **Note**
>
> The screen may be blank or all white. This is normal. The screen lights up when a payment is sent to it.

#### Register the Device in Payabli

Now, you must register the device in Payabli before you can accept payments.

### Register the device

To register a PAX A920, copy the serial number from the back of the device, and then send a request the [/Cloud/register/\{entry}](/api-reference/cloud/register-cloud-device) endpoint.

### Request

POST [https://api-sandbox.payabli.com/api/Cloud/register/\{entry}](https://api-sandbox.payabli.com/api/Cloud/register/\{entry})

**`Register`**

```curl Register
curl -X POST https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267 \
     -H "requestToken: <apiKey>" \
     -H "Content-Type: application/json" \
     -d '{
  "description": "Front Desk POS",
  "registrationCode": "YS7DS5"
}'
```

**`Register`**

```python Register
import requests

url = "https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267"

payload = {
    "description": "Front Desk POS",
    "registrationCode": "YS7DS5"
}
headers = {
    "requestToken": "<apiKey>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())
```

**`Register`**

```javascript Register
const url = 'https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267';
const options = {
  method: 'POST',
  headers: {requestToken: '<apiKey>', 'Content-Type': 'application/json'},
  body: '{"description":"Front Desk POS","registrationCode":"YS7DS5"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

**`Register`**

```go Register
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267"

	payload := strings.NewReader("{\n  \"description\": \"Front Desk POS\",\n  \"registrationCode\": \"YS7DS5\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("requestToken", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

**`Register`**

```ruby Register
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["requestToken"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"description\": \"Front Desk POS\",\n  \"registrationCode\": \"YS7DS5\"\n}"

response = http.request(request)
puts response.read_body
```

**`Register`**

```java Register
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267")
  .header("requestToken", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"description\": \"Front Desk POS\",\n  \"registrationCode\": \"YS7DS5\"\n}")
  .asString();
```

**`Register`**

```php Register
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267', [
  'body' => '{
  "description": "Front Desk POS",
  "registrationCode": "YS7DS5"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'requestToken' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

**`Register`**

```csharp Register
using RestSharp;

var client = new RestClient("https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267");
var request = new RestRequest(Method.POST);
request.AddHeader("requestToken", "<apiKey>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"Front Desk POS\",\n  \"registrationCode\": \"YS7DS5\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

**`Register`**

```swift Register
import Foundation

let headers = [
  "requestToken": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "description": "Front Desk POS",
  "registrationCode": "YS7DS5"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/Cloud/register/8cfec329267")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```

## PAX A920 asynchronous flow

The PAX A920 device uses an asynchronous flow to process transactions.
The transaction is initiated by the device, and the final status is sent to you in a webhook event.

#### Initiate transaction

The device sends a request to the Payabli API to process the transaction.

#### Initial response

The API responds with the current status of the transaction.
The transaction isn't complete yet.

#### Webhook response

When the transaction is complete, the API sends a webhook event to notify you of the final status of the transaction.

> **Note**
>
> You must enable webhook notifications to receive them. They are not sent by default.
> See [Set up and receive events using Web](https://docs.payabli.com/developer-guides/notifications-and-webhooks-overview#set-up-and-receive-events-using-web-webhooks) for more information.

The response for an initiated transaction looks like this:

**`Initiated transaction response`**

```json Initiated transaction response
{
  "responseText": "Success",
  "isSuccess": true,
  "pageIdentifier": null,
  "responseData": {
    "authCode": null,
    "referenceId": "237-e2928ea2f73d473f95f4094d56870ffc",
    "resultCode": 1,
    "resultText": "Initiated",
    "avsResponseText": null,
    "cvvResponseText": null,
    "customerId": 319082,
    "methodReferenceId": null
  }
}
```

The `resultText` has a value of `"Initiated"`, which means the transaction is in progress.

To get the final status of the transaction, you need to listen for either the `ApprovedPayment` webhook event or the `DeclinedPayment` webhook event.
The webhook payloads for a completed transaction look like this:

**`Success`**

```json Success
{
  "Event": "ApprovedPayment",
  "Paypoint": "Athlete Factory LLC\r\n",
  "Text": "Payment Approved!",
  "transId": "10-33eb676a-da48-401f-9494-e69a324b152d",
  "NetAmount": "100.00",
  "Fee": "0.00",
  "TotalAmount": "100.00",
  "transTime": "04/04/2022 13:56:17",
  "CustomerId": "224",
  "CustomerNumber": "888"
}
```

**`Failure`**

```json Failure
{
  "Event": "DeclinedPayment",
  "Paypoint": "Athlete Factory LLC",
  "Text": "Payment Declined!",
  "transId": "10-073d7d504e3c4357be3ff904f9653b4a",
  "NetAmount": "0.05",
  "Fee": "0.00",
  "TotalAmount": "0.05",
  "transTime": "9/18/2023 7:20:14 PM",
  "CustomerId": "1323",
  "CustomerNumber": "customer-xchg_004"
}
```

See [Notifications and Reports Overview](/developer-guides/notifications-and-webhooks-overview) for more information on how to set up webhooks.

> If you're a software company, you're a payments company™