Account | Coinkun API

#Create Account

Available

Create an anonymous Coinkun account and receive its Transfer Key once. No authentication is required.

POST/accounts

Request

HTTP MethodPOST
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts

No request parameters.

curl --request POST "https://coinkun.com/api/v1/accounts" \
  --header 'Content-Type: application/json' \
  --data '{}'

{}

{
  "account": "apr-00000000000000000000000000000001",
  "created": "2026-09-05T12:00:00.000000Z",
  "transfer-key": "YOUR_TRANSFER_KEY"
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

Omit the body or send an empty JSON object. No request fields are implemented yet; profile, unknown fields and query parameters are rejected with HTTP 400 before issuance. Nonempty bodies must use application/json and fit within 16384 bytes. With public write limits enabled, creation shares an IP budget with the dashboard. HTTP 429 includes Retry-After seconds; an unavailable admission service returns 503 before issuance. Save the one-time Transfer Key securely; GET cannot recover a lost key. Every valid POST creates a new account; the unsupported Idempotency-Key header is ignored. Do not automatically retry after a timeout or lost response: an account may already exist. On success, save both the account identifier and Transfer Key together before requesting addresses. Each account receives a vault on the selected LTC regtest/mainnet network and attempts public keyset preparation from the configured Signer, without a Core wallet or node connection. Addresses are issued separately. X-Coinkun-Keyset-Status is ready or pending. Pending means the account already exists; unlock that same account in the dashboard and use Prepare Litecoin keys to retry. Mainnet requires a separate database, explicit scan origin and separate private source. Ready describes public keys, not payment monitoring or permission to spend. Mainnet spending is disabled by default; the operator must opt in explicitly. Live mainnet acceptance is pending. Errors use a JSON error object with code and message; 500 is an internal error and 503 an unavailable dependency. A failed response does not prove that issuance was rolled back. All examples are placeholders.

#Account Info

Available

Read public Account metadata without a Transfer Key. Only existing Litecoin currency data is returned; reading never creates keys or contacts a node.

GET/accounts/{account}

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}

Parameter	Type	Description	Required
`account`	string	Account identifier in the URL.	Yes
`currency`	string	The only supported value is ltc (Litecoin); other values are rejected.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "info": [
    {
      "currency": "ltc",
      "created": "2026-09-05T12:00:00.000000Z",
      "units": "satoshi"
    }
  ]
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

#Account Balance

Available

Read this Account's verified Litecoin balance without a Transfer Key. Amounts use integer atomic units, not decimal LTC values.

GET/accounts/{account}/balance

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/balance

Parameter	Type	Description	Required
`account`	string	Account identifier.	Yes
`currency`	string	Only ltc (Litecoin). Optional for the whole Account, required with addresses.	No
`addresses`	string	1 to 100 comma-separated owned receiving addresses. Duplicates count once; currency=ltc is required.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/balance" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "balance": [
    {
      "currency": "ltc",
      "available": 0,
      "total": 0
    }
  ]
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

100000000 atomic units equal 1 LTC. The zero values above illustrate a verified empty account, not a fallback for missing data. Total includes currently unspent pending and immature coinbase; available requires at least one confirmation and coinbase maturity. The whole Account includes own change; an addresses filter counts only its selected receive addresses. Spent parents are never counted twice. This is not spending authorization; reservations and fees are checked again by the Transfer API. Reads do not create keys, Vaults or observations. All responses use no-store. Missing or changed observations, source failures, mismatches, incomplete Backfill, timeouts, processing limits or a missing LTC Vault return HTTP 503 with error.code=balance_unavailable and Retry-After of 5 seconds, not null amounts, partial totals or guessed zero funds. Retrying is safe, but it does not guarantee recovery without operator action. Missing Account returns 404; invalid requests return 400; internal errors 500; unavailable storage returns 503 with the shared unavailable error code. All errors contain only an error object with code and message, not balance amounts. Outputs are read in 250-row batches under a 16 MiB saved-evidence budget, not capped at 250 per account; confirmed-spent history is excluded. An unfiltered read allows 10000 Vault addresses. Other limits are 10000 mempool IDs, 32 MiB node evidence and a 30-second RPC deadline. Without matching watcher coverage, the fallback reads at most 250 mempool bodies / 16 MiB. Restored historical addresses need an explicit Backfill; a balance read does not scan old history. The addresses filter accepts at most 100 entries before deduplication, each 1 to 90 ASCII letters or digits. Empty entries, spaces, arrays, missing currency, other currencies/networks, confirmation overrides, unknown query fields and nonempty JSON body objects are rejected with 400. Unknown, foreign or change addresses produce 404 for the entire selection, not a partial sum. These strict input/error rules are Coinkun's contract, not a claim about undocumented Apirone behavior.

#Generate Address

Available

Issue a new receiving address for the Account in the URL. API and dashboard share the same public keyset, receive counter and saved addresses. No Transfer Key, private source or Core wallet is needed for issuance.

POST/accounts/{account}/addresses

Request

HTTP MethodPOST
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses

Parameter	Type	Description	Required
`account`	string	Account identifier in the URL.	Yes
`currency`	string	Required JSON field; only ltc (Litecoin) is supported.	Yes
`addr-type`	string	Optional JSON field; defaults to p2wpkh. Other values, including null, are rejected.	No
`callback`	object or null	Optional URL/method/data override. Omitted or null inherits the account setting; an empty object disables notifications for this address.	No

curl --request POST "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses" \
  --header 'Content-Type: application/json' \
  --data '{
  "currency": "ltc",
  "addr-type": "p2wpkh"
}'

{
  "currency": "ltc",
  "addr-type": "p2wpkh"
}

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "created": "2026-09-05T12:00:00.000000Z",
  "type": "p2wpkh"
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

Send an application/json object of at most 16384 bytes. Callback URL must be HTTP(S), method GET or POST (default POST), data a JSON object (default empty). Canonical configuration is limited to 4096 bytes. Unknown fields and all query parameters return 400 before allocation. The caller cannot choose a network, another Vault, a keyset, a branch or an index. HTTP 200 returns the five fields shown; callback is included only when explicitly supplied, never exposing inherited private settings. created is the saved address allocation time. Every repeated POST issues a new address; the unsupported Idempotency-Key header is ignored. If an HTTP response fails after commit, the first address remains saved and a retry issues the next one. GET can read saved addresses, but the list does not identify which concurrent request created one. Addresses must not be deleted. Shared IP and Account admission budgets cover both API and dashboard creation when enabled. HTTP 429 returns Retry-After seconds without issuing an address; admission outage returns 503 before allocation. HTTP 404 means an unknown Account. HTTP 409 with keyset_not_ready means this same Account needs a matching active keyset; resume pending preparation through the unlocked dashboard. Never replace existing sources automatically. HTTP 409 with address_range_exhausted needs operator attention. A lock timeout or deadlock returns 503 with Retry-After of 5 seconds; unavailable storage also returns 503. Internal errors return 500 without private details. Errors contain an error object with code and message. These are explicit Coinkun error semantics, not a promise of identical Apirone errors. Confirmed blocks can be observed by a separately enabled local scanner; mempool observations are also available in dashboard History. Account/Address Balance is available separately; callback configuration is saved; local callback workers deliver new receipts and provide a protected attempt log. Never send funds to documentation placeholders or use these regtest addresses on mainnet.

#Address Info

Available

Read the saved metadata and verified balance of one receiving address belonging to this Account. No Transfer Key or key derivation is needed; balance verification requires node evidence.

GET/accounts/{account}/addresses/{address}

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses/{address}

Parameter	Type	Description	Required
`account`	string	Owning account identifier.	Yes
`address`	string	Receiving address within that account.	Yes
`currency`	string	Optional; only ltc (Litecoin) is supported.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses/${ADDRESS}" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "type": "p2wpkh",
  "created": "2026-09-05T12:00:00.000000Z",
  "balance": {
    "available": 100000,
    "total": 150000
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

The five issuance metadata fields are preserved; balance embeds integer atomic available/total from the same calculation as the separate Address Balance endpoint. Total includes unspent pending, immature and reserved outputs; available requires confirmation, maturity and no reservation. This is not spending authorization. Missing, changed or unavailable evidence returns 503 balance_unavailable with Retry-After: 5 and no metadata or amounts, never zero or partial success. Balance verification shares the bounded DB/RPC reads of Address Balance. Callback settings and internal evidence are not exposed. Reading never creates keys, addresses or observations; saved receive addresses remain readable with retired keysets. Change addresses and other accounts/networks are not exposed. Unknown Account, missing address, foreign address and internal database IDs return 404. Unsupported query parameters and nonempty JSON body objects return 400, internal failures 500 and unavailable storage connections 503. All responses use no-store and safe JSON errors contain code and message.

#Address Balance

Available

Read the verified integer balance of one receiving address belonging to the Account, without a Transfer Key.

GET/accounts/{account}/addresses/{address}/balance

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses/{address}/balance

Parameter	Type	Description	Required
`account`	string	Owning account identifier.	Yes
`address`	string	Receiving address.	Yes
`currency`	string	Optional; only ltc (Litecoin) is supported.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses/${ADDRESS}/balance" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "available": 0,
  "total": 0
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

Uses the same calculation as the Account addresses filter. Total includes unspent pending funds; available requires one confirmation and coinbase maturity. This is not spending authorization. Unknown, foreign or change addresses return 404. Retired keysets do not hide saved receiving addresses. Unverifiable evidence or processing limits return 503 with balance_unavailable and Retry-After of 5 seconds, never zero or partial amounts. An empty owned address returns zero only after a successful verification. Outputs are read in 250-row batches under a 16 MiB saved-evidence budget, not capped at 250 per address; confirmed-spent history is excluded. Other limits include 10000 mempool IDs, 32 MiB node evidence and a 30-second RPC deadline. Without matching watcher coverage, the fallback reads at most 250 mempool bodies / 16 MiB. Storage failures return 503 unavailable, internal errors return 500, and invalid or unsupported query fields and nonempty JSON body objects return 400. All responses use no-store. No keys, addresses or observations are created. Restored history needs an explicit Backfill. Address Info and Address List embed the same verified balance. Address List shares one calculation across its entries, not a separate calculation for every row.

#Account Addresses

Available

Read saved Litecoin receiving addresses with a verified balance per entry, newest first, with pagination and optional prefix and empty-balance filters.

GET/accounts/{account}/addresses

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses

Parameter	Type	Description	Required
`account`	string	Account identifier.	Yes
`currency`	string	Required query parameter; only ltc (Litecoin) is supported.	Yes
`limit`	integer	Integer from 1 to 100; default 10. Invalid values are rejected, not clamped.	No
`offset`	integer	Integer from 0 to 10000; default 0. Number of matching records to skip.	No
`q`	string	Case-sensitive address:prefix (1–90 ASCII letters or digits) and/or empty:false. The latter excludes zero total balances, not zero available balances. Combine once each with a comma in either order; empty q means no filter. Wildcards, duplicate filters and other empty values are rejected.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses" \
  --get \
  --data-urlencode "currency=ltc" \
  --data-urlencode "limit=10" \
  --data-urlencode "offset=0"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "addresses": [
    {
      "address": "YOUR_REGTEST_ADDRESS",
      "type": "p2wpkh",
      "created": "2026-09-05T12:00:00.000000Z",
      "balance": {
        "available": 100000,
        "total": 150000
      }
    }
  ],
  "pagination": {
    "total": 1,
    "offset": 0,
    "limit": 10
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

No Transfer Key is required. Only this Account's saved receive addresses are listed; change addresses and other networks are excluded. Empty or unprepared accounts return an empty addresses array without preparing keys. Pagination total counts all filter matches before offset and limit; an offset beyond the end returns an empty page and keeps that total. Ordering is descending saved ID. Pages may shift when new addresses are issued; this is not a cross-request snapshot. These are Coinkun pagination limits, not verified Apirone limits. Each balance contains integer atomic total and available amounts. One RPC-backed calculation verifies the selected page. With empty:false, one full Vault calculation verifies money first, then zero total balances are removed before pagination; pending, immature and reserved funds remain. Full checks share existing balance limits: 10000 addresses including change, 16 MiB saved evidence, 32 MiB node evidence and a 30-second RPC deadline. Ordinary pages only check their selected addresses. Missing scanner, stale observations, RPC failure or exceeded capacity return 503 balance_unavailable and Retry-After: 5, never guessed zero or partial entries. Empty ordinary pages need no balance check. Unknown query fields, invalid parameters and nonempty JSON body objects return 400. Unknown Account returns 404; internal errors 500 and unavailable storage connections 503. All responses use no-store. Errors contain an error object with code and message. Reading never calls Signer, changes observations or consumes an address index.

#Estimation

Available

Read-only Litecoin transfer preview using verified owned funds. It does not reserve, sign or publish.

GET/accounts/{account}/transfer

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/transfer

Parameter	Type	Description	Required
`account`	string	Source account identifier.	Yes
`currency`	string	Asset to estimate.	Yes
`destinations`	string	One address:amount pair; amount is positive integer atomic units. Percentages and multiple destinations follow in step 6.7.	Yes
`addresses`	string	Restrict the source to comma-separated account addresses.	No
`fee`	string	Strategy normal, priority or custom. Custom requires fee-rate in integer atomic units per virtual byte.	No
`fee-rate`	integer	Positive integer atomic units per virtual byte; only with fee=custom.	No
`subtract-fee-from-amount`	boolean	Deduct the network fee proportionally from recipient amounts. Required for a 100% sweep. Net outputs must not become dust.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/transfer" \
  --get \
  --data-urlencode "currency=ltc" \
  --data-urlencode "destinations=YOUR_DESTINATION_ADDRESS:100000"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "destinations": [
    {
      "address": "YOUR_DESTINATION_ADDRESS",
      "amount": 100000
    }
  ],
  "amount": 100000,
  "total": 100141,
  "fee": {
    "subtract-from-amount": false,
    "processing": {
      "amount": 0
    },
    "network": {
      "strategy": "normal",
      "amount": 141,
      "rate": 1,
      "source": "regtest_fallback"
    }
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

#Transfer

Available

Authenticated durable Litecoin payment on the selected network. Only the Account's verified outputs fund its payment, fee and change. Mainnet requires COINKUN_LTC_MAINNET_SPENDING_ENABLED=true; default is disabled. A pause preserves signed holds and permits observation and callbacks through separately enabled workers. Offline mainnet tests are not live acceptance.

POST/accounts/{account}/transfer

Request

HTTP MethodPOST
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/transfer
Authorization
transfer-key in the JSON body. JWT remains planned.
Idempotency-KeyYOUR_UNIQUE_ORDER_KEY

Parameter	Type	Description	Required
`account`	string	Source account identifier.	Yes
`currency`	string	Asset to transfer.	Yes
`transfer-key`	string	Active Transfer Key for this Account. JWT is not supported in this MVP.	Yes
`Idempotency-Key`	header	Coinkun retry contract; 1..128 ASCII letters, digits, underscore, dot, colon or dash. Same key plus changed intent returns 409.	Yes
`fee-limit`	integer	Coinkun safety extension; maximum approved network fee in atomic units. A larger fresh estimate is rejected without signing.	Yes
`destinations`	array	1..100 ordered distinct transparent recipients on the selected network. Integer atomic amounts (integer strings accepted) or percentages of verified available source funds before fees, up to eight decimal places. Fixed amounts are additional; percentage sum is at most 100%. Largest-remainder rounding is deterministic in recipient order.	Yes
`addresses`	array	Optional subset of source receiving addresses.	No
`fee`	string	Network fee strategy.	No
`fee-rate`	integer	Required only for custom, in integer atomic units per virtual byte.	No
`subtract-fee-from-amount`	boolean	Subtract the network fee proportionally, with exact integer largest-remainder rounding. Net outputs must remain non-dust.	No

curl --request POST "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/transfer" \
  --header 'Idempotency-Key: YOUR_UNIQUE_ORDER_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
  "currency": "ltc",
  "transfer-key": "YOUR_TRANSFER_KEY",
  "fee-limit": 1000,
  "destinations": [
    {
      "address": "YOUR_DESTINATION_ADDRESS",
      "amount": 100000
    }
  ],
  "fee": "normal",
  "subtract-fee-from-amount": false
}'

{
  "currency": "ltc",
  "transfer-key": "YOUR_TRANSFER_KEY",
  "fee-limit": 1000,
  "destinations": [
    {
      "address": "YOUR_DESTINATION_ADDRESS",
      "amount": 100000
    }
  ],
  "fee": "normal",
  "subtract-fee-from-amount": false
}

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "created": "2026-09-05T12:00:00.000000Z",
  "type": "payment",
  "id": "YOUR_PAYMENT_ID",
  "status": "broadcast",
  "last_error": null,
  "txs": [
    "YOUR_TRANSACTION_ID"
  ],
  "destinations": [
    {
      "address": "YOUR_DESTINATION_ADDRESS",
      "amount": 100000
    }
  ],
  "amount": 100000,
  "total": 100141,
  "fee": {
    "subtract-from-amount": false,
    "processing": {
      "amount": 0
    },
    "network": {
      "strategy": "normal",
      "amount": 141,
      "rate": 1,
      "source": "regtest_fallback"
    }
  },
  "change-address": "YOUR_CHANGE_ADDRESS"
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

HTTP 200 means published/confirmed, not final settlement; 202 returns the durable ID while work is unfinished. Retry with the same Idempotency-Key and payload, never a new key after a timeout. Before the first reservation, requested intents are not listed in History; retry the same Transfer request to retrieve their status. The saved signed bytes are reused; unknown broadcast does not release funds. A definitive preflight rejection returns the failed payment with 400; validation/auth/conflict failures use the error envelope. Direct Transfer Key is checked again before reservation. No signed bytes or private material are returned. Processing fee is zero. Payment History and dashboard review/send are implemented. Multiple recipients, source filters, percentages and proportional subtract-fee are supported. A percentage resolves once at reservation; the same retry cannot sweep later funds.

#Account History

Available

Read Litecoin receipts and accepted payments for this Account, not a balance. One combined page and total; confirmation is checked against the scanner checkpoint and node.

GET/accounts/{account}/history

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/history

Parameter	Type	Description	Required
`account`	string	Account identifier.	Yes
`currency`	string	The only supported value is ltc (Litecoin).	No
`q`	string	Up to 1024 ASCII bytes. Comma-separated address, date-from, date-to and item-type (receipt or payment); each filter appears at most once.	No
`limit`	integer	Integer from 1 to 100; default 10.	No
`offset`	integer	Integer from 0 to 10000; default 0.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/history" \
  --get \
  --data-urlencode "currency=ltc" \
  --data-urlencode "limit=10" \
  --data-urlencode "offset=0"

{
  "account": "apr-00000000000000000000000000000001",
  "items": [
    {
      "id": "YOUR_TRANSACTION_ID",
      "type": "receipt",
      "currency": "ltc",
      "date": "2026-09-16T12:00:00.000000Z",
      "txs": [
        "YOUR_TRANSACTION_ID"
      ],
      "amount": 150000,
      "is_confirmed": true,
      "observation_status": "recorded"
    }
  ],
  "pagination": {
    "total": 1,
    "offset": 0,
    "limit": 10
  },
  "as_of": {
    "height": 120,
    "block_hash": "YOUR_BLOCK_HASH",
    "checked_at": "2026-09-16T12:00:01.000000Z"
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

Public read, no Transfer Key. item-type selects receipt or payment; omitted means both. History is not a balance. The dashboard shows saved observations; this API additionally verifies the current checkpoint. Payments use pay- IDs and creation time, with negative total including fee in the list (not proof of a settled debit). Unaccepted requested intents are excluded. Payment status/last_error describe execution and can lag the chain; is_confirmed follows blockchain evidence, never the worker's saved status. Replay refuses verification with 503. One transaction is one receipt, summing only this Account's receiving outputs. Change and coinbase are excluded. Spent receipts retain their original integer amount; pending, not_seen and orphaned stay visible and are not cancellations. Address is a case-sensitive substring of an owned receive address, 1..90 letters/digits. It selects whole receipts, not a partial amount; payments match destinations or actual own input addresses. No match returns an empty page. date-from and date-to are inclusive ISO 8601 timestamps; omitted timezone means UTC. Underscore filter aliases are accepted, but duplicate aliases return 400. Dates and ordering use block time, or the last mempool sighting when no block is stored; ties use a stable internal ID. Ordering can move when observations change; pagination is not frozen across separate HTTP requests. The Coinkun extensions observation_status and as_of explain saved state and the checked block checkpoint. is_confirmed is true for a recorded receipt only after the source/checkpoint check, not permission to spend. Missing or lagging scanner, incomplete backfill, changed observations/chain, RPC failure or the 10-second RPC deadline return 503 history_unavailable with Retry-After 5 and no items. No full mempool scan or per-UTXO balance check is performed; this is observed history, not proof that every mempool transaction or restored historical address has been discovered. The read writes nothing and uses no-store. Unknown query fields, unsupported currencies, arrays, malformed filters, nonempty JSON bodies and out-of-range pagination return 400; unknown Account is 404. Address History is a separate endpoint.

#Account History Item

Available

Read one owned Litecoin receipt with receiving outputs, or an accepted payment with destinations and saved fees.

GET/accounts/{account}/history/{HistoryItemID}

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/history/{HistoryItemID}

Parameter	Type	Description	Required
`account`	string	Account identifier.	Yes
`HistoryItemID`	string	Receipt txid (64 lowercase hex characters) or payment ID (pay- followed by 32 lowercase hex characters).	Yes
`currency`	string	The only supported value is ltc (Litecoin).	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/history/${HISTORY_ITEM_ID}" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "created": "2026-09-16T12:00:00.000000Z",
  "type": "receipt",
  "id": "YOUR_TRANSACTION_ID",
  "items": [
    {
      "txid": "YOUR_TRANSACTION_ID",
      "vout": 0,
      "address": "YOUR_REGTEST_ADDRESS",
      "amount": 100000,
      "block": {
        "hash": "YOUR_BLOCK_HASH",
        "height": 101,
        "deleted": false
      },
      "is_confirmed": true
    }
  ],
  "amount": 100000,
  "observation_status": "recorded",
  "as_of": {
    "height": 120,
    "block_hash": "YOUR_CHECKPOINT_HASH",
    "checked_at": "2026-09-16T12:00:01.000000Z"
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

Public read, no Transfer Key. Only this Account's receive outputs are returned, not change or coinbase. Amounts are original integer atomic units, not remaining balances. One item per output; repeated addresses are not merged. vout is the blockchain output index, not a database ID. vout, observation_status and as_of are Coinkun extensions. created is the transaction's first observation time in our database, stable across confirmation and reorg; Account History date instead follows block time or last mempool sighting. This timestamp is shared if the transaction pays several Accounts. Pending and not_seen use block: null instead of a fictional block height. Orphaned retains its old block with deleted: true and is_confirmed false; absence/orphaning is not cancellation. Only verified recorded receipts are confirmed. The same History snapshot/checkpoint verification applies, with no per-output RPC and a 10-second RPC deadline. A changing/unavailable source, incomplete scanner/backfill, or more than 1000 owned outputs returns 503 history_unavailable with Retry-After 5 and no items or amounts, never a successful partial receipt. Oversized receipts need operator intervention; a retry alone cannot fix that limit. Successful reads write nothing and use no-store. Malformed IDs, unsupported currencies, filters/pagination, unknown query fields and nonempty JSON bodies return 400. Unknown Accounts and unknown/foreign items return 404. A pay- ID returns the Transfer response shape plus is_confirmed, observation_status and as_of. is_confirmed uses chain evidence, not asynchronous execution status. Payment amount is positive destination amount; total includes fee. The list instead shows negative total. No keys, unsigned/signed bytes or internal database IDs are loaded into the public response.

#Account Address History

Available

Saved incoming and outgoing blockchain movements of one exact LTC receiving address.

GET/accounts/{account}/addresses/{address}/history

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses/{address}/history

Parameter	Type	Description	Required
`account`	string	Owning account identifier.	Yes
`address`	string	Exact Account-owned receiving address; foreign, change and unknown addresses return 404.	Yes
`currency`	string	Optional ltc only; uses the selected regtest/mainnet network.	No
`limit`	integer	Canonical integer 1..100; default 10 transactions, not outputs.	No
`offset`	integer	Canonical integer 0..10000; default 0.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses/${ADDRESS}/history" \
  --get \
  --data-urlencode "currency=ltc" \
  --data-urlencode "limit=10" \
  --data-urlencode "offset=0"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "txs": [
    {
      "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
      "created": "2026-09-16T12:00:00.000000Z",
      "amount": -150000,
      "block": null,
      "deleted": false,
      "is_confirmed": false,
      "observation_status": "pending"
    }
  ],
  "pagination": {
    "total": 1,
    "offset": 0,
    "limit": 10
  },
  "as_of": {
    "height": 120,
    "block_hash": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
    "checked_at": "2026-09-16T12:00:01.000000Z"
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

Important

This is not a balance or a Transfer API. Each transaction appears once: its signed atomic amount is credits minus this address's saved outputs consumed by its inputs. Same-address returns are netted; sibling/foreign addresses are excluded. Zero-net transactions and coinbase rewards are included; is_confirmed does not imply maturity or permission to spend. created follows block time or last mempool sighting, ordered newest first with a stable tie-breaker. Pending and not_seen use block: null and deleted false; orphaned keeps its old block and deleted true, not a declaration of cancellation. is_confirmed, observation_status and as_of are Coinkun extensions. We do not invent a mempool block height. Rows, sums and count share one DB snapshot. A second snapshot and the same node/checkpoint verification as Receipt History detect changes; RPC runs outside transactions with a 10-second deadline. Incomplete input evidence, scanner/backfill or changing/unavailable evidence returns 503 history_unavailable with Retry-After 5 and no txs or amounts. A verified existing empty address returns an empty page; a missing address returns 404 before RPC. Reads write nothing, do not discover missing history, do not check live mempool presence and use no-store. Unknown queries, q filters and nonempty JSON bodies return 400.

#Account Callback Info

Available

Read the saved notification configuration for the LTC account. No RPC or delivery occurs.

GET/accounts/{account}/callback

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/callback
Authorization
transfer-key in the JSON body. JWT remains planned.

Parameter	Type	Description	Required
`account`	string	Account identifier.	Yes
`currency`	string	Must be ltc on the selected network.	Yes
`transfer-key`	string	Transfer Key of this account. JWT is not implemented.	Yes

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/callback" \
  --get \
  --data-urlencode "currency=ltc"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "callback": null
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

#Address Callback Info

Available

Read the effective receiving-address callback (own override or account default). Null inherits; an empty object disables notifications. Public metadata never exposes callback secrets.

GET/accounts/{account}/addresses/{address}/callback

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses/{address}/callback
Authorization
transfer-key in the JSON body. JWT remains planned.

Parameter	Type	Description	Required
`account`	string	Owning account identifier.	Yes
`address`	string	Receiving address.	Yes
`transfer-key`	string	Transfer Key of this account. JWT is not implemented.	Yes

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses/${ADDRESS}/callback"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "callback": null
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.

#Address Callback Log

Available

Read real delivery attempts for an owned receiving address. This private journal never calls RPC, sends HTTP or creates an attempt.

GET/accounts/{account}/addresses/{address}/callback-log

Request

HTTP MethodGET
Content Typeapplication/json
URLhttps://coinkun.com/api/v1/accounts/{account}/addresses/{address}/callback-log
Authorization
transfer-key in the JSON body. JWT remains planned.

Parameter	Type	Description	Required
`account`	string	Owning account identifier.	Yes
`address`	string	Receiving address.	Yes
`transfer-key`	string	Transfer Key of this account; JWT is deferred.	Yes
`limit`	integer	Page size 1..100; default 10.	No
`offset`	integer	Number of attempts to skip, 0..10000; default 0.	No

curl --request GET "https://coinkun.com/api/v1/accounts/${ACCOUNT_ID}/addresses/${ADDRESS}/callback-log" \
  --get \
  --data-urlencode "limit=10" \
  --data-urlencode "offset=0"

{
  "account": "apr-00000000000000000000000000000001",
  "currency": "ltc",
  "address": "YOUR_REGTEST_ADDRESS",
  "log": [],
  "pagination": {
    "total": 0,
    "offset": 0,
    "limit": 10
  }
}

Illustrative example · Replace YOUR_* and ${VARIABLES} with your own values · Never paste real keys into shared documentation.