---
title: "Documentation"
canonical: "https://fragment.dev/docs"
---

# Documentation

Source: https://fragment.dev/docs

[Documentation index](https://fragment.dev/llms.txt)

<a id="docs"></a>

Fragment is the financial system for agents. Programmable money that bills, pays, and accounts for itself.

Use your agent to try for free today.

```text
Read https://fragment.dev/skills/quickstart.md and follow it to build and run a working Fragment example.
```

Or follow the [Quickstart](https://fragment.dev/guides/quickstart.md).

<a id="featured"></a>

## Featured

- [Payments](https://fragment.dev/guides/make-payments.md)
- [Accounting 101](https://fragment.dev/guides/accounting-101.md)
- [Design your Ledger](https://fragment.dev/guides/design-a-ledger.md)

<a id="guides"></a>

## Guides

- [Quickstart](https://fragment.dev/guides/quickstart.md)
- [Post Ledger Entries](https://fragment.dev/guides/post-ledger-entries.md)
- [Reconcile Transactions](https://fragment.dev/guides/reconcile-payments.md)
- [Generate Reports](https://fragment.dev/guides/generate-reports.md)

<a id="reference"></a>

## Reference

See the [API reference](https://fragment.dev/api-reference.md).

<a id="reference-createpayment"></a>

### createPayment

```typescript
const { createPayment } = await fragment.createPayment({
  ik: 'payment-1',
  ledgerIk: 'ledger-1',
  type: 'card_payin',
  typeVersion: 1,
  parameters: {
    amount: '4999',
  },
});

if (createPayment.__typename === 'CreatePaymentResult') {
  console.log(createPayment.payment.id);
}
```

```python
response = await fragment.create_payment(
    ik="payment-1",
    ledger_ik="ledger-1",
    type_="card_payin",
    type_version=1,
    parameters={"amount": "4999"},
)

result = response.create_payment
if result.typename__ == "CreatePaymentResult":
    print(result.payment.id)
```

```go
raw, _ := json.Marshal(map[string]string{
	"amount": "4999",
})
parameters := json.RawMessage(raw)

response, err := queries.CreatePayment(
	ctx,
	fragment,
	"payment-1",
	"ledger-1",
	"card_payin",
	1, // typeVersion
	&parameters,
)
if err != nil {
	return err
}

if r, ok := response.GetCreatePayment().(*queries.CreatePaymentCreatePaymentCreatePaymentResult); ok {
	fmt.Println(r.Payment.Id)
}
```

```ruby
response = fragment.create_payment({
  ik: 'payment-1',
  ledgerIk: 'ledger-1',
  type: 'card_payin',
  typeVersion: 1,
  parameters: {
    amount: '4999',
  },
})

result = response.data.create_payment
puts result.payment.id if result.__typename == 'CreatePaymentResult'
```

<a id="reference-addledgerentry"></a>

### addLedgerEntry

```typescript
const { addLedgerEntry } = await fragment.addLedgerEntry({
  ik: 'entry-1',
  ledgerIk: 'ledger-1',
  type: 'user_funds_account',
  parameters: {
    user_id: 'user-1',
    funding_amount: '10000',
  },
});

if (addLedgerEntry.__typename === 'AddLedgerEntryResult') {
  console.log(addLedgerEntry.entry.id);
}
```

```python
response = await fragment.add_ledger_entry(
    ik="entry-1",
    ledger_ik="ledger-1",
    type_="user_funds_account",
    parameters={
        "user_id": "user-1",
        "funding_amount": "10000",
    },
)

result = response.add_ledger_entry
if result.typename__ == "AddLedgerEntryResult":
    print(result.entry.id)
```

```go
parameters, _ := json.Marshal(map[string]string{
	"user_id":        "user-1",
	"funding_amount": "10000",
})

response, err := queries.AddLedgerEntry(
	ctx,
	fragment,
	"entry-1",
	"ledger-1",
	"user_funds_account",
	nil, // typeVersion
	nil, // posted
	parameters,
	nil, // tags
	nil, // groups
)
if err != nil {
	return err
}

if r, ok := response.GetAddLedgerEntry().(*queries.AddLedgerEntryAddLedgerEntryAddLedgerEntryResult); ok {
	fmt.Println(r.Entry.Id)
}
```

```ruby
response = fragment.add_ledger_entry({
  ik: 'entry-1',
  ledgerIk: 'ledger-1',
  type: 'user_funds_account',
  parameters: {
    user_id: 'user-1',
    funding_amount: '10000',
  },
})

result = response.data.add_ledger_entry
puts result.entry.id if result.__typename == 'AddLedgerEntryResult'
```

<a id="reference-reverseledgerentry"></a>

### reverseLedgerEntry

```typescript
const { reverseLedgerEntry } = await fragment.reverseLedgerEntry({
  id: 'ledger-entry-id',
});

if (reverseLedgerEntry.__typename === 'ReverseLedgerEntryResult') {
  console.log(reverseLedgerEntry.reversingLedgerEntry.id);
}
```

```python
response = await fragment.reverse_ledger_entry(id="ledger-entry-id")

result = response.reverse_ledger_entry
if result.typename__ == "ReverseLedgerEntryResult":
    print(result.reversing_ledger_entry.id)
```

```go
response, err := queries.ReverseLedgerEntry(ctx, fragment, "ledger-entry-id")
if err != nil {
	return err
}

if r, ok := response.GetReverseLedgerEntry().(*queries.ReverseLedgerEntryReverseLedgerEntryReverseLedgerEntryResult); ok {
	fmt.Println(r.ReversingLedgerEntry.Id)
}
```

```ruby
response = fragment.reverse_ledger_entry({ id: 'ledger-entry-id' })

result = response.data.reverse_ledger_entry
puts result.reversing_ledger_entry.id if result.__typename == 'ReverseLedgerEntryResult'
```

<a id="reference-getledgeraccountbalance"></a>

### getLedgerAccountBalance

```typescript
const { ledgerAccount } = await fragment.getLedgerAccountBalance({
  ledgerIk: 'ledger-1',
  path: 'liabilities/users:user-1/available',
});

console.log(ledgerAccount?.balance);
```

```python
response = await fragment.get_ledger_account_balance(
    ledger_ik="ledger-1",
    path="liabilities/users:user-1/available",
)

print(response.ledger_account.balance)
```

```go
response, err := queries.GetLedgerAccountBalance(
	ctx,
	fragment,
	"liabilities/users:user-1/available",
	"ledger-1",
	nil, // balanceCurrency
	nil, // balanceAt
	nil, // balanceConsistencyMode
)
if err != nil {
	return err
}

fmt.Println(response.LedgerAccount.Balance)
```

```ruby
response = fragment.get_ledger_account_balance({
  ledgerIk: 'ledger-1',
  path: 'liabilities/users:user-1/available',
})

puts response.data.ledger_account.balance
```

<a id="changelog"></a>

## Changelog

See the [latest changelog](https://fragment.dev/changelog/2026.md).

[Status](https://status.fragment.dev/)