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

# Create resident charge

POST https://api.propexo.com/v1/resident-charges/
Content-Type: application/json

Create a resident charge for an integration.

Reference: https://docs.propexo.com/api-reference/pms-generic-ap-is/billing-and-payments/create-resident-charge

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Servers

- `https://api.propexo.com` (Production, default)
- `https://api.sandbox.propexo.com` (Sandbox)

## Request

### Body (application/json)

This endpoint expects a _v1_resident-charges__post_input.

- `integration_id` (string, required)
- `lease_id` (string, optional) — The Propexo unique identifier for the lease
- `financial_account_id` (string, optional) — The Propexo unique identifier for the financial account
- `amount_in_cents` (integer, optional) — The amount of the resident charge, in cents
- `transaction_date` (V1ResidentChargesPostInputTransactionDate, optional) — The transaction date of the resident charge
- `description` (string, optional) — Description of the resident charge
- `reference_number` (string, optional) — The reference number for the resident charge
- `charge_code_id` (string, optional) — The Propexo ID for the charge code associated with this new charge
- `post_month` (V1ResidentChargesPostInputPostMonth, optional) — The post month for the resident charge. We will strip all data out of the datetime except the year and month.
- `third_party_charge_id` (string, optional) — A unique value provided to Entrata to uniquely identify the transaction from your system. This can be an alphanumeric string. This does not become the ID of the transaction in Entrata. If not provided, Propexo will generate one
- `is_approval_required` (boolean, optional) — Whether or not the resident charge requires approval. This will require the charge be approved first before being posted to the ledger
- `property_id` (string, optional) — The Propexo unique identifier for the property
- `resident_id` (string, optional) — The Propexo unique identifier for the resident
- `transaction_batch_id` (string, optional) — A unique value provided by Realpage to associate a charge with a batch. This can be an alphanumeric string.
- `notes` (string, optional) — Notes associated with the resident charge
- `batch_id` (string, optional) — An identifier for the transaction batch. This should be unique to your system.
- `unit_id` (string, optional) — The Propexo unique identifier for the unit

## Response

### 200

Successful response

- `job_id` (string, required) — The ID of the job created to handle this operation
- `data` (V1ResidentChargesPostOutputData, required)

## Errors

### 400 Bad Request Error

Bad Request

- `error` (ErrorResponseError, required)

## Types

### V1ResidentChargesPostInputTransactionDate

The transaction date of the resident charge

### V1ResidentChargesPostInputPostMonth

The post month for the resident charge. We will strip all data out of the datetime except the year and month.

### V1ResidentChargesPostOutputData

### ErrorResponseError

- `code` (string, required)
- `message` (string, required)
- `details` (map from string to any, optional)

## Examples

**Request**

```json
{
  "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e"
}
```

**Response**

```json
{
  "job_id": "job_123e4567-e89b-12d3-a456-426614174000",
  "data": {}
}
```

**SDK Code**

```python
import requests

url = "https://api.propexo.com/v1/resident-charges/"

payload = { "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e" }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://api.propexo.com/v1/resident-charges/';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"integration_id":"intg_9f8b7c6d5e4a3b2c1d0e"}'
};

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

```go
package main

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

func main() {

	url := "https://api.propexo.com/v1/resident-charges/"

	payload := strings.NewReader("{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\"\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	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))

}
```

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

url = URI("https://api.propexo.com/v1/resident-charges/")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\"\n}"

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

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

HttpResponse<String> response = Unirest.post("https://api.propexo.com/v1/resident-charges/")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\"\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api.propexo.com/v1/resident-charges/', [
  'body' => '{
  "integration_id": "intg_9f8b7c6d5e4a3b2c1d0e"
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://api.propexo.com/v1/resident-charges/");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"integration_id\": \"intg_9f8b7c6d5e4a3b2c1d0e\"\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["integration_id": "intg_9f8b7c6d5e4a3b2c1d0e"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api.propexo.com/v1/resident-charges/")! 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()
```