Source: https://cryptanio.com/de/docs/reference/list-invoices/
Contract / release / updated: v1 / 1.0.0 62 / 2026-10-10

[API-Referenz](https://cryptanio.com/de/docs.html#reference)

# Rechnungen auflisten

GET `/v1/invoices`

Vertrag v1 / 1.0.0 62 / 2026-10-10

[Markdown](https://cryptanio.com/de/docs/reference/list-invoices/index.md) [OpenAPI](https://cryptanio.com/openapi.json)

Nur Rechnungen, keine Spenden. Neueste ID zuerst. Antwort enthält data ohne next_before; letzte ID als before zum Fortsetzen senden. Bei leerer Seite stoppen.

Schlüsselberechtigungen: `invoices` / read / `payments`.

## Parameter

| Parameter | Eingehend | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `project` | query | Nein | Projekt-ID. Zum Auflisten oder Erstellen von Überwachungen erforderlich, außer bei Projektbeschränkung des Schlüssels. Sonst nutzt Weglassen den Konto-/Projektkontext der Aktion; ausdrücklich setzen.; `string` |
| `chain` | query | Nein | Filter für Netzwerkcode.; `string` |
| `status` | query | Nein | Rechnungsstatus.; `string` `pending`, `seen`, `paid`, `underpaid`, `partial`, `overpaid`, `expired`, `late`, `canceled` |
| `limit` | query | Nein | Seitengröße: höchstens 200. Ungültige Werte nutzen Standard; Werte über 200 werden begrenzt.; `integer` Standard: `50`; minimum: `1`; maximum: `200` |
| `before` | query | Nein | Cursor aus next_before oder ID des letzten Eintrags der vorherigen Seite; neueste zuerst.; `string` minLength: `1` |

## Anfragebeispiele

Beispiele führen eine echte Aktion in Ihrem Konto aus. Die im Code genannten Umgebungsvariablen setzen. Schlüssel geheim halten; Schreibanfragen werden nicht automatisch wiederholt.



### Shell / cURL

```bash
#!/usr/bin/env bash
set -euo pipefail
: "${CRYPTANIO_PROJECT_ID:?Set CRYPTANIO_PROJECT_ID}"
: "${CRYPTANIO_API_KEY:?Set CRYPTANIO_API_KEY}"
response_file="$(mktemp)"
trap 'rm -f "$response_file"' EXIT
transfer_status=0
http_status="$(curl \
  --silent --show-error --max-time 30 --request GET \
  --header "Authorization: Bearer $CRYPTANIO_API_KEY" \
  --header 'Accept: application/json' \
  --get \
  --data-urlencode "project=$CRYPTANIO_PROJECT_ID" \
  --data-urlencode 'limit=50' \
  "https://api.cryptanio.com/v1/invoices" \
  --output "$response_file" --write-out '%{http_code}')" || transfer_status=$?
if [[ "$http_status" == 2?? ]]; then
  cat "$response_file"
  exit "$transfer_status"
fi
printf 'HTTP %s\n' "$http_status" >&2
cat "$response_file" >&2
exit 1
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.sh)



### Go

```go
// Go; standard library only. Run: go run request.go
package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func env(name string) string {
    value := os.Getenv(name)
    if value == "" { fmt.Fprintln(os.Stderr, "Set", name); os.Exit(1) }
    return value
}
func run() error {
    path := "/v1/invoices"

    endpoint, err := url.Parse("https://api.cryptanio.com" + path)
    if err != nil { return err }
    query := endpoint.Query()
    query.Set("project", env("CRYPTANIO_PROJECT_ID"))
    query.Set("limit", "50")
    endpoint.RawQuery = query.Encode()

    request, err := http.NewRequest("GET", endpoint.String(), nil)
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + env("CRYPTANIO_API_KEY"))
    request.Header.Set("Accept", "application/json")
    client := &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        body, err := io.ReadAll(response.Body)
        if err != nil { return err }
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, body)
    }
    _, err = io.Copy(os.Stdout, response.Body)
    return err
}
func main() {
    if err := run(); err != nil { fmt.Fprintln(os.Stderr, err); os.Exit(1) }
}
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.go)



### Rust

```rust
// Cargo.toml dependencies:
// reqwest = { version = "=0.12.24", features = ["blocking", "json"] }
// serde_json = "=1.0.145"
use std::{error::Error, io, time::Duration};
use reqwest::{blocking::Client, redirect::Policy, Method, Url};

fn env(name: &str) -> Result<String, Box<dyn Error>> {
    let value = std::env::var(name)?;
    if value.is_empty() { return Err(format!("Set {name}").into()); }
    Ok(value)
}
fn run() -> Result<(), Box<dyn Error>> {
    let mut url = Url::parse("https://api.cryptanio.com")?;
    {
        let mut segments = url.path_segments_mut().map_err(|_| "Invalid base URL")?;
        segments.clear();
        segments.push("v1");
        segments.push("invoices");
    }
    url.query_pairs_mut()
        .append_pair("project", &env("CRYPTANIO_PROJECT_ID")?)
        .append_pair("limit", &"50".to_owned());
    let client = Client::builder().timeout(Duration::from_secs(30)).redirect(Policy::none()).build()?;
    let request = client.request(Method::GET, url)
        .header("Authorization", format!("Bearer {}", env("CRYPTANIO_API_KEY")?))
        .header("Accept", "application/json".to_owned());
    let mut response = request.send()?;
    let status = response.status();
    if !status.is_success() { return Err(format!("HTTP {}: {}", status.as_u16(), response.text()?).into()); }
    io::copy(&mut response, &mut io::stdout())?;
    Ok(())
}
fn main() {
    if let Err(error) = run() { eprintln!("{error}"); std::process::exit(1); }
}
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.rs)



### PHP

```php
<?php
// PHP 8 with the cURL extension. Run this on your server.
function env(string $name): string {
    $value = getenv($name);
    if ($value === false || $value === '') throw new RuntimeException('Set ' . $name);
    return $value;
}
try {
    $path = '/v1/invoices';

    $query = [
        'project' => env('CRYPTANIO_PROJECT_ID'),
        'limit' => '50',
    ];
    $url = 'https://api.cryptanio.com' . $path . ($query ? '?' . http_build_query($query, '', '&', PHP_QUERY_RFC3986) : '');
    $headers = [
        'Authorization: ' . 'Bearer ' . env('CRYPTANIO_API_KEY'),
        'Accept: ' . 'application/json',
    ];
    $curl = curl_init($url);
    curl_setopt_array($curl, [
        CURLOPT_CUSTOMREQUEST => 'GET',
        CURLOPT_HTTPHEADER => $headers,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_FOLLOWLOCATION => false,
        CURLOPT_CONNECTTIMEOUT => 10,
        CURLOPT_TIMEOUT => 30,
    ]);
    $response = curl_exec($curl);
    if ($response === false) throw new RuntimeException(curl_error($curl));
    $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);
    if ($status < 200 || $status >= 300) throw new RuntimeException('HTTP ' . $status . ': ' . $response);
    echo $response;
} catch (Throwable $error) {
    fwrite(STDERR, $error->getMessage() . PHP_EOL);
    exit(1);
}
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.php)



### Python

```python
# Python 3; standard library only.
import json
import os
import sys
from urllib.error import HTTPError, URLError
from urllib.parse import quote, urlencode
from urllib.request import HTTPRedirectHandler, Request, build_opener

def env(name):
    result = os.environ.get(name)
    if not result:
        raise ValueError("Set " + name)
    return result

class NoRedirect(HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

try:
    path = "/v1/invoices"

    query = {
        "project": env("CRYPTANIO_PROJECT_ID"),
        "limit": "50",
    }
    url = "https://api.cryptanio.com" + path + ("?" + urlencode(query) if query else "")
    headers = {
        "Authorization": "Bearer " + env("CRYPTANIO_API_KEY"),
        "Accept": "application/json",
    }
    data = None
    request = Request(url, data=data, headers=headers, method="GET")
    with build_opener(NoRedirect()).open(request, timeout=30) as response:
        if not 200 <= response.status < 300:
            raise ValueError("HTTP " + str(response.status))
        sys.stdout.buffer.write(response.read())
except HTTPError as error:
    print("HTTP " + str(error.code) + ": " + error.read().decode("utf-8", errors="replace"), file=sys.stderr)
    sys.exit(1)
except (ValueError, URLError, OSError) as error:
    print(str(error), file=sys.stderr)
    sys.exit(1)
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.py)



### Node.js

```javascript
// Node.js 18+. Run on your server, never in a browser.
const env = name => {
  const result = process.env[name];
  if (!result) throw new Error(`Set ${name}`);
  return result;
};
try {
  let path = "/v1/invoices";

  const url = new URL(path, "https://api.cryptanio.com");
  url.searchParams.set("project", env("CRYPTANIO_PROJECT_ID"));
  url.searchParams.set("limit", "50");
  const headers = {
    "Authorization": "Bearer " + env("CRYPTANIO_API_KEY"),
    "Accept": "application/json",
  };
  const response = await fetch(url, {
    method: "GET", headers, redirect: "manual",
    signal: AbortSignal.timeout(30_000),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
  if (response.body) {
    for await (const chunk of response.body) process.stdout.write(chunk);
  }
} catch (error) {
  console.error(error.message);
  process.exitCode = 1;
}
```



[Beispiel herunterladen](https://cryptanio.com/files/examples/api/list-invoices.mjs)

## Antworten und Fehler

### 200 Erfolgreiche Antwort.

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `data` | `object[]` | Ja |  |

### 401 Kein gültiger aktiver API-Schlüssel (unauthorized).

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |



### 401 application/json

```json
{
  "error": {
    "code": "forbidden",
    "message": "this API key is read-only"
  }
}
```



### 403 Schlüssel verbietet Aktion, Projekt, Dienst oder IP; E-Mail unbestätigt.

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |



### 403 application/json

```json
{
  "error": {
    "code": "forbidden",
    "message": "this API key is read-only"
  }
}
```



### 429 Zu viele Anfragen (rate_limited); nach Retry-After wiederholen.

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |



### 429 application/json

```json
{
  "error": {
    "code": "forbidden",
    "message": "this API key is read-only"
  }
}
```



### 500 Interner Fehler (internal).

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |



### 500 application/json

```json
{
  "error": {
    "code": "forbidden",
    "message": "this API key is read-only"
  }
}
```



### 503 Vorübergehend nicht verfügbar (unavailable); mit Backoff wiederholen.

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |



### 503 application/json

```json
{
  "error": {
    "code": "forbidden",
    "message": "this API key is read-only"
  }
}
```



[Fehler behandeln und sicher wiederholen](https://cryptanio.com/de/docs.html#errors)

## Verschachtelte Objekte

### `InvoiceList`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `data` | `object[]` | Ja |  |

### `Invoice`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `checkout_url` | `string` | Nein | Von Cryptanio bereitgestellte Zahlungsseite. Erstellung und Wiederholung einer Rechnung mit Methodenauswahl geben einen interaktiven Zugangslink zurück, der die Auswahl erlaubt, bis eine Zahlung erkannt wird. Bei fester Methode und bei jedem GET oder Listenabruf wird ein separater Link mit reinem Lesezugriff zurückgegeben. Beide Links nur mit dem vorgesehenen Zahler teilen; keiner gewährt Zugriff auf Konto oder API-Schlüssel. Zahlung über die Rechnungs-API oder einen verifizierten Webhook bestätigen, nicht anhand einer Browserweiterleitung.; `uri` |
| `id` | `string` | Ja | Undurchsichtige Kennung; als Zeichenfolge behalten.; minLength: `1` |
| `status` | `string` | Ja | pending wartet auf Zahlung; seen erkannt; partial teilweise bezahlt; paid beglichen; underpaid/overpaid/late erfordern Entscheidung; expired Frist abgelaufen; canceled storniert.; `pending`, `seen`, `paid`, `underpaid`, `partial`, `overpaid`, `expired`, `late`, `canceled` |
| `project_id` | `string` | Ja | Undurchsichtige Kennung; als Zeichenfolge behalten.; minLength: `1` |
| `reference` | `string` | Nein | Bestellreferenz. |
| `customer` | `object` | Nein |  |
| `product` | `object` | Nein |  |
| `payer` | `object` | Nein |  |
| `metadata` | `object` | Nein | Bis zu 20 Paare, höchstens 8192 JSON-Bytes. Keine Geheimnisse einschließen. |
| `invoice_currency` | `string` | Nein | Währung des Bestellangebots. |
| `invoice_amount` | `string` | Nein | Exakter Dezimalbetrag als Zeichenfolge; keine Gleitkommazahlen verwenden.; pattern: `^[0-9]+(?:\.[0-9]+)?$` |
| `chain` | `string` | Ja | Netzwerkcode. |
| `asset` | `string` | Ja | Zahlungsasset. |
| `address` | `string` | Ja | Zahlungsadresse. |
| `payment_route` | `object` | Nein | Erforderliche Zuordnung auf der Blockchain, wenn eine automatische Quelle einen Tag, ein Memo, einen TON-Kommentar oder eine Solana-Pay-Referenz ausgibt. Speichern Sie diese zusammen mit der Empfangsadresse; die Bestellreferenz des Händlers ist ein separates Feld. |
| `payment_uri` | `string` | Nein | Solana-Pay-Transferanfrage mit Empfänger, genauem Betrag, Mint des unterstützten Tokens und erforderlicher Referenz. Verwenden Sie diese URI im Zahlungs-QR anstelle der reinen Empfangsadresse.; `uri` |
| `amount` | `string \| string` | Ja | Tatsächlicher Betrag, den der Käufer senden muss; kann zur Unterscheidung von Rechnungen vom angefragten Betrag abweichen. Leer, bis eine Methode ausgewählt wurde. |
| `amount_raw` | `string \| string` | Ja | Ganzzahliger Betrag in der kleinsten Einheit als Zeichenfolge. Leer, bis eine Methode ausgewählt wurde. |
| `asked` | `string \| string` | Ja | Ursprünglich angefragter Kryptobetrag. Leer, bis eine Methode ausgewählt wurde. |
| `decimals` | `integer` | Ja | Dezimalstellen des Assets.; minimum: `0` |
| `tolerance` | `string` | Nein | Toleranz in kleinsten Einheiten; anders als request.tolerance.; pattern: `^[0-9]+$` |
| `sandbox` | `boolean` | Ja | Eine Testrechnung belegt keine echte Blockchain-Zahlung. |
| `needs_decision` | `boolean` | Nein | Bei underpaid, overpaid oder late ist eine Entscheidung erforderlich. |
| `paid` | `string` | Nein | Erhaltener Betrag in kleinsten Einheiten.; pattern: `^[0-9]+$` |
| `tx_id` | `string` | Nein | Kennung der Zahlungstransaktion. |
| `paid_at` | `string` | Nein | UTC-Datum und -Uhrzeit nach RFC 3339.; `date-time` |
| `expires_at` | `string` | Ja | UTC-Datum und -Uhrzeit nach RFC 3339.; `date-time` |
| `created_at` | `string` | Ja | UTC-Datum und -Uhrzeit nach RFC 3339.; `date-time` |

### `ID`

Undurchsichtige Kennung. Format nicht garantiert; nicht in eine Zahl umwandeln.

`string` Undurchsichtige Kennung. Format nicht garantiert; nicht in Zahl umwandeln.

### `InvoiceStatus`

pending wartet auf Zahlung; seen erkannt; partial teilweise bezahlt; paid beglichen; underpaid/overpaid/late erfordern Entscheidung; expired Frist abgelaufen; canceled storniert.

`string` pending wartet auf Zahlung; seen erkannt; partial teilweise bezahlt; paid beglichen; underpaid/overpaid/late erfordern Entscheidung; expired Frist abgelaufen; canceled storniert.

### `Customer`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `id` | `string` | Ja | Kundenkennung in Ihrem System.; maxLength: `120` |

### `Product`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `id` | `string` | Nein | Produktkennung in Ihrem System.; maxLength: `120` |
| `name` | `string` | Nein | Produktname.; maxLength: `200` |
| `quantity` | `integer` | Nein | Menge.; minimum: `1`; maximum: `1000000` |

### `Payer`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `comment` | `string` | Ja | Kommentar des Zahlenden.; maxLength: `500` |

### `InvoiceMetadata`

Bis zu 20 Paare, höchstens 8192 JSON-Bytes. Keine Geheimnisse einschließen.

`object` Bis zu 20 Paare, höchstens 8192 JSON-Bytes. Keine Geheimnisse einschließen.

### `Decimal`

`string`

### `RawAmount`

`string`

### `Error`

| Feld | Typ | Erforderlich | Beschreibung |
| --- | --- | --- | --- |
| `error` | `object` | Ja |  |