Members, receipts, and support

After payment, developers should treat Hilt as the operating source of truth.

The post-payment trail

The important objects are:
  • payments for transaction status
  • memberships for active access state
  • receipts for proof and verification
  • support for exception handling
The main rule is simple:
  • use the payment_id to find the right story
  • use memberships to understand access
  • use receipts to understand proof
  • use support to keep the human trail attached to the same case

Membership routes

Use these for merchant operations:

Membership actions at a glance

Delivery rescue behaviour

Hilt now treats failed access handoff as queued operational work, not just a static failed field. That means:
  • the first failed delivery is still recorded immediately on the membership and payment
  • Hilt can retry failed access on a real schedule in the background
  • your support workflow can still use POST /retry-delivery for an immediate manual push
  • if automated rescue is exhausted, the case moves into manual review instead of disappearing
The important API detail is simple:
  • delivery_status tells you the latest membership-side delivery state
  • delivery.failed webhooks tell you the access handoff did not complete cleanly
  • POST /retry-delivery remains the manual control when your own workflow needs an immediate retry
  • GET /delivery-diagnostics gives you the provider-side truth for Telegram or Discord before you guess
  • POST /delivery-support-ticket opens or reuses the linked support case when rescue needs a human trail

Inspect provider diagnostics

Use it when the merchant needs to answer operational questions such as:
  • is Telegram or Discord automation configured correctly
  • does the saved member identity still look usable
  • does the member currently appear active at the provider
  • is Hilt falling back to a static invite or delivery URL
The response includes:
  • overall_status
  • summary
  • provider_state
  • checks
  • actions
That makes it useful for support desks, retry tooling, and your own access automation.

Open the linked delivery support case

Use it when an access issue needs a durable human trail instead of one more retry button press. If a live delivery ticket already exists for that membership, Hilt reuses it instead of opening duplicates.

Membership list filters

GET /v1/memberships supports the filters the merchant dashboard relies on:
  • product_id
  • status
  • platform
  • q
  • limit
  • offset
That makes it useful for both backend automation and support views.

Renewal intelligence

For recurring flows, Hilt exposes an operations view from membership and subscription data.
Use it when you need:
  • expiring-soon cohorts
  • paid-through timing
  • cancellation and collection state
  • product-level recurring-access reporting
  • recent grace, expiry, and renewal events
The response includes:
  • summary
  • expiring_memberships
  • product_reports
  • recent_events
That makes it a good fit for merchant dashboards, support tooling, and recurring-access reporting jobs.

Look up a membership

Representative response:
You can also search by:
  • wallet
  • identity
  • tx_signature

Read a full membership record

Use the full membership record when you need:
  • access status
  • most recent payment link
  • current period end date
  • delivery result
  • merchant notes

Add merchant notes

Update the member profile label

Gift extra access

Typical uses:
  • launch-week goodwill
  • manual migration support
  • replacing time lost because of an access handoff problem

Receipt routes

Use these for proof retrieval and verification:

Receipt route guidance

Read receipts for a workspace

Representative response:
GET /v1/receipts also supports filters that match the merchant receipt workspace:
  • wallet
  • product_id
  • q

Read a full receipt

Use the full receipt when you need:
  • transaction details
  • stored proof payload
  • cryptographic metadata
  • public verification URL

Verify a receipt publicly

This public proof link is useful for buyers, support, and external verification. It is especially useful when:
  • a buyer wants a proof link without logging in
  • support needs to send a verification link externally
  • your own tools want a shareable receipt URL instead of the full merchant payload

Retrieve the public receipt proof view

Use this when your own tooling wants:
  • the same proof-ready payload Hilt shows publicly
  • verification state bundled with the receipt
  • invoice metadata without separately reconstructing the proof page

Generate a proof PDF

This is the cleanest option when a merchant or buyer needs a document rather than just a link.

Save invoice metadata

Use invoice metadata when you want the receipt proof to carry:
  • merchant invoice number
  • buyer billing name or email
  • billing reference from your system
  • notes support should keep with the proof
This is useful when support or merchant ops needs to send proof without copying links into a separate email workflow.

Support routes

Use these when a merchant needs a clean support trail:

Support route guidance

Create a support ticket

Representative response:

Read or continue the thread

Use this when the payment outcome is real but a human follow-up is still needed. Structured context is worth passing whenever you already know the linked Hilt ids. That makes it easier for merchant and support tooling to expose support-linked actions such as:
  • retry delivery
  • inspect recurring access state
  • open the receipt proof
  • send the proof link directly from the ticket

A reliable post-payment sequence

For most technical teams, the most reliable follow-up loop is:
  1. read GET /v1/payments/{payment_id}
  2. once confirmed, look up the membership
  3. read the receipt if you need proof or invoice context
  4. let Hilt’s rescue queue retry failed access in the background, or call POST /retry-delivery when you need an immediate push
  5. inspect subscription state if the recurring buyer needs the next approval path
  6. open or continue a support ticket if the case needs human context
That sequence is much safer than building post-payment logic from wallet activity alone. Persist:
  • the payment_id
  • the originating product context
  • the buyer identity if your app already knows it
Then rely on Hilt for:
  • final payment status
  • membership state
  • receipt proof
  • support follow-up
That is much safer than rebuilding the entire operating layer yourself.

Common questions

What should happen after a Hilt payment confirms?

Read the payment state, inspect membership when access is involved, read the receipt when proof is needed, and let Hilt’s delivery and support trail carry recovery work.

Why should Hilt remain the post-payment source of truth?

Hilt ties payment, access, receipt, support, delivery recovery, and renewal context to the same trail. Rebuilding that state from wallet activity alone is fragile.

Which post-payment objects should my app store?

Store the Hilt ids you need to correlate later: payment_id, product_id, membership_id, receipt_id, and ticket_id when support is involved.