# Heth.me documentation > User guides, business/API reference and remote MCP connection instructions. MCP access is limited to the connected account and its current permissions. Connection consent does not authorize automatic spending. Money values use exact integer strings in minor units. Check currency, network and environment. HTTP success is not proof of settlement. This index describes documentation, not account permissions. Use the authenticated API for current operation state. - [API schema (documented subset)](https://docs.heth.me/openapi.json) ## en: Connect an AI assistant Source: https://docs.heth.me/markdown/en/ai/mcp.md --- title: "Connect an AI assistant" last_update: date: 2026-10-21 --- # Connect an AI assistant Heth MCP gives an assistant limited access to your own account, including available business functions. It cannot grant platform administration access. Opening a connection screen grants no permission. ## Connect an assistant 1. In the Heth app where your wallet is already open, go to **Settings → AI connections** and choose **Create connection code**. The one-time code belongs to that account and expires after five minutes. 2. In your AI client’s connection settings, add `https://mcp.heth.me/mcp` and choose OAuth. Start connecting. 3. In the connection window, enter only the code from Heth. You do not sign in to your wallet in this browser. The code sends a request to the exact account that created it; it grants no access. 4. Open the push in the Heth app. If it does not arrive, open **Settings → AI connections → Connection requests**. Compare the **request verification code** with the one in the connection window, and check the account, client identifier and service address. The application name alone does not verify identity. 5. In Heth, uncheck permissions you do not want to share and choose **Approve selected AI access**, or choose **Deny AI access**. Opening the push alone does not approve anything. 6. Return to the AI client. Its connection window finishes automatically after your decision in Heth. Your wallet session and signing keys stay in Heth. A used or expired connection code cannot be reused. Create a new code in Heth; creating one replaces the previous unused code. If the whole connection request expires, restart from the AI client. ### In ChatGPT Open **Plugins → Add → Add custom MCP server**, enter a name such as Heth.me and the server address above, and keep **OAuth** selected. ChatGPT discovers the connection settings automatically; no wallet API key, client secret or recovery phrase is needed. Create the personal plugin, choose **Connect Heth.me**, then follow the code-and-push steps above. You can select default permissions under **Advanced OAuth settings**; the final account permission choice is confirmed in the Heth app. After connection, select Heth.me in the chat and try “Show my wallet balances using Heth”. The available tools depend on the permissions you approved. ## Permissions and tools Only permissions requested by the client and currently available to your account can be approved. A tool is visible only with its required permission. Tools cover account data, transfers, ordinary business changes, subscription requests and OBS. | Permission | Tools and purpose | | --- | --- | | `heth:wallets:read` | `get_wallet_balances`: own wallet balances | | `heth:transactions:read` | `list_transactions`, `get_transaction`: own history and original transaction status | | `heth:business:read` | `list_products`, `list_business_payment_links`, `list_business_subscriptions`: own products, managed links and merchant subscriptions; `get_business_subscription`, `list_business_subscription_requests` read an agreement or outgoing requests | | `heth:payments:prepare` | `prepare_transfer`, `get_transfer_request`: prepare a transfer for approval in Heth and read the original result | | `heth:business:manage` | `create_business_product`, `update_business_product`, `delete_business_product`; `create_business_payment_link`, `update_business_payment_link`, `delete_business_payment_link`: ordinary changes confirmed in the AI client | | `heth:business:manage` | `request_business_subscription`: request a customer's approval in Heth; `prepare_business_subscription_change`: review pause, resume or cancellation in Heth | | `heth:obs:read` | `get_obs_widget`, `list_obs_events`: settings and incoming events | | `heth:obs:configure` | `prepare_obs_connection`, `update_obs_widget`: Heth review link, or appearance fields only with confirmation in the AI client | `prepare_obs_connection` creates no access and returns no OBS token. Currency/network, receiving accounts, keys and access permissions cannot be changed by an appearance tool. See the [OBS setup and customization guide](../user/obs.md), including the open source project and instructions for coding assistants. ## How long access lasts Your connection permission lasts **until you revoke it**. Technical credentials expire separately: MCP access tokens last 15 minutes; refresh tokens rotate and expire after 30 days without renewal. An expired technical credential may require you to connect again even if the consent record remains active. Each request checks the current connection and account permissions. Heth uses a separate restricted API credential valid for at most 60 seconds to serve MCP requests; the full wallet session is not shared with MCP. Revoking consent or withdrawing account permissions blocks subsequent requests, including requests with unexpired tokens. Data already returned to the client cannot be recalled. ## Revoke or reconnect In Heth, open **Settings → AI connections**, check the client identifier, service address, permissions and status. Choose **Revoke AI access** and confirm in Heth. Revocation does not cancel completed payments or subscription debit mandates; manage those separately in [subscription settings](../user/features.md). If asked to reconnect, start a fresh authorization in your AI client. Revocation, expired credentials, withdrawn permissions or detected reuse of a refresh token can end access. Do not paste recovery phrases, wallet keys or browser-session credentials into an assistant to repair the connection. An unavailable service is an error, not an empty account or a successful approval. ## Payments and other changes Heth requires **separate confirmation in Heth for every monetary operation**. A connection permission does not authorize automatic spending. Ordinary product and payment-link edits require confirmation in the AI client. Changes to access rights, payout recipients or future-debit authorization require Heth confirmation. OBS appearance follows the client-confirmation policy. A tool annotation alone does not prove that a client obtained approval. You can also use the [Heth application](https://app.heth.me) or the supported [API integration](../business/quick-start.md). ## Transfer with an assistant 1. Tell the assistant the transfer type, recipient, currency, network and amount. Internal-to-internal (`hot_hot`), internal-to-blockchain (`hot_cold`), blockchain-to-your-internal-account (`cold_hot`) and blockchain-to-blockchain (`cold_cold`) are distinct operations. Use `self` as the recipient for `cold_hot`; it credits your own Heth account. 2. `prepare_transfer` saves the terms and returns a Heth review link. It creates no payment. Amounts and `max_debit` use exact integer strings in the token's minor units. `max_debit` caps the token debit including platform fees. For a blockchain source, `max_network_fee` caps the transaction's network gas charge in wei (ETH/Base) or sun (TRON). Base may additionally charge an L1 data fee. 3. Open Heth and check the account, requesting client, recipient, source, amount, network and fee limits. Choose **Confirm and send in Heth** only when all terms are correct. Opening the link does not approve or send anything. Requests expire after 15 minutes. 4. Heth signs the displayed instruction and uses its normal transfer flow. Blockchain transactions are signed on your device or a connected signing device. Open Heth where the source account can be signed; private keys never go to the assistant. 5. The assistant reads `get_transfer_request` to check the original transaction. Approved or processing is not the same as paid. After a timeout, read the original result; reuse the same `request_id` and identical terms if a preparation must be retried. Do not create a second transfer to resolve an uncertain outcome. Revocation blocks a new transfer from starting. A transaction already accepted for execution can still complete; revoking an AI connection does not cancel an accepted blockchain transfer. ## Products, links and subscriptions The assistant shows ordinary product or managed-link changes for confirmation in the AI client. Price and link amounts are integer strings in minor units; product quantities are positive whole numbers. A stable `request_id` makes retries idempotent. These operations cannot edit payment routing, payout recipients, keys or access rights. Deleting a link or product does not reverse an earlier payment. `request_business_subscription` creates a request for the payer to review in Heth. It grants no future-debit permission and creates no charge by itself. The payer reviews the amount, frequency and first charge before signing in Heth. Use `list_business_subscription_requests` to check requests, and `get_business_subscription` or `list_business_subscriptions` for existing agreements. To pause, resume or cancel an agreement, `prepare_business_subscription_change` returns a Heth review screen. Nothing changes until the owner confirms there. Resuming permits scheduled charges under the existing payment permission. Cancellation stops future charges and does not refund completed payments. Changing the agreed billing terms requires a new payer approval. ## en: Authentication and API keys Source: https://docs.heth.me/markdown/en/business/authentication.md --- title: "Authentication and API keys" last_update: date: 2026-10-20 --- # Authentication and API keys ## Issue and revoke a key 1. Sign in to [Heth](https://app.heth.me) and open **Business**. 2. Open the integration screen using **Connect**. 3. In **API integration**, use **+** to issue a key. 4. Store the key as a secret in your server-side integration. 5. To revoke a key, remove its entry on that screen. Update the integration when replacing a key. Never use a key printed in a screenshot or documentation example. The documentation uses placeholders rather than usable credentials. ## Request headers | Header | Use | | --- | --- | | `x-api-key` | Required for API-key authentication | | `Content-Type: application/json` | Required when submitting JSON | For `https://app.heth.me`, the Heth gateway supplies the organization context. This rule applies to that host: do not assume it holds for a different platform API URL. An API key is bound to its own account and permissions. ## Keys and user sessions are different Transaction integration accepts an API key. Interactive wallet functions can require the signed-in user's Bearer session instead; a key does not automatically grant access to wallets, profile, usernames or every business feature. Customer subscription sessions are a separate type of authorization. Never substitute one token type for another or copy a seed into an integration configuration. See [capabilities](capabilities.md) and [errors](errors.md). An integration must request only the access needed for its task. ## en: Business capabilities and availability Source: https://docs.heth.me/markdown/en/business/capabilities.md --- title: "Business capabilities and availability" last_update: date: 2026-10-20 --- # Business capabilities and availability Use the capabilities enabled for the signed-in account. An API endpoint existing in the platform does not mean it is enabled for your account, network or payment route. | Capability | Integration boundary | | --- | --- | | Payments and payouts | Transaction API, configured route, permitted instrument and environment | | Heth receiving links | A receiving URL generated in the app; sharing does not create a charge | | Managed payment links and products | Separate business resources; require enabled account access | | Merchant subscriptions | Agreements billed to your customers; require supported payment methods and customer authorization | | A payer's own subscription permissions | Separate customer authorization and explicit approval/revocation | | Refund or cancellation | Only if supported by the original transaction and payment method; a blockchain transfer is not generically reversible | | Wallets, @usernames, gift cards, webhooks | Account functions may require the user's session and additional confirmation | | Donations | Platform/author flow with its own recipient, minimum, fee and expiry | The public token registry returns configuration, not an entitlement to pay with every listed asset. Match the asset to the network and the effective account configuration. For example, USDT/ETH and USDT/TRX cannot be interchanged. ## Documentation boundaries The [transaction reference](../transactions/overview.md) covers request formats for the documented flows. Do not obtain operator credentials or change terminals/routing to resolve a rejected request. Contact support with the transaction identifier when an account route is unavailable. The [AI connection guide](../ai/mcp.md) explains permissions and confirmation for functions available to your account. ## en: Errors, status checks and retries Source: https://docs.heth.me/markdown/en/business/errors.md --- title: "Errors, status checks and retries" last_update: date: 2026-10-20 --- # Errors, status checks and retries Always inspect both the HTTP response and the transaction `status`. A 200 or 201 can contain a rejected or pending transaction. | HTTP result | Integration action | | --- | --- | | 400 / 422 | Check the supplied fields, types, amount scale, environment and recipient. Do not resubmit unchanged validation failures in a loop | | 401 | Check the credential, its validity and the API host | | 403 | The authenticated account or key lacks permission; do not switch accounts or environments automatically | | 404 | Check the identifier and account context. This does not prove another account has no such resource | | 409 | Inspect the conflict and recover the original operation before creating anything else | | 429 | Respect `Retry-After` when present and retry reads with bounded backoff | | Timeout / 5xx | The result may be unknown. Look up the original operation by `id` or `txid` before resubmitting | Error response shapes can differ by endpoint. Prefer a documented machine-readable error code where available; `error_description` is human-readable text and not a stable code. Redact credentials and payment instrument data from logs. ## Transaction outcomes - `charged`: the transaction completed successfully. - `rejected` or `failed`: inspect the reason and the original operation; do not report success. - `refunded` or `reversed`: funds have a different outcome from a newly settled payment. - Pending/action-required/unknown status: show that state and the required user action. Never infer success from an unrecognized status or a timestamp alone. Use [GET transaction](../transactions/get_transaction.md) to verify an operation. Keep the same `txid` for retries of the same business instruction. Webhook delivery failures and a payment processing failure are different events. ## en: Start an API integration Source: https://docs.heth.me/markdown/en/business/quick-start.md --- title: "Start an API integration" last_update: date: 2026-10-20 --- # Start an API integration Use an API key issued for your own Heth account. First read [authentication](authentication.md), [amounts and statuses](../field_conventions.md) and [available business capabilities](capabilities.md). ## Verify access without moving funds Set `HETH_API_KEY` in your integration's secret storage. Do not put it in source control, a browser bundle, a URL or an AI conversation. This request reads account transactions without moving money. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'limit=10' \ --data-urlencode 'order_by=started' ``` An empty `data` array is a valid result. For a 401 or 403, check authentication and account permissions. ## First payment 1. Check which payment routes are enabled for your account and obtain the recipient or payment instrument details. 2. Choose the appropriate [transaction example](../transactions/overview.md). Replace every placeholder with verified details for your own operation. 3. Use a small amount. For six-decimal USDT, `"1000000"` means 1 USDT. 4. Generate and save a unique `txid` for the business operation before sending it. 5. Submit once, save the returned `id`, then [read its status](../transactions/get_transaction.md). 6. If the request times out, look up the original `txid` or retry the identical request with that same identifier. Do not create a replacement identifier. Sending a payment request can move real funds. Review the recipient, amount, currency, network and fees before sending. An API key authorizes only the operations available to its account. ## en: Products, managed links and subscriptions Source: https://docs.heth.me/markdown/en/business/resources.md --- title: "Products, managed links and subscriptions" last_update: date: 2026-10-20 --- # Products, managed links and subscriptions These are account-owned business resources. API-key or partner Bearer access and the corresponding enabled capabilities are required. A key does not turn on a payment route. See [authentication](authentication.md). For reads and deletion, env is a query filter. For product/link creation and updates, send env in the JSON body. Partner ownership comes from the credential; do not send another partner_id. Resource price fields can have endpoint-specific integer types: the transaction API amount remains an exact integer string. ## Products ```http GET /api/v1/products?env=prod&limit=10 GET /api/v1/products/{id}?env=prod POST /api/v1/products PUT /api/v1/products/{id} DELETE /api/v1/products/{id}?env=prod ``` Creating a product defines its header, text, price, qty and currency. A product is not a payment. List responses use data/total; product details and creation responses use data. The shown price is 1 USDT at decimals=6. ```json { "env": "prod", "header": "Example item", "text": "Example item", "price": 1000000, "qty": "1", "currency": "USDT" } ``` ## Managed payment links ```http GET /api/v1/links?env=prod&limit=10 POST /api/v1/links PUT /api/v1/links/{id} DELETE /api/v1/links/{id}?env=prod ``` Links are separate server resources with amount settings, payment configuration and optional products. Use the returned resource URL/form information, not an invented URL. A Heth receive-link generated in the app is a different object. Deleting a link does not refund an already settled payment. ## Merchant subscriptions ```http GET /api/v1/recurrents?env=prod&limit=10 GET /api/v1/recurrents/{id}?env=prod POST /api/v1/recurrents PUT /api/v1/recurrents/{id} POST /api/v1/recurrents/{id}/pause POST /api/v1/recurrents/{id}/resume POST /api/v1/recurrents/{id}/cancel ``` A subscription is created from a successful initial payment belonging to the account. POST /recurrents uses payment_id and a recurrent object; interval accepts daily, weekly, monthly or yearly, with period specifying the number of intervals. Environment is inherited from the initial payment. The payer must authorize the payment method and recurring debit terms. Creating a subscription is not proof that a usable debit permission exists. Lifecycle actions use `POST /recurrents/{id}/pause`, /resume and /cancel. Read the returned status; cancelling future charges does not refund earlier ones. A Heth payer manages their own crypto subscription mandates with their wallet session in Settings → Subscription mandates, where the feature is enabled. This is separate from merchant subscription management. ## en: Webhook integration Source: https://docs.heth.me/markdown/en/business/webhooks.md --- title: "Webhook integration" last_update: date: 2026-10-20 --- # Webhook integration A webhook reports an account event to your receiving URL. It is a notification; verify the authoritative transaction state through [GET transaction](../transactions/get_transaction.md). ## Configure the receiver In Heth webhook settings, set a URL you control, configure the integration secret and enable delivery. Changing the URL changes who receives account events. Protect that endpoint and avoid redirects to untrusted recipients. Configuration requires the user's account session; an API key used for transactions is not automatically sufficient. ## Process notifications safely 1. Validate the account webhook signature and replay checks described below. 2. Record the event/transaction identifier with sensitive fields redacted. 3. Make handling idempotent: duplicate or delayed delivery must not create another payment. 4. Retrieve the transaction with your own credential and reconcile its status. 5. Return the receiver response required by the configured delivery contract. Do not treat a browser push notification as a webhook or a guarantee of delivery. This overview does not promise ordering, retry intervals or an authentication format common to every configured integration. Obtain the actual delivery contract before enabling production automation. ## Account webhook delivery format This format applies to account webhooks configured in Heth settings. Other callback integrations may use a different contract. When a non-empty account webhook secret is configured, the request includes x-webhook-signature (hex HMAC-SHA256), x-webhook-timestamp (Unix seconds) and x-webhook-event-id. Verify the HMAC over timestamp + "." + the exact raw HTTP body bytes using the configured secret; do not parse and reserialize JSON before verification. Check the signed body timestamp matches the timestamp header, reject a clock difference above 5 minutes, compare signatures in constant time, and deduplicate by event_id. A retry retains event_id but receives a fresh timestamp/signature. Without a configured secret the signature headers can be absent; configure a secret before trusting automated delivery. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` The envelope has event_id, timestamp, type and data. For account transaction events, data includes tx_id, txid, type, status, amount, currency and event_type. amount can be a JSON integer: use a lossless parser. A donation may add a donation object. Acknowledge a verified event with HTTP 2xx after recording it; repeated verified event_id values must not trigger the business action twice. Confirm the transaction through GET even after a valid notification. ## en: Field Conventions & Glossary Source: https://docs.heth.me/markdown/en/field_conventions.md --- title: Field Conventions & Glossary last_update: date: 2026-10-20 --- # Field Conventions & Glossary Canonical definitions used across API documentation. ## Request Headers | Header | Required | Definition | | ------ | -------- | ---------- | | x-api-key | Yes | API-key issued in the app ("Business" section). The organization is resolved from the request host | | Content-Type | Yes (POST) | `application/json` for create requests | ## Amount & Currency | Term | Definition | | ---- | ---------- | | amount | String of an integer in minor units (e.g. cents, smallest token fraction) | | amount_with_fee | Amount plus applied fee (minor units) | | currency | ISO-like currency / token code (e.g. USDT) | | currency_dest | Destination currency for conversion (FX). Optional; defaults to `currency` | ## Identifiers | Term | Definition | | ---- | ---------- | | id | Internal system UUID of transaction | | txid | Client-supplied string identifying one business operation; UUID is a convenient choice, not a required format | ## Routing & Environment | Term | Definition | | ---- | ---------- | | route | Processing path alias configured for API key | | env | `prod` (default). Preserve this value when opening and confirming the request. | ## Status Lifecycle | Status | Meaning | | ------ | ------- | | created | Accepted, awaiting processing | | new | Initial state before processing starts | | authorizing | Authorization in progress | | pre_authorized_3ds | Awaiting 3DS authentication | | action_required | Awaiting an additional action (3DS / extra authorization) | | charging | In progress (authorization / funding) | | payment_suspended | Inbound transaction temporarily suspended | | payout_suspended | Outbound transaction temporarily suspended | | charged | Successfully completed (terminal) | | reversed | Charge reversed (terminal) | | refunded | Refunded (terminal) | | rejected | Irrecoverably failed (terminal) | | failed | Failed (terminal) | Terminal states are `charged`, `reversed`, `refunded`, `rejected`, `failed`. The most common happy path is `created → charging → charged`. ## Time Fields | Field | Definition | | ----- | ---------- | | started | ISO timestamp when processing began | | finished | ISO timestamp when processing completed; determine the outcome from status | ## Money Storage Objects | Field | Definition | | ----- | ---------- | | network | Blockchain network (ETH, TRX, etc.) | | type | Instrument type (bank_card, p2p_proxy, etc.) | | wallet_id | Internal wallet identifier (payout/payment target) | | cardnumber | Virtual card PAN (masked in some responses) | | cvv | Virtual card security code (never log in plaintext) | | exp_month / exp_year | Card expiry values (string, zero padded) | | cardholder | Cardholder name (ASCII or UTF-8) | ## Error Fields | Field | Definition | | ----- | ---------- | | error_description | Human-readable failure reason (non-stable text) | ## Idempotency Guidance Use a unique (idempotent) `txid` per business operation and persist it before sending. The value is a string; UUID generation is convenient but UUID syntax is not required. Retry the same instruction with the same identifier in the same account and environment. Do not reuse it for a different recipient or amount. Recover the original operation after a timeout; a retry must not silently become a new payment. ## Polling Strategy Poll reads with bounded backoff, for example 1s → 2s → 4s → 8s, with a 30s interaction budget. Stop at a known final status or when the budget expires. On timeout report a pending/unknown result and keep the original `id`/`txid`. Unknown statuses are not success. See [errors and retries](business/errors.md). ## Webhooks (Informational) Webhooks indicate state change but are not authoritative. Always confirm via GET Transaction. ## Amount scale Amounts are strings of integers in minor units, not floating-point values. Obtain decimals for the currency, network and environment from `GET https://app.heth.me/api/v1/contracts?env=prod`. USDT/ETH and USDT/TRX currently use 6 decimals: 1 USDT = `"1000000"`, 0.25 USDT = `"250000"`. ETH has 18 decimals; this does not apply to every token on Ethereum. An unknown scale must stop amount conversion. See the [API schema](/openapi.json). ## en: Use Heth.me: wallets, transfers and payments Source: https://docs.heth.me/markdown/en/intro.md --- slug: "/" sidebar_position: 1 title: "Wallets, transfers and payment API" sidebar_label: "Get started" description: "Set up a Heth.me wallet, transfer USDT, pay by QR and accept payments. User guides, business integration instructions and API reference." last_update: date: 2026-10-20 --- # Use Heth.me: wallets, transfers and payments Learn how to set up a Heth.me account, receive and transfer funds, pay for purchases and connect payment acceptance. User guides explain the app; the API reference explains integration requests. ## Start using your wallet - [Create or restore an account](user/wallets.md) and understand Crypto Accounts and Wallet balances. - [Receive, transfer or withdraw funds](user/transfers.md), choose a network and signing method. - [Pay or accept a payment by QR](user/payments.md) and share a receiving link. - [Use @usernames, gift cards and donations](user/features.md), and configure notifications. - [Protect account access](user/security.md) and understand offline limits. USDT transfers on Ethereum and TRON use different receiving details. Before confirming, check the asset, network, recipient and amount. ## Connect payments for your business Start with a [read request that moves no money](business/quick-start.md), then choose the integration you need: - [Authentication and API keys](business/authentication.md). - [Payments, payouts and transaction status](transactions/overview.md). - [Products, payment links and subscriptions](business/resources.md). - [Webhooks: signatures and event handling](business/webhooks.md). - [Amount and identifier formats](field_conventions.md), [errors and retries](business/errors.md). Business features depend on [account access](business/capabilities.md). HTTP success does not confirm payment: check the original transaction status. ## Connect AI to Heth.me [Connect your AI assistant through Heth MCP](ai/mcp.md) to use your own account and available business functions. You choose its permissions and confirm every monetary operation in Heth. The guide explains connection, transfers, business changes, OBS and revocation. AI integration developers can use the [documented API subset](/openapi.json), [documentation index](/llms.txt) and [full text guides](/llms-full.txt). These describe interfaces and rules; obtain current balances, permissions and operation results from the API. ## App and support [Open Heth.me](https://app.heth.me) · [Contact support](https://t.me/hethmesupport_bot) ## en: Subscriptions and autopay Source: https://docs.heth.me/markdown/en/subscriptions.md --- title: Subscriptions and autopay --- # Subscriptions and autopay A shop can ask a Heth.me user to approve recurring payments. The payer reviews and signs the conditions with their ordinary unlocked HethWallet. A separate email account or Customer Portal login is not needed. Payments debit the **Heth account balance** in the agreed currency and network. ## For the payer 1. Open **Settings → Subscriptions and autopay**. New requests appear separately from existing subscriptions. 2. Open a request and check the shop, amount per payment, currency/network and billing period. A confirmation link opens the same screen. A locked wallet asks for its usual PIN and returns to the request. 3. Choose **Enable subscription** or **Reject**. Opening a link or receiving a notification never approves a subscription. 4. After approval, the first payment is scheduled. The list shows the amount, period and next payment date; while retrying a failed payment, it shows the next retry time. 5. Revoke the subscription to stop future charges. Revocation does not refund completed payments. Approval records consent and schedules a payment; it does not mean that the payment has succeeded. Check the transaction status. The balance must be sufficient when a payment is executed. ## How new requests are announced For a recognized payer, the server sends a subscription-request push to registered devices, with a link to `/subscriptions/confirm/?env=`. An entry is also saved in the notification bell, even when no device can receive the push. Pending requests remain available in **Settings → Subscriptions and autopay**. Installed PWAs use web push. Heth.me for iOS and Android, starting with version 1.0.0 (build 5), uses system notifications. Enable notifications in the wallet and allow them in your device settings. Tapping a subscription request opens its confirmation screen; a locked wallet first asks for the usual PIN or available passkey. Receiving or opening a notification does not approve the subscription. If a notification does not arrive, open the pending request list or the confirmation link from the shop. ## For the shop In HethWallet, open **Business → Subscriptions and autopay**. Enter the payer's wallet address, `@username` or Heth card number, a subscription name, the amount per payment, currency/network and period. Send the request, then copy its confirmation link. You can list your requests and cancel a request while it is still pending. The operator must enable Heth subscriptions for the organization and configure a working payment route. Creating a request does not authorize a debit. ## Create a request through the API Use the shop's API key or its ordinary partner Bearer session. On `app.heth.me`, the organization is resolved from the host. A read-only key cannot create or cancel requests. ```bash curl -X POST 'https://app.heth.me/api/v1/heth/subscription-requests' \ -H "x-api-key: $HETH_API_KEY" \ -H 'Content-Type: application/json' \ -d '{ "request_id": "b56b2c66-4ae5-4cb9-92ea-7a3297b72b55", "payer": "@alice", "description": "Monthly membership", "amount": "1000000", "currency": "USDT", "network": "ETH", "interval": "monthly", "period": 1, "env": "prod" }' ``` | Field | Description | Type | Example | | --- | --- | --- | --- | | `request_id` | Unique idempotent UUID. Reuse it with identical terms when retrying the same request. | String | `b56b2c66-4ae5-4cb9-92ea-7a3297b72b55` | | `payer` | Wallet address, username or Heth card number. | String | `@alice` | | `description` | Subscription name, 1–250 characters without line breaks. | String | `Monthly membership` | | `amount` | Positive integer in token minor units. For 6-decimal USDT, `1000000` means 1 USDT. | String | `1000000` | | `currency`, `network` | Enabled token/network pair for the chosen environment. Networks: `ETH`, `TRX`, `BASE`. | String | `USDT`, `ETH` | | `interval` | `daily`, `weekly`, `monthly` or `yearly`. | String | `monthly` | | `period` | Number of intervals, 1–365; default 1. | Number | `1` | | `env` | `prod` (default). Preserve this value when opening and confirming the request. | String | `prod` | HTTP `201` returns the request directly, including `id`, `status`, `amount_decimals`, `confirm_url`, `expires_at`, `subscription_id` and `next_charge_at`. Requests expire after seven days. A successful creation does not reveal whether the supplied payer exists; only the actual recipient can read and approve the request. ## API operations All paths below start with `/api/v1`. Shop operations require the shop's API key or partner Bearer session. | Method and path | Purpose | | --- | --- | | `POST /heth/subscription-requests` | Create a request. | | `GET /heth/subscription-requests?env=prod&limit=50` | List the shop's requests in `data` and `total`. | | `POST /heth/subscription-requests/:id/cancel` | Cancel a pending request; body `{"env":"prod"}`. | For the first page, omit `page`. Use `page=1` for the next page, then increment it; `limit` controls the page size. Wallet operations require the payer's ordinary wallet Bearer session. A shop's API key cannot approve for the payer. | Method and path | Purpose | | --- | --- | | `GET /heth/subscriptions?env=prod&limit=50` | Own subscriptions in `data`/`total`, pending requests in `requests`/`requests_total`. | | `GET /heth/subscription-requests/:id?env=prod` | Read the addressed request and canonical signing `message`. | | `POST /heth/subscription-requests/:id/confirm` | Approve with `{"signature":"","env":"prod"}` after reviewing the exact conditions. | | `POST /heth/subscription-requests/:id/reject` | Reject; body `{"env":"prod"}`. | | `POST /heth/subscriptions/:id/revoke-mandate` | Stop future charges; body `{"env":"prod"}`. | The signature binds the shop, payer, organization, environment, description, amount and its scale, currency/network, interval and period, first-payment rule, nonce and expiry. Changing the conditions requires a new request and fresh consent. Retrying approval or a scheduled payment cannot debit the same period twice. API timestamps without a timezone suffix are UTC; the application displays device-local time. ## Statuses and errors Request statuses are `pending`, `signed`, `rejected` and `expired`. An approved request has a `subscription_id`. Track actual payment completion through the transaction API and configured webhooks. `401` means missing/invalid authentication; `403` means subscriptions are disabled or the API key is read-only. An inaccessible request returns `404`. `422` indicates invalid terms, a reused UUID with different conditions, an invalid signature, or an expired/closed request. A shop cannot change the signed conditions of an active subscription without new payer consent. ## en: Aggregated Payment (Merchant Collection by Card Number) Source: https://docs.heth.me/markdown/en/transactions/aggregator_payment.md --- title: Aggregated Payment (Merchant Collection by Card Number) last_update: date: 2026-10-20 --- # Aggregated Payment (Merchant Collection by Card Number) Example: `"1000000"` is 1 USDT when decimals=6. Replace all placeholders with verified recipient and instrument details. Sending this request can move real funds. Review and explicitly authorize the operation before submitting it. See [Quick Start](../business/quick-start.md). This transaction type enables a payment service Aggregator to accept customer payments on behalf of an integrated Merchant. Funds are debited from the Payer and distributed between the Merchant (net of the Aggregator fee) and the Aggregator (fee portion) automatically. ## Business Flow 1. Merchant signs an agreement / onboards with the Aggregator. 2. Aggregator instructs the Merchant to create (or provide) a wallet in the heth.me system and sends back the `wallet_id`. 3. Using its own API key, the Aggregator creates a payment transaction specifying the Merchant wallet details in `money_storage_merchant` and the Payer card details in `money_storage`. 4. Upon successful processing, the balances of the Payer, Merchant, and Aggregator are updated in a single step. 5. The transaction status can be polled using the standard transaction retrieval method (authorized with the same API key). ## Example Request ```bash curl --location --request POST 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage_merchant": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "08", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Payment", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## Field Reference | Field | Description | Type | Example | | ----- | ----------- | :--- | ------- | | amount | Transaction amount (string of an integer in minor units) | String | 1000000 | | currency | Transaction currency (default USDT) | String | USDT | | env | `prod` (default). Preserve this value when opening and confirming the request. | String | prod | | type | Transaction type (payment) | String | payment | | route | Processing route (must match configured mapping) | String | hot_hot_ETH | | money_storage_merchant | Merchant (payee) wallet descriptor | Object | | | > wallet_id | Merchant wallet identifier | String | YOUR_WALLET_ID | | > network | Blockchain network (TRX or ETH) | String | ETH | | > type | Wallet interaction type (e.g. p2p_proxy) | String | p2p_proxy | | > currency | Merchant settlement currency (default USDT) | String | USDT | | money_storage | Payer funding instrument descriptor | Object | | | > network | Blockchain network (TRX or ETH) | String | ETH | | > type | Instrument type (bank_card) | String | bank_card | | > currency | Payer currency (default USDT) | String | USDT | | > cardnumber | Virtual card number | String | YOUR_CARD_NUMBER | | > cvv | Virtual card CVV | String | YOUR_CVV | | > exp_month | Card expiry month | String | 08 | | > exp_year | Card expiry year | String | 2026 | | > cardholder | Cardholder name | String | John Doe | | description | Human-readable description | String | Payment | | txid | Idempotent transaction identifier (string) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## Notes * The Aggregator fee logic is applied automatically based on the API key configuration. * Ensure `route` matches an enabled processing route for the provided API key. * Use idempotent `txid` values to avoid accidental duplicate submissions. * Retrieve transaction status via the standard GET transaction endpoint (polling until a terminal state is reached). ## en: Get Transaction Status Source: https://docs.heth.me/markdown/en/transactions/get_transaction.md --- title: Get Transaction Status last_update: date: 2026-10-20 --- # Get Transaction Status Retrieve the latest state of a specific transaction by its internal `id` using your API key. ## Request ``` GET /api/v1/transactions/{transaction_id}?env=prod Headers: x-api-key: ``` `{transaction_id}` is the transaction's internal `id` (UUID), passed as a path segment. ## Response Fields | Field | Description | | ----- | ----------- | | amount | Amount in minor units | | amount_with_fee | Amount including fee (minor units) | | amount_dest | Destination amount for conversion (minor units), if applicable | | currency | Currency code (e.g. USDT) | | currency_dest | Destination currency for conversion, if applicable | | description | Original description provided | | env | `prod` (default). Preserve this value when opening and confirming the request. | | error_description | Error details if status is rejected | | finished | Finish timestamp (ISO) if terminal | | id | Internal transaction identifier (UUID) | | route | Processing route used | | started | Start timestamp (ISO) | | status | Current status (see Status Lifecycle in Field Conventions; e.g. created, charging, charged, refunded, rejected, failed) | | txid | Client supplied external identifier | | type | Transaction type (payment or payout) | | widget_url | Widget link (if widget flow) | | simple_auth_redirect_url | 3DS / additional auth URL when applicable | ## Example ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## Usage Notes * Poll with exponential backoff (e.g. 1s, 2s, 4s, 8s) until a terminal state. * Determine the outcome from `status`; a missing or present `finished` alone is not proof of the outcome. * `txid` should be idempotent per business operation. ## Recover by external operation identifier ```bash curl --get 'https://app.heth.me/api/v1/transactions/example-order-001' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'by=txid' \ --data-urlencode 'env=prod' ``` ## en: List transactions Source: https://docs.heth.me/markdown/en/transactions/list_transactions.md --- title: "List transactions" last_update: date: 2026-10-20 --- # List transactions Read your account’s transactions. The response is an object with `data` and `cursor`, not a bare array. Use a bounded period and explicit environment. See the [Quick Start](../business/quick-start.md), [authentication](../business/authentication.md) and [error handling](../business/errors.md). ```http GET /api/v1/transactions?env=prod&order_by=started&limit=30 x-api-key: YOUR_API_KEY ``` ## Filters | Filter | Meaning | | --- | --- | | `started_from / updated_from` | Start of time range (ISO 8601) | | `started_to / updated_to` | End of time range (ISO 8601) | | `type` | Filter by type | | `status` | Filter by status | | `txid` | Exact external operation string | | `order_by` | started or updated | | `limit` | Page size: 1–500, default 100 | | `env` | `prod` (default). Preserve this value when opening and confirming the request. | | `cursor` | Timestamp returned as cursor_value | ```json { "data": [ { "id": "c033ceaa-3726-4479-8be3-c9af8a0b2336", "txid": "example-order-001", "type": "payment", "status": "charged", "amount": "1000000", "currency": "USDT", "env": "prod", "started": "2026-10-01T10:00:00Z" } ], "cursor": { "cursor_field": "started", "cursor_value": "2026-10-01T10:00:00Z" } } ``` ## Next page Pass the returned `cursor.cursor_value` as the query string `cursor`, not the whole cursor object. Keep the same environment, filters and order_by. For order_by=updated, cursor_field can be updated_at. Stop when data is empty or no advancing cursor is returned. Reconcile by transaction id when records change during traversal. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'order_by=started' \ --data-urlencode 'limit=30' \ --data-urlencode 'cursor=2026-10-01T10:00:00Z' ``` ## en: Transaction API Source: https://docs.heth.me/markdown/en/transactions/overview.md --- title: "Transaction API" last_update: date: 2026-10-20 --- # Transaction API Choose the flow for your enabled account route. These are Heth virtual instruments, not a general promise to accept or pay any external bank card. See the [Quick Start](../business/quick-start.md), [authentication](../business/authentication.md) and [error handling](../business/errors.md). ## Create - [Payment with a virtual card](pcn.md) - [Payout to a virtual card](wcn.md) - [Payout to a wallet ID](wid.md) - [Aggregator payment](aggregator_payment.md) ## Read - [Get a transaction](get_transaction.md) - [List transactions](list_transactions.md) ## Reference - [Amounts, identifiers and statuses](../field_conventions.md) ## en: Payment by Card Number Source: https://docs.heth.me/markdown/en/transactions/pcn.md --- title: Payment by Card Number last_update: date: 2026-10-20 --- # Payment by Card Number Example: `"1000000"` is 1 USDT when decimals=6. Replace all placeholders with verified recipient and instrument details. Sending this request can move real funds. Review and explicitly authorize the operation before submitting it. See [Quick Start](../business/quick-start.md). Initiate a payment using a virtual card instrument. ## Request Example ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "10", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Payment", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` | Field | Description | Type | Example | | ----- | ----- | :--- | ----- | | amount | Transaction amount (string of an integer in minor units) | String | 1000000 | | currency | Transaction currency (default USDT) | String | USDT | | env | `prod` (default). Preserve this value when opening and confirming the request. | String | prod | | type | Transaction type (in this case payment) | String | payment | | route | Transaction route (must match route mapping) | String | hot\_hot\_ETH | | money_storage | Card instrument descriptor | Object | | | \>network | Blockchain network (TRX or ETH) | String | ETH | | \>type | Instrument type (bank_card) | String | bank_card | | \>currency | Instrument currency (default USDT) | String | USDT | | \>cardnumber | Virtual card number | String | YOUR_CARD_NUMBER | | \>cvv | Virtual card CVV | String | YOUR_CVV | | \>exp_month | Expiry month | String | 10 | | \>exp_year | Expiry year | String | 2026 | | \>cardholder | Cardholder name | String | John Doe | | description | Transaction description | String | Payment | | txid | Idempotent transaction identifier (string) | String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## en: Payout by wallet ID Source: https://docs.heth.me/markdown/en/transactions/pid.md --- title: "Payout by wallet ID" last_update: date: 2026-10-20 --- # Payout by wallet ID This page describes the same wallet-ID payout flow as the canonical reference. Use the request and field definitions there. [Payout by wallet ID](wid.md) ## en: Aggregator payment by virtual card Source: https://docs.heth.me/markdown/en/transactions/rcn.md --- title: "Aggregator payment by virtual card" last_update: date: 2026-10-20 --- # Aggregator payment by virtual card This page describes the same merchant-collection flow as the canonical aggregator reference. Use that request and its definitions. [Aggregator payment by virtual card](aggregator_payment.md) ## en: Withdrawal by Card Number Source: https://docs.heth.me/markdown/en/transactions/wcn.md --- title: Withdrawal by Card Number last_update: date: 2026-10-20 --- # Withdrawal by Card Number Example: `"1000000"` is 1 USDT when decimals=6. Replace all placeholders with verified recipient and instrument details. Sending this request can move real funds. Review and explicitly authorize the operation before submitting it. See [Quick Start](../business/quick-start.md). Initiate a payout (funds sent to a card number). ## Request Example ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER" }, "description": "Withdrawal", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` | Field | Description | Type | Example | | ----- | ----- | :--- | ----- | | amount | Transaction amount (string of an integer in minor units) | String | 1000000 | | currency | Transaction currency (default USDT) | String | USDT | | env | `prod` (default). Preserve this value when opening and confirming the request. | String | prod | | route | Transaction route (must match route mapping) | String | hot\_hot\_ETH | | type | Transaction type (in this case payout) | String | payout | | money\_storage | Recipient data object | Object | | | \>network | Blockchain network (TRX or ETH) | String | ETH | | \>type | Instrument type (bank\_card) | String | bank\_card | | \>currency | Recipient currency (default USDT) | String | USDT | | \>cardnumber | Recipient card number | String | YOUR_CARD_NUMBER | | description | Transaction description | String | Withdrawal | | txid | Idempotent transaction identifier (string) | String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## en: Withdrawal by ID Source: https://docs.heth.me/markdown/en/transactions/wid.md --- title: Withdrawal by ID last_update: date: 2026-10-20 --- # Withdrawal by ID Example: `"1000000"` is 1 USDT when decimals=6. Replace all placeholders with verified recipient and instrument details. Sending this request can move real funds. Review and explicitly authorize the operation before submitting it. See [Quick Start](../business/quick-start.md). Payout to a wallet identifier. ## Request Example ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Withdrawal", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` | Field | Description | Type | Example | | ----- | ----- | :--- | ----- | | amount | Transaction amount (string of an integer in minor units) | String | 1000000 | | currency | Transaction currency (default USDT) | String | USDT | | env | `prod` (default). Preserve this value when opening and confirming the request. | String | prod | | route | Transaction route (must match route mapping) | String | hot\_hot\_ETH | | type | Transaction type (in this case payout) | String | payout | | money\_storage | Recipient data object | Object | | | \>wallet\_id | Recipient wallet identifier | String | YOUR_WALLET_ID | | \>network | Blockchain network (TRX or ETH) | String | ETH | | \>type | Transaction type for wallets (in this case p2p\_proxy) | String | p2p\_proxy | | \>currency | Recipient currency (default USDT) | String | USDT | | description | Transaction description | String | Withdrawal | | txid | Idempotent transaction identifier (string) | String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## en: Additional account features Source: https://docs.heth.me/markdown/en/user/features.md --- title: "Additional account features" last_update: date: 2026-10-21 --- # Additional account features Features shown in your account depend on its settings. The following explanations do not mean every feature is enabled for every user. ## @usernames In username settings, check availability and the displayed registration price. Select the eligible funding wallet and follow payment instructions. An unpaid reservation is not an active receiving name. Check expiry and renewal terms before paying; an expired or suspended name may not resolve. Releasing a name can be refused while its payment is in progress. ## Gift cards In the gift-card screen, you can view your issues, prepare a supported issue or redeem a code. Issuing a card funds it from your own eligible wallet and requires confirmation. Store the revealed code securely: possession of the code can allow redemption. For redemption, enter the code in Heth; the server determines its denomination. A submitted request alone is not confirmation of credit. ## Gas The gas-purchase screen prepares a separate operation using the supported funding source. Check the destination account, amount and network. A cold funding source can require a signature. Gas for a blockchain transfer is separate from the transferred token amount. ## Donations Open the author's donation page and check the platform, author, asset, network, minimum and fee. Choose an available Heth Wallet or external account and review before authorizing. External transfers can expire; check the current details before sending. The result page shows the original donation status. ## Notifications and webhooks 1. Open **Settings → Notifications**, turn notifications on and approve the system or browser prompt. In the mobile app, Heth uses system notifications; the browser version uses the browser's notification service where supported. 2. If permission was denied, allow notifications for Heth in your device or browser settings, reopen Heth and try again. Delivery also depends on connectivity and device restrictions. 3. To stop notifications on this device, turn the same switch off. This does not cancel payments, subscriptions or AI connections. Opening a payment notification takes you to Heth. Unlock the account and review any requested action there; tapping a notification does not sign or approve a payment. Verify the final result in transaction history. In webhook settings, you can configure a receiving URL and secret for an external integration. This URL receives account events; use an endpoint you control. See [webhook integration](../business/webhooks.md). ## Subscriptions, hardware and multisig Manage subscription requests and future-payment permissions in Heth. The [subscription and autopay guide](../subscriptions.md) explains payer approval, merchant requests, payment dates and revocation. Linking a payment card or authorizing future debits requires your explicit consent. For hardware or multisig accounts, check that your device and signing method support the selected network before sending funds. In **Settings → Subscription mandates**, accounts with this feature can view their own crypto subscription permissions and per-charge limits. Choose a permission, select **Revoke mandate** and confirm in Heth to stop future charges. Revocation does not refund completed payments. ## OBS Studio donation widget Add the Heth widget as an OBS Studio browser source to display a receiving QR, visual themes and incoming-payment alerts. Connect it through **Settings → OBS Studio** in Heth. Keep the private connection URL out of public scenes and AI conversations. An assistant using MCP can read the restricted event feed and change supported appearance settings; access permissions are confirmed in Heth. [OBS setup guide](./obs.md). ## en: OBS Studio: receiving QR and payment alerts Source: https://docs.heth.me/markdown/en/user/obs.md --- title: "OBS Studio: receiving QR and payment alerts" last_update: date: 2026-10-21 --- # OBS Studio: receiving QR and payment alerts The Heth widget is a **Browser source** in OBS Studio. It displays your receiving QR and alerts for incoming, completed Heth transfers. It does not install a native OBS plugin and does not control scenes, recording or streaming. An incoming transfer is not automatically an author/platform donation. ![Preview of the updated widget in English. Sample event; the preview QR does not initiate a payment.](/img/obs-preview-en.png) Preview of the updated widget in English. Sample event; the preview QR does not initiate a payment. ## Connect the widget 1. Open Heth and sign in to the account that will receive donations. 2. Open **Settings → OBS Studio**. The recipient is your signed-in Heth account. 3. Select an available currency/network pair. Optionally enter a suggested amount, caption, theme and language. An empty amount lets the payer choose it. 4. Save the appearance. Choose **Approve and create OBS connection** to create separate, restricted access for the widget. 5. Copy the connection URL. In OBS, add a **Browser** source and paste the URL. Start with a source size of **900 × 500** pixels; resize or crop to fit your scene. 6. Check the recipient, currency and network by scanning the QR with your phone. Review the payment screen before confirming any payment. The QR itself does not move money. The background is transparent. Keep the QR unobstructed and large enough to scan. Check the result in the actual scene, including at the resolution viewers receive. The widget supports Russian and English independently of your Heth interface language. ## Access and privacy The connection uses a separate API key restricted to OBS. Heth creates the key and puts it in the connection URL, so you do not need to copy a key from Business settings. Existing webhook settings are independent: webhooks send events to your server, while the OBS Browser source reads the widget’s restricted feed directly. You do not need to run a webhook receiver for the standard widget. An OBS key belongs to your account and can read its widget feed. MCP permissions are granted separately; revoking an OBS connection and revoking an AI connection are separate actions. The connection URL contains a private OBS access token in its fragment, after `#`. Treat the whole URL as private: do not put it in your stream description, screenshots, public scene exports or an AI chat. The QR displayed to viewers contains payment details, not this token. OBS access can read the receiving identifier, appearance settings and a restricted incoming-payment feed. It cannot read your balance or full transaction history, send money or edit settings. In **Settings → OBS Studio**, revoke an old connection if its URL was exposed or you stopped using it. Create a new connection in Heth when needed. ## How alerts work Alerts represent incoming transfers with status `charged`. Pending, failed and outgoing operations are excluded. The amount uses the recipient amount and its stored precision; it is not rounded to a whole token. If precision is unavailable, the widget does not invent an amount. A fresh connection starts with new events. A running browser source can resume from its saved cursor after a short interruption; its replay window is limited to 24 hours. Reloading or recreating a source is not a way to export account history. Verify receipt and final operation details in [transaction history](./payments.md), independently of an on-stream alert. ## Change the widget with an AI assistant A connected assistant using the [remote MCP service](../ai/mcp.md) with the appropriate permissions can read the widget settings, view the restricted event feed and propose a connection. It can change ordinary appearance settings with confirmation in the AI client. The already connected widget refreshes saved appearance automatically, normally within 30 seconds. Creating or revoking access and changing a receiving account require confirmation in Heth. The assistant provides a link to the Heth setup screen; it does not receive the private OBS connection URL. Example requests: “Use an English caption and a minimal theme for my OBS widget” or “Show recent incoming events for my widget”. MCP does not give the assistant control of OBS Studio itself. ## Your own layout and AI-assisted customization {#custom-layout} The standard Heth settings need no source-code access. For an arbitrary layout, fork the public [Heth OBS widget](https://github.com/Heth-me/obs-widget), licensed under MIT. Start with its [AI guide](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md), file map and hosting instructions. The repository includes build and hosting instructions. A coding assistant with access to your copy can change the layout, CSS, fonts, colors and notification presentation, then check a synthetic preview and build. It does not need your live OBS connection URL or payment credentials. A custom build must be hosted: a public repository by itself does not serve incoming-payment alerts. Heth MCP can read events and change supported Heth appearance settings. It does not edit a repository, compile a custom build or give an assistant access to your hosting account. For arbitrary HTML/CSS layouts, customize the open source project. You can keep using the standard Heth-hosted widget without building anything. ## Troubleshooting **Heth shows a 404 instead of the widget:** update Heth, check the Browser-source URL and reopen the source. If the error persists, contact support. Do not create new keys to fix a page-loading error. - **No OBS settings entry:** update Heth and check your account access with support. Do not paste a general account API key into a widget URL. - **QR appears, no alert:** check that the transfer is completed and incoming to this account. The Browser source must remain active and online. - **Access disabled:** reconnect in Heth; retrying a revoked URL will not restore permission. - **Wrong asset or network:** correct the settings in Heth, wait for the widget to refresh and scan the QR again before accepting payments. - **Old URL uses `api_key=`:** reconnect through Settings → OBS Studio. Keep the old URL private and revoke an obsolete account key. ## en: Pay and receive payments Source: https://docs.heth.me/markdown/en/user/payments.md --- title: "Pay and receive payments" last_update: date: 2026-10-20 --- # Pay and receive payments ## Pay with Heth Open the payment screen and follow the available payment method. A payer QR can authorize a payment: share it only with the intended merchant. Where the app requests amount confirmation, check the merchant and amount before confirming. Never send your recovery phrase or payment secret to a merchant or AI assistant. The app can show some cached information or generate certain payer codes without a connection. The merchant still needs connectivity to process the payment; ordinary transfers do not execute offline. See [offline limits](security.md). ## Confirm the payment amount Follow the confirmation method Heth shows for this payment: 1. Open your payer QR and show it only to the intended merchant. 2. Check the requested amount and recipient before approving. 3. If Heth asks you to generate a code, return to the amount-confirmation screen after displaying your QR, enter the payment amount and generate the current code. 4. Read that code to the cashier only for this payment. It is different from a recovery phrase, PIN or reusable payment secret, which you must keep private. 5. If the QR or code expires, open a fresh one and follow the current prompt. If confirmation is not configured, complete the setup in Heth while online. 6. Check the original transaction status. A displayed QR, generated code or cashier request does not by itself prove payment. ## Accept a Heth payment 1. Open **Business**. 2. Enter the amount and select an available asset/network. 3. Scan the payer's Heth QR and submit the request. 4. If payer approval is required, wait for it. 5. Treat the payment as received only when its status is `charged`. A decline, pending result and timeout are different outcomes. Keep the original operation identifier when checking the result. ## Share a receiving link The payment-link screen generates a Heth receiving URL with your recipient identifier, selected currency and, optionally, an amount. The payer reviews and authorizes the transfer. Sharing the link does not charge anyone. This receiving URL differs from a managed business payment link created through an API. Do not assume a locally generated receiving link has a server-side list, expiry or cancellation function. ## Other QR providers Only use methods actually enabled for your account. A QR provider logo or a scanner recognizing a format is not proof that the corresponding payment route is available. Contact support if a method cannot be used; do not substitute another recipient or network to force a payment through. ## en: Account security and offline use Source: https://docs.heth.me/markdown/en/user/security.md --- title: "Account security and offline use" last_update: date: 2026-10-21 --- # Account security and offline use ## Recovery and signing Keep recovery phrases and private keys in the wallet that owns them. A PIN or biometric unlock protects access on the current device; it is not a replacement for a recovery backup. Never share a seed, private key or reusable payment secret with support, a merchant or an AI assistant. Show a one-time payment QR only to the intended merchant. If Mode B explicitly asks you to read a confirmation code to the cashier, do so only after checking that payment and its amount. Check the origin, recipient, amount, currency and network before signing. Reconnecting an account, changing a network or opening a wallet prompt does not by itself complete a payment. For a hardware wallet, check the details on the device as well. ## Face ID / Touch ID and passkeys In **Settings → Face ID / Touch ID**, enable biometric unlock if this option is available, then confirm the system prompt. Heth uses a WebAuthn credential (passkey) for local unlock. Availability depends on the device and browser; use your PIN when biometric unlock is unavailable or cancelled. This unlocks Heth on the current device. It does not replace your recovery phrase, recover an account on another device, or authorize an AI connection or payment. Keep your recovery backup before changing devices or reinstalling Heth. ## Offline limits Cached balances and history can be viewed while offline, but may be out of date. Some payer codes can be generated locally for a merchant who is online. Sending transfers, loading current balances and receiving a confirmed processing result require connectivity. After reconnecting, refresh history before repeating any operation. ## Fees and support Check the fees and amount shown for the actual operation. A blockchain gas fee can be separate from the service fee. Do not infer a fee or guaranteed completion time from another transfer type. Use [Heth support](https://t.me/hethmesupport_bot) and share the transaction identifier and problem description. Do not send account secrets. Read the [Privacy Policy](https://app.heth.me/settings/legal/privacy-policy) and [Terms of Service](https://app.heth.me/settings/legal/terms-of-service) in Heth. [Payment problems and status](troubleshooting.md). ## en: Transfer and withdraw funds Source: https://docs.heth.me/markdown/en/user/transfers.md --- title: "Transfer and withdraw funds" last_update: date: 2026-10-20 --- # Transfer and withdraw funds Choose the source first: an internal Wallet balance or a Crypto Account. Then select the recipient, asset and network. Check the amount, recipient and fees on the final review before authorizing the operation. ## Transfer types | Transfer | User action | | --- | --- | | Wallet → Wallet | Enter the recipient identifier or resolve an active @username, then review the transfer | | Wallet → Crypto Account | Enter the external address and its network; review the withdrawal and fees | | Crypto Account → Wallet | Select the source account and the destination Wallet; sign the prepared blockchain transaction | | Crypto Account → Crypto Account | Check the external recipient and sign using the owner wallet | An internal transfer and a blockchain withdrawal have different processing and fee requirements. Blockchain transfers may need a native gas balance. A purchase of gas is a separate operation; verify the source and the destination account. ## External and hardware wallets For watch-only addresses, use the external wallet connected to that address. The connected account and network must match the source. Supported signing methods depend on the network, browser and device. A transfer opened through a wallet link may not return a transaction hash to Heth: opening another wallet is not proof of payment. ## If the result is unclear Open transaction history and inspect the original operation. Do not repeat the transfer solely because the screen timed out or the network disconnected. Save its identifier and contact support if the status remains unclear. A pending operation must not be described as a completed payment. [Payment problems and status](troubleshooting.md). ## en: Payment problems and transaction status Source: https://docs.heth.me/markdown/en/user/troubleshooting.md --- title: "Payment problems and transaction status" description: "Find an original Heth payment, understand a pending result and resolve network, balance or QR confirmation problems." last_update: date: 2026-10-20 --- # Payment problems and transaction status ## The screen timed out: should I send again? 1. Restore the connection and open transaction history in the same account and environment. 2. Find the original operation by its identifier, time, amount and recipient. Open its details if available. 3. Check the current status. If the operation remains pending or cannot be found, contact support before sending again. A missing result is not proof that no money moved. 4. Keep the original identifier for follow-up. For API integrations, use [status lookup](../transactions/get_transaction.md) and the same original `txid`; do not create a replacement identifier to bypass a timeout. | Status | What to do | | --- | --- | | `created`, `pending`, `processing` | Processing is not complete. Refresh the original operation; do not count it as received | | `auth_required` | Open Heth and follow the requested approval for this operation | | `charged` | The operation has settled. Check its amount, recipient and fee in the details | | `rejected`, `failed` | Read the original error and resolve its cause before attempting a new operation | | No status or an unfamiliar status | Keep the result unconfirmed and request clarification; do not infer success or failure | A refund or reversal is a separate result. Confirm it from the original operation and the actual credited balance. A blockchain transfer cannot be cancelled merely by closing Heth. ## The balance or receiving details look wrong - Check the account, asset, network and environment. An internal Wallet and a Crypto Account are different destinations. - Refresh after reconnecting. An offline screen can contain cached information. - For an external deposit, compare the destination and network in the sending wallet with Heth's receiving details. A transaction on another network does not credit this account automatically. - For an additional cold account missing on another device, reconnect its original wallet. See [accounts and backup](wallets.md). ## The payer QR or amount confirmation does not work Open a fresh payer QR in Heth. If the app requests a confirmation code, follow the [payment instructions](payments.md), check the amount and use the current code. A QR is not a receipt. The merchant needs connectivity to process the request. If the app says confirmation is not configured, complete its setup in Heth while online. ## Contact support Send the transaction identifier, approximate time with time zone, asset/network, amount and the visible error to [Heth support](https://t.me/hethmesupport_bot). Mask unrelated personal information in screenshots. Never include a recovery phrase, private key, API key, payer QR, gift-card code or reusable payment secret. ## en: Get started and understand your wallets Source: https://docs.heth.me/markdown/en/user/wallets.md --- title: "Get started and understand your wallets" last_update: date: 2026-10-20 --- # Get started and understand your wallets Open [Heth.me](https://app.heth.me). Create a recovery phrase or restore your existing account, then follow the application steps to set a PIN and, where supported, biometric unlock. Keep your recovery phrase separately before receiving funds. See [account security](security.md). ## Crypto Account and Wallet | Item | What it means | How a transfer is authorized | | --- | --- | --- | | Crypto Account (cold) | A blockchain address, generated or connected in the app | The owner signs with a local, external or supported hardware wallet | | Wallet (hot) | An account balance used for internal payments and transfers | The service processes the authorized operation | | Watch-only account | An address added for viewing without its private key | Viewing does not give permission to spend; use the connected signer | Cold accounts and their labels can be stored on your device. Signing in elsewhere does not necessarily restore every additional account you connected on another device. Back up each account through its original wallet. ## Receive funds 1. Open the required Crypto Account or Wallet. 2. Check the asset and network. USDT on Ethereum and USDT on TRON are different transfer destinations. 3. Use the receiving details or QR shown for that account. Do not substitute a blockchain address for an internal wallet identifier. 4. Confirm the incoming operation in history. A pending balance is not the same as available funds. For purchases through an external exchange, check its destination network before withdrawing. The exchange page provides links to external services; availability and terms depend on that provider. ## Available assets Use the assets shown for your account. The global token registry can include assets that are not enabled in your interface or for a particular operation. ## ru: Подключить ИИ-помощника Source: https://docs.heth.me/markdown/ru/ai/mcp.md --- title: "Подключить ИИ-помощника" last_update: date: 2026-10-21 --- # Подключить ИИ-помощника Heth MCP даёт помощнику ограниченный доступ к вашему аккаунту, включая доступные ему бизнес-функции. Администрирование платформы через него недоступно. Открытие экрана подключения само по себе не выдаёт разрешений. ## Как подключить помощника 1. В приложении Heth, где уже открыт ваш кошелёк, перейдите в **Настройки → Подключения ИИ** и нажмите **Создать код подключения**. Одноразовый код относится именно к этому аккаунту и действует пять минут. 2. В настройках подключений клиента ИИ добавьте `https://mcp.heth.me/mcp`, выберите OAuth и начните подключение. 3. В открывшемся окне введите только код из Heth. Входить в кошелёк в этом браузере не нужно. Код направляет запрос в создавший его аккаунт, но сам по себе доступа не даёт. 4. Откройте пуш в приложении Heth. Если он не пришёл, откройте **Настройки → Подключения ИИ → Запросы на подключение**. Сверьте **код проверки запроса** с кодом в окне подключения. Проверьте аккаунт, идентификатор клиента и адрес сервиса: одно название приложения не подтверждает его подлинность. 5. В Heth снимите лишние разрешения и нажмите **Разрешить выбранный доступ ИИ** либо **Отказать в доступе ИИ**. Само открытие пуша ничего не подтверждает. 6. Вернитесь в клиент ИИ: окно подключения завершит процесс автоматически после решения в Heth. Сессия кошелька и ключи подписи остаются в приложении Heth. Использованный или истёкший код не подходит для повторной привязки. Создайте новый код в Heth: он заменяет предыдущий неиспользованный. Если истёк сам запрос подключения, начните его заново в клиенте ИИ. ### В ChatGPT Откройте **Plugins → Add → Add custom MCP server**, укажите название, например Heth.me, адрес сервера выше и оставьте **OAuth**. ChatGPT обнаружит настройки автоматически; API-ключ кошелька, client secret и фраза восстановления не нужны. Создайте личный плагин, нажмите **Connect Heth.me** и пройдите шаги с кодом и пушем выше. Запрашиваемые разрешения можно выбрать в **Advanced OAuth settings**, а окончательный выбор доступа к аккаунту подтверждается в приложении Heth. После подключения выберите Heth.me в чате и попробуйте: «Покажи балансы моих кошельков через Heth». Доступные инструменты зависят от подтверждённых разрешений. ## Разрешения и инструменты Можно подтвердить только запрошенные разрешения, которые доступны вашему аккаунту сейчас. Инструмент виден только при наличии нужного разрешения. Инструменты охватывают данные аккаунта, переводы, обычные бизнес-изменения, запросы подписки и OBS. | Разрешение | Инструменты и назначение | | --- | --- | | `heth:wallets:read` | `get_wallet_balances`: балансы своих кошельков | | `heth:transactions:read` | `list_transactions`, `get_transaction`: своя история и исходный статус операции | | `heth:business:read` | `list_products`, `list_business_payment_links`, `list_business_subscriptions`: свои товары, управляемые платёжные ссылки и подписки продавца; `get_business_subscription`, `list_business_subscription_requests`: условия отдельной подписки и исходящие запросы | | `heth:payments:prepare` | `prepare_transfer`, `get_transfer_request`: подготовка перевода для подтверждения в Heth и проверка исходного результата | | `heth:business:manage` | `create_business_product`, `update_business_product`, `delete_business_product`; `create_business_payment_link`, `update_business_payment_link`, `delete_business_payment_link`: обычные изменения с подтверждением в клиенте ИИ | | `heth:business:manage` | `request_business_subscription`: запрос согласия плательщика в Heth; `prepare_business_subscription_change`: проверка приостановки, возобновления или отмены в Heth | | `heth:obs:read` | `get_obs_widget`, `list_obs_events`: настройки и входящие события | | `heth:obs:configure` | `prepare_obs_connection`, `update_obs_widget`: ссылка на проверку в Heth либо оформление с подтверждением в клиенте ИИ | `prepare_obs_connection` не выдаёт доступ и не возвращает токен OBS. Через изменение оформления нельзя менять валюту, сеть, получателя, ключи или права доступа. См. [подключение и настройку OBS](../user/obs.md): там есть открытый проект и инструкции для ИИ, который помогает менять код. ## Срок доступа Разрешение подключения действует **до вашего отзыва**. Технические данные доступа имеют отдельные сроки: токен MCP — 15 минут; refresh-токен заменяется при обновлении и истекает после 30 дней без обновления. Если технический токен истёк, может понадобиться повторное подключение, даже если запись согласия ещё активна. Каждый запрос проверяет текущее согласие и права аккаунта. Для обращения к API Heth используется отдельный ограниченный токен сроком не более 60 секунд; полная сессия кошелька в MCP не передаётся. Отзыв согласия или прав аккаунта блокирует последующие запросы, включая запросы с ещё не истёкшими токенами. Уже полученные клиентом данные отозвать невозможно. ## Отзыв и повторное подключение В Heth откройте **Настройки → Подключения ИИ**, проверьте идентификатор клиента, адрес сервиса, разрешения и статус. Нажмите **Отозвать доступ ИИ** и подтвердите действие в Heth. Отзыв не отменяет завершённые платежи и разрешения на списания по подпискам: ими нужно управлять отдельно в [настройках подписок](../user/features.md). Если помощник просит подключиться заново, начните новую авторизацию из клиента ИИ. Доступ может прекратиться после отзыва, истечения токенов, изменения прав или обнаружения повторного использования refresh-токена. Не передавайте помощнику фразу восстановления, ключи кошелька или данные браузерной сессии для исправления подключения. Недоступность сервиса — ошибка, а не пустой аккаунт или успешное подтверждение. ## Платежи и другие изменения Heth требует **отдельного подтверждения в Heth каждой денежной операции**. Разрешение подключения не разрешает автоматические списания. Обычные изменения товаров и платёжных ссылок требуют подтверждения в клиенте ИИ. Изменения прав, получателей выплат и разрешений на будущие списания подтверждаются в Heth. Оформление OBS подтверждается в клиенте ИИ. Одна аннотация инструмента не доказывает, что клиент получил согласие человека. Вы также можете использовать [приложение Heth](https://app.heth.me) или поддерживаемую [интеграцию API](../business/quick-start.md). ## Перевод с помощью ИИ 1. Укажите помощнику тип перевода, получателя, валюту, сеть и сумму. Между внутренними счетами (`hot_hot`), с внутреннего на блокчейн-адрес (`hot_cold`), с блокчейн-адреса на свой внутренний счёт (`cold_hot`) и между блокчейн-адресами (`cold_cold`) — разные операции. Для `cold_hot` получатель — `self`: зачисление идёт на ваш собственный счёт Heth. 2. `prepare_transfer` сохраняет условия и возвращает ссылку для проверки в Heth. Платёж при этом не создаётся. Сумма и `max_debit` передаются точными целочисленными строками в минимальных единицах токена. `max_debit` ограничивает списание токена вместе с комиссиями платформы. Для источника в блокчейне `max_network_fee` ограничивает сетевую плату за газ транзакции в wei (ETH/Base) или sun (TRON). В Base дополнительно возможна плата за данные L1. 3. Откройте Heth и проверьте аккаунт, клиента ИИ, получателя, источник, сумму, сеть и пределы комиссий. Нажимайте **Подтвердить и отправить в Heth** только при верных условиях. Само открытие ссылки ничего не подтверждает и не отправляет. Запрос действует 15 минут. 4. Heth подписывает показанное поручение и использует обычный механизм перевода. Блокчейн-транзакция подписывается на вашем устройстве или подключённом устройстве подписи. Открывайте Heth там, где доступна подпись источника; приватные ключи помощнику не передаются. 5. Помощник проверяет исходную транзакцию через `get_transfer_request`. Подтверждение или обработка ещё не означают оплату. После обрыва связи проверьте исходный результат; повторяйте подготовку с тем же `request_id` и теми же условиями. Не создавайте второй перевод ради выяснения результата первого. Отзыв подключения запрещает начало нового перевода. Уже принятая к исполнению транзакция может завершиться: отзыв доступа ИИ не отменяет принятый блокчейн-перевод. ## Товары, ссылки и подписки Обычные изменения товаров и управляемых платёжных ссылок помощник показывает для подтверждения в клиенте ИИ. Цены и суммы ссылок — целочисленные строки в минимальных единицах валюты, количество товара — положительное целое число. Постоянный `request_id` защищает от повторного изменения при повторе запроса. Эти операции не меняют маршрутизацию платежей, получателей выплат, ключи и права доступа. Удаление ссылки или товара не отменяет прежние платежи. `request_business_subscription` создаёт запрос для проверки плательщиком в Heth. Сам запрос не даёт права на будущие списания и не создаёт платёж. Плательщик проверяет сумму, периодичность и первое списание перед подписью в Heth. Запросы проверяются через `list_business_subscription_requests`, существующие соглашения — через `get_business_subscription` или `list_business_subscriptions`. Для приостановки, возобновления или отмены соглашения `prepare_business_subscription_change` возвращает экран проверки в Heth. До подтверждения владельцем ничего не меняется. Возобновление разрешает списания по расписанию в пределах существующего платёжного разрешения. Отмена прекращает будущие списания и не возвращает уже оплаченные суммы. Новые условия списаний требуют нового согласия плательщика. ## ru: Авторизация и API-ключи Source: https://docs.heth.me/markdown/ru/business/authentication.md --- title: "Авторизация и API-ключи" last_update: date: 2026-10-20 --- # Авторизация и API-ключи ## Выпустить и отозвать ключ 1. Войдите в [Heth](https://app.heth.me) и откройте **Бизнес**. 2. Перейдите к интеграции кнопкой **Подключить**. 3. На экране **Интеграция по АПИ** нажмите **+** для выпуска ключа. 4. Сохраните ключ как секрет серверной интеграции. 5. Для отзыва удалите запись ключа на этом экране. При замене обновите настройки интеграции. Не используйте ключ из скриншота или примера документации. Вместо действующих реквизитов здесь используются placeholders. ## Заголовки запроса | Заголовок | Применение | | --- | --- | | `x-api-key` | Обязателен для авторизации API-ключом | | `Content-Type: application/json` | Обязателен при отправке JSON | Для `https://app.heth.me` контекст организации подставляет шлюз Heth. Это правило относится к указанному хосту и не переносится на произвольный API платформы. Ключ привязан к собственному аккаунту и его правам. ## Ключ и пользовательская сессия различаются Транзакционная интеграция принимает API-ключ. Интерактивные функции могут требовать Bearer-сессию вошедшего пользователя: ключ не открывает автоматически кошельки, профиль, @имена и все бизнес-функции. Клиентские сессии подписок — отдельный вид авторизации. Не заменяйте один тип токена другим и не копируйте seed в конфигурацию интеграции. См. [доступные функции](capabilities.md) и [ошибки](errors.md). Запрашивайте только необходимый для задачи доступ. ## ru: Бизнес-функции и доступность Source: https://docs.heth.me/markdown/ru/business/capabilities.md --- title: "Бизнес-функции и доступность" last_update: date: 2026-10-20 --- # Бизнес-функции и доступность Используйте функции, включённые для аккаунта. Наличие endpoint в платформе не означает доступность для вашего пользователя, сети и маршрута. | Возможность | Условия интеграции | | --- | --- | | Платежи и выплаты | Транзакционный API, настроенный маршрут, разрешённые инструмент и окружение | | Ссылка получения Heth | URL формируется в приложении; отправка ссылки не создаёт списание | | Управляемые ссылки и товары | Отдельные бизнес-ресурсы с проверкой доступа аккаунта | | Подписки продавца | Выставляются покупателям; требуют поддерживаемого способа оплаты и согласия покупателя | | Собственные акцепты плательщика | Отдельная клиентская авторизация и явное подтверждение или отзыв | | Возврат и отмена | Только при поддержке исходной транзакцией и способом оплаты; блокчейн-перевод нельзя произвольно обратить | | Кошельки, @имена, подарочные карты, webhooks | Могут требовать пользовательскую сессию и дополнительное подтверждение | | Донаты | Поток площадки и автора со своими получателем, минимумом, комиссией и сроком | Публичный реестр токенов возвращает конфигурацию, а не право платить каждым активом. Сопоставляйте актив с сетью и действующими настройками аккаунта. Например, USDT/ETH и USDT/TRX не взаимозаменяемы. ## Границы справочника [Справочник транзакций](../transactions/overview.md) описывает форматы запросов указанных сценариев. Для устранения отказа не запрашивайте операторские реквизиты и не меняйте терминалы и маршрутизацию. При недоступном маршруте передайте поддержке идентификатор транзакции. [Руководство по подключению ИИ](../ai/mcp.md) объясняет разрешения и подтверждение действий, доступных вашему аккаунту. ## ru: Ошибки, статусы и повторы Source: https://docs.heth.me/markdown/ru/business/errors.md --- title: "Ошибки, статусы и повторы" last_update: date: 2026-10-20 --- # Ошибки, статусы и повторы Проверяйте HTTP-ответ и `status` транзакции. При 200 или 201 транзакция может быть отклонена или ожидать обработки. | HTTP-результат | Действие интеграции | | --- | --- | | 400 / 422 | Проверьте поля, типы, масштаб суммы, окружение и получателя. Не повторяйте неизменённый невалидный запрос по кругу | | 401 | Проверьте реквизиты авторизации, срок и API-хост | | 403 | Аккаунту или ключу не хватает прав; не переключайте автоматически пользователя и окружение | | 404 | Проверьте идентификатор и контекст аккаунта. Ответ не доказывает отсутствие ресурса у другого аккаунта | | 409 | Разберите конфликт и восстановите исходную операцию до создания другой | | 429 | Учитывайте `Retry-After`, если он передан; повторы чтения ограничивайте по времени | | Таймаут / 5xx | Результат может быть неизвестен. Найдите исходную операцию по `id` или `txid` до повторной отправки | Форматы ошибок различаются по endpoint. Если описан машинный код ошибки, используйте его; `error_description` — человекочитаемый, нестабильный текст. Удаляйте из логов секреты и данные платёжного инструмента. ## Результат транзакции - `charged`: операция успешно завершена. - `rejected` или `failed`: проверьте причину и исходную операцию; успех не подтверждён. - `refunded` или `reversed`: состояние денег отличается от нового успешного зачисления. - Ожидание, запрос действия или неизвестный статус: покажите это состояние и необходимое действие пользователя. Незнакомый статус и timestamp сами по себе не означают успеха. Проверяйте операцию через [GET транзакции](../transactions/get_transaction.md). Для повтора одной бизнес-инструкции сохраняйте `txid`. Ошибка доставки webhook и ошибка обработки платежа — разные события. ## ru: Начало API-интеграции Source: https://docs.heth.me/markdown/ru/business/quick-start.md --- title: "Начало API-интеграции" last_update: date: 2026-10-20 --- # Начало API-интеграции Используйте API-ключ собственного аккаунта Heth. Сначала прочитайте об [авторизации](authentication.md), [суммах и статусах](../field_conventions.md) и [доступных бизнес-функциях](capabilities.md). ## Проверить доступ без движения денег Сохраните `HETH_API_KEY` в хранилище секретов интеграции. Не помещайте его в репозиторий, клиентский код, URL или переписку с ИИ. Этот запрос читает историю аккаунта без движения денег. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'limit=10' \ --data-urlencode 'order_by=started' ``` Пустой массив `data` — допустимый результат. При ответе 401 или 403 проверьте авторизацию и права аккаунта. ## Первый платёж 1. Проверьте доступные вашему аккаунту платёжные маршруты и получите реквизиты получателя или платёжного инструмента. 2. Выберите нужный [пример транзакции](../transactions/overview.md) и замените все заполнители проверенными реквизитами своей операции. 3. Используйте небольшую сумму: для USDT с шестью знаками `"1000000"` означает 1 USDT. 4. До отправки создайте и сохраните уникальный `txid` бизнес-операции. 5. Отправьте запрос один раз, сохраните `id` и [проверьте статус](../transactions/get_transaction.md). 6. При таймауте найдите исходную операцию по `txid` или повторите идентичный запрос с тем же идентификатором. Новый идентификатор не создавайте. Отправка платёжного запроса может привести к списанию реальных средств. До отправки проверьте получателя, сумму, валюту, сеть и комиссии. API-ключ разрешает только операции, доступные его аккаунту. ## ru: Товары, управляемые ссылки и подписки Source: https://docs.heth.me/markdown/ru/business/resources.md --- title: "Товары, управляемые ссылки и подписки" last_update: date: 2026-10-20 --- # Товары, управляемые ссылки и подписки Это бизнес-ресурсы собственного аккаунта. Нужны API-ключ или партнёрская Bearer-сессия и включённые возможности. Ключ сам по себе не включает платёжный маршрут. См. [авторизацию](authentication.md). Для чтения и удаления env — query-фильтр. При создании и изменении товаров и ссылок передавайте env в JSON-теле. Владельца определяют реквизиты доступа; не передавайте чужой partner_id. Поля цены ресурса могут иметь целочисленный тип своего endpoint; amount транзакционного API остаётся строкой целого числа. ## Товары ```http GET /api/v1/products?env=prod&limit=10 GET /api/v1/products/{id}?env=prod POST /api/v1/products PUT /api/v1/products/{id} DELETE /api/v1/products/{id}?env=prod ``` Создание товара задаёт header, text, price, qty и currency. Сам товар не является платежом. Списки возвращают data/total, детали и создание товара — data. Цена примера — 1 USDT при decimals=6. ```json { "env": "prod", "header": "Example item", "text": "Example item", "price": 1000000, "qty": "1", "currency": "USDT" } ``` ## Управляемые платёжные ссылки ```http GET /api/v1/links?env=prod&limit=10 POST /api/v1/links PUT /api/v1/links/{id} DELETE /api/v1/links/{id}?env=prod ``` Ссылки — отдельные серверные ресурсы с настройкой суммы, оплаты и необязательными товарами. Используйте URL или параметры формы из ответа, не придумывайте адрес. Ссылка получения, сформированная в Heth локально, — другой объект. Удаление ссылки не возвращает уже списанные деньги. ## Подписки продавца ```http GET /api/v1/recurrents?env=prod&limit=10 GET /api/v1/recurrents/{id}?env=prod POST /api/v1/recurrents PUT /api/v1/recurrents/{id} POST /api/v1/recurrents/{id}/pause POST /api/v1/recurrents/{id}/resume POST /api/v1/recurrents/{id}/cancel ``` Подписка создаётся на основе успешного начального платежа собственного аккаунта. POST /recurrents принимает payment_id и объект recurrent; interval — daily, weekly, monthly или yearly, period — количество интервалов. Окружение наследуется от исходного платежа. Покупатель должен разрешить способ оплаты и условия последующих списаний. Создание записи подписки ещё не подтверждает наличие действующего разрешения на списание. Для состояния используются `POST /recurrents/{id}/pause`, /resume и /cancel. Проверяйте ответ; отмена будущих списаний не возвращает предыдущие. Собственные криптовалютные акцепты плательщик Heth просматривает и отзывает со своей сессией кошелька в Настройках → Акцепты подписок, если функция доступна аккаунту. Это отдельный сценарий от управления подписками продавца. ## ru: Интеграция webhook Source: https://docs.heth.me/markdown/ru/business/webhooks.md --- title: "Интеграция webhook" last_update: date: 2026-10-20 --- # Интеграция webhook Webhook сообщает о событии аккаунта на указанный URL. Это уведомление; актуальный статус проверяйте через [GET транзакции](../transactions/get_transaction.md). ## Настроить получателя В настройках Heth укажите принадлежащий вам URL, настройте секрет интеграции и включите доставку. Изменение URL меняет получателя событий аккаунта. Защитите endpoint и избегайте перенаправлений посторонним получателям. Настройка требует пользовательскую сессию; транзакционного API-ключа не обязательно достаточно. ## Обработать уведомление 1. Проверьте подпись webhook аккаунта и защиту от повторов по описанию ниже. 2. Сохраните идентификаторы события и транзакции, удаляя чувствительные поля. 3. Обрабатывайте идемпотентно: повторное или запоздавшее уведомление не должно создавать новый платёж. 4. Получите транзакцию со своими реквизитами доступа и сверьте статус. 5. Верните ответ, предусмотренный настроенным контрактом доставки. Push браузера не является webhook и не гарантирует доставку. Этот обзор не обещает общий для всех интеграций порядок, интервалы повторов или формат авторизации. До включения боевой автоматизации получите действующий контракт доставки. ## Формат доставки webhook аккаунта Этот формат относится к webhook, настроенному в Heth. Другие callback-интеграции могут иметь иной контракт. При непустом секрете webhook передаются x-webhook-signature (hex HMAC-SHA256), x-webhook-timestamp (Unix seconds) и x-webhook-event-id. Проверяйте HMAC от timestamp + "." + точных исходных байтов HTTP-тела с настроенным секретом: до проверки нельзя разобрать JSON и сериализовать заново. Сверяйте timestamp подписанного тела с заголовком, отклоняйте расхождение часов больше 5 минут, сравнивайте подписи за постоянное время и исключайте повторную обработку по event_id. При повторе event_id сохраняется, timestamp и подпись обновляются. Без настроенного секрета заголовков подписи может не быть; до автоматизации задайте секрет. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` Конверт содержит event_id, timestamp, type и data. В транзакционных событиях аккаунта data содержит tx_id, txid, type, status, amount, currency и event_type. amount может быть JSON-целым: используйте разбор без потери точности. Донат может добавлять объект donation. После проверки и сохранения события отвечайте HTTP 2xx; повторный проверенный event_id не должен повторять бизнес-действие. Даже после подписанного уведомления сверяйте транзакцию через GET. ## ru: Глоссарий и соглашения по полям Source: https://docs.heth.me/markdown/ru/field_conventions.md --- title: Глоссарий и соглашения по полям last_update: date: 2026-10-20 --- # Глоссарий и соглашения по полям ## Заголовки запроса | Заголовок | Обязателен | Определение | | --------- | ---------- | ----------- | | x-api-key | Да | API-ключ, выпущенный в приложении (раздел «Бизнес»). Организация определяется по хосту запроса | | Content-Type | Да (POST) | `application/json` для запросов создания | ## Суммы и валюта | Термин | Определение | | ------ | ----------- | | amount | Строка целого числа в минорных единицах | | amount_with_fee | Сумма с включенной комиссией (минорные единицы) | | currency | Код валюты / токена (USDT) | | currency_dest | Валюта зачисления для конвертации (FX). Опционально; по умолчанию равна currency | ## Идентификаторы | Термин | Определение | | ------ | ----------- | | id | Внутренний UUID транзакции | | txid | Строковый идентификатор бизнес-операции, заданный интеграцией; UUID удобен, но не обязателен | ## Маршрутизация и среда | Термин | Определение | | ------ | ----------- | | route | Алиас маршрута обработки, настроенный для API-ключа | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | ## Статусы | Статус | Значение | | ------ | -------- | | created | Принята, ожидает обработки | | new | Начальное состояние до старта обработки | | authorizing | Идёт авторизация | | pre_authorized_3ds | Ожидает 3DS-аутентификацию | | action_required | Требуется доп. действие (3DS / доп. авторизация) | | charging | В процессе проведения | | payment_suspended | Входящая транзакция временно приостановлена | | payout_suspended | Исходящая транзакция временно приостановлена | | charged | Успешно завершена (терминальный) | | reversed | Списание отменено (терминальный) | | refunded | Возврат (терминальный) | | rejected | Отказ (терминальный) | | failed | Сбой (терминальный) | Терминальные статусы: `charged`, `reversed`, `refunded`, `rejected`, `failed`. Типичный happy-path: `created → charging → charged`. ## Временные поля | Поле | Значение | | ----- | -------- | | started | Время начала обработки (ISO) | | finished | Время достижения терминального статуса | ## Объекты money_storage | Поле | Значение | | ----- | -------- | | network | Blockchain-сеть (ETH, TRX и т.п.) | | type | Тип инструмента (bank_card, p2p_proxy) | | wallet_id | Идентификатор кошелька | | cardnumber | PAN виртуальной карты | | cvv | CVV виртуальной карты | | exp_month / exp_year | Срок действия (строки) | | cardholder | Имя держателя | ## Ошибки | Поле | Значение | | ----- | -------- | | error_description | Текстовое описание ошибки (нестабильно) | ## Идемпотентность Используйте уникальный (идемпотентный) `txid` для каждой бизнес-операции и сохраните его до отправки. Значение — строка; UUID удобен, но формат UUID не обязателен. Повторяйте ту же инструкцию с тем же идентификатором в том же аккаунте и окружении. Не используйте его для другой суммы или получателя. После таймаута восстанавливайте исходную операцию: повтор не должен незаметно создавать новый платёж. ## Поллинг Повторяйте чтение с ограниченным backoff, например 1s → 2s → 4s → 8s, с бюджетом ожидания 30s. Остановитесь при известном конечном статусе или исчерпании бюджета. При таймауте сохраните `id`/`txid` и покажите ожидание или неизвестный результат. Незнакомый статус не означает успеха. См. [ошибки и повторы](business/errors.md). ## Webhook Информирует об изменении — статус подтверждайте через GET. ## Масштаб суммы Суммы — строки целых чисел в минорных единицах, а не числа с плавающей точкой. Получайте decimals по валюте, сети и окружению из `GET https://app.heth.me/api/v1/contracts?env=prod`. Для USDT/ETH и USDT/TRX сейчас 6 знаков: 1 USDT = `"1000000"`, 0,25 USDT = `"250000"`. У ETH 18 знаков, но это не относится ко всем токенам Ethereum. При неизвестном масштабе преобразование суммы нужно остановить. См. [схему API](/openapi.json). ## ru: Как пользоваться Heth.me: кошелёк и платежи Source: https://docs.heth.me/markdown/ru/intro.md --- slug: "/" sidebar_position: 1 title: "Кошелёк, переводы и приём платежей" sidebar_label: "Начало работы" description: "Как настроить кошелёк Heth.me, переводить USDT, платить по QR и принимать платежи. Инструкции для пользователей и бизнеса, справочник API." last_update: date: 2026-10-20 --- # Как пользоваться Heth.me: кошелёк и платежи В этом руководстве — как настроить аккаунт Heth.me, получать и переводить средства, оплачивать покупки и подключать приём платежей. Пользовательские инструкции объясняют действия в приложении, а справочник API — запросы для интеграции. ## Начать пользоваться кошельком - [Создать или восстановить аккаунт](user/wallets.md), разобраться в криптосчетах и балансе кошелька. - [Получить, перевести или вывести средства](user/transfers.md), выбрать сеть и способ подписи. - [Оплатить покупку по QR или принять платёж](user/payments.md), отправить ссылку для получения. - [Использовать @имя, подарочные карты и донаты](user/features.md), настроить уведомления. - [Сохранить доступ к аккаунту](user/security.md) и понять, что работает без интернета. Для USDT важна сеть: перевод в Ethereum и перевод в TRON используют разные реквизиты. Перед подтверждением сверяйте актив, сеть, получателя и сумму. ## Подключить платежи для бизнеса Начните с [запроса чтения без движения денег](business/quick-start.md). Затем выберите нужную часть интеграции: - [Авторизация и API-ключи](business/authentication.md). - [Платежи, выплаты и проверка статуса](transactions/overview.md). - [Товары, платёжные ссылки и подписки](business/resources.md). - [Webhooks: подпись и обработка событий](business/webhooks.md). - [Формат сумм и идентификаторов](field_conventions.md), [ошибки и повторные запросы](business/errors.md). Набор бизнес-функций определяется [доступом аккаунта](business/capabilities.md). Успешный HTTP-ответ ещё не подтверждает оплату: результат проверяется по статусу исходной транзакции. ## Подключить ИИ к Heth.me [Подключите помощника через Heth MCP](ai/mcp.md) для работы со своим аккаунтом и доступными бизнес-функциями. Вы выбираете разрешения и подтверждаете каждую денежную операцию в Heth. В руководстве — подключение, переводы, бизнес-действия, OBS и отзыв доступа. Для разработчиков ИИ-интеграций доступны [схема документированной части API](/openapi.json), [индекс документации](/llms.txt) и [текст всех руководств](/llms-full.txt). Эти материалы описывают интерфейсы и правила; текущий баланс, права и результат операции нужно получать из API. ## Приложение и помощь [Открыть Heth.me](https://app.heth.me) · [Обратиться в поддержку](https://t.me/hethmesupport_bot) ## ru: Подписки и автоплатежи Source: https://docs.heth.me/markdown/ru/subscriptions.md --- title: Подписки и автоплатежи --- # Подписки и автоплатежи Магазин может запросить у пользователя Heth.me согласие на регулярные платежи. Плательщик проверяет и подписывает условия обычным разблокированным HethWallet. Отдельный вход по email или в Customer Portal не нужен. Платежи списываются с **баланса счёта Heth** в согласованных валюте и сети. ## Плательщику 1. Откройте **Настройки → Подписки и автоплатежи**. Новые запросы показаны отдельно от существующих подписок. 2. Откройте запрос и проверьте магазин, сумму одного платежа, валюту/сеть и период. Ссылка подтверждения открывает этот же экран. Заблокированный кошелёк запросит обычный PIN и вернёт к запросу. 3. Нажмите **Подтвердить подписку** или **Отклонить**. Открытие ссылки или получение уведомления не подтверждает подписку. 4. После согласия планируется первый платёж. В списке видны сумма, период и дата следующего списания; при повторной попытке после ошибки — время следующей попытки. 5. Отзовите подписку, чтобы остановить будущие списания. Отмена не возвращает уже выполненные платежи. Подтверждение записывает согласие и планирует платёж; оно не означает, что платёж уже прошёл. Проверяйте статус транзакции. В момент списания на балансе должно быть достаточно средств. ## Как узнать о новом запросе Если плательщик найден, сервер отправляет **«Запрос на подписку»** на зарегистрированные устройства со ссылкой `/subscriptions/confirm/?env=`. Запись также сохраняется под колоколом уведомлений, даже если ни одно устройство не может получить push. Ожидающие запросы доступны в **Настройки → Подписки и автоплатежи**. В установленной PWA используется web push. Приложение Heth.me для iOS и Android, начиная с версии 1.0.0 (сборка 5), использует системные уведомления. Включите уведомления в кошельке и разрешите их в настройках устройства. Нажатие на запрос подписки открывает экран подтверждения; заблокированный кошелёк сначала попросит обычный PIN или доступный ключ входа. Получение или открытие уведомления не означает согласия на подписку. Если уведомление не пришло, откройте список ожидающих запросов или ссылку подтверждения от магазина. ## Магазину В HethWallet откройте **Бизнес → Подписки и автоплатежи**. Укажите адрес кошелька плательщика, `@username` или номер карты Heth, название подписки, сумму одного платежа, валюту/сеть и период. Отправьте запрос и скопируйте ссылку подтверждения. Здесь же можно смотреть свои запросы и отменять их, пока плательщик ещё не дал согласие. Оператор должен включить подписки Heth для организации и настроить рабочий маршрут платежей. Создание запроса не даёт разрешения на списание. ## Создание запроса через API Используйте API-ключ магазина или его обычную партнёрскую Bearer-сессию. На `app.heth.me` организация определяется по домену. Ключ только для чтения не позволяет создавать и отменять запросы. ```bash curl -X POST 'https://app.heth.me/api/v1/heth/subscription-requests' \ -H "x-api-key: $HETH_API_KEY" \ -H 'Content-Type: application/json' \ -d '{ "request_id": "b56b2c66-4ae5-4cb9-92ea-7a3297b72b55", "payer": "@alice", "description": "Monthly membership", "amount": "1000000", "currency": "USDT", "network": "ETH", "interval": "monthly", "period": 1, "env": "prod" }' ``` | Поле | Описание | Тип | Пример | | --- | --- | --- | --- | | `request_id` | Уникальный идемпотентный UUID. При повторе того же запроса используйте его с неизменными условиями. | String | `b56b2c66-4ae5-4cb9-92ea-7a3297b72b55` | | `payer` | Адрес кошелька, имя пользователя или номер карты Heth. | String | `@alice` | | `description` | Название подписки: 1–250 символов без переносов строки. | String | `Monthly membership` | | `amount` | Положительное целое в минимальных единицах токена. Для USDT с 6 знаками `1000000` означает 1 USDT. | String | `1000000` | | `currency`, `network` | Включённая пара токен/сеть выбранного контура. Сети: `ETH`, `TRX`, `BASE`. | String | `USDT`, `ETH` | | `interval` | `daily`, `weekly`, `monthly` или `yearly`. | String | `monthly` | | `period` | Число интервалов от 1 до 365; по умолчанию 1. | Number | `1` | | `env` | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | String | `prod` | HTTP `201` возвращает сам запрос, включая `id`, `status`, `amount_decimals`, `confirm_url`, `expires_at`, `subscription_id` и `next_charge_at`. Запрос действует семь дней. Успешное создание не раскрывает существование указанного плательщика; прочитать и подтвердить запрос может только его адресат. ## Операции API Все пути ниже начинаются с `/api/v1`. Для операций магазина нужен его API-ключ или партнёрская Bearer-сессия. | Метод и путь | Назначение | | --- | --- | | `POST /heth/subscription-requests` | Создать запрос. | | `GET /heth/subscription-requests?env=prod&limit=50` | Получить запросы магазина в `data` и `total`. | | `POST /heth/subscription-requests/:id/cancel` | Отменить ожидающий запрос; тело `{"env":"prod"}`. | Для первой страницы не передавайте `page`. Для следующей укажите `page=1`, затем увеличивайте номер; `limit` задаёт размер страницы. Для операций кошелька нужна обычная Bearer-сессия кошелька плательщика. API-ключ магазина не может подтвердить подписку за плательщика. | Метод и путь | Назначение | | --- | --- | | `GET /heth/subscriptions?env=prod&limit=50` | Свои подписки в `data`/`total`, ожидающие запросы в `requests`/`requests_total`. | | `GET /heth/subscription-requests/:id?env=prod` | Прочитать адресованный запрос и каноническое сообщение `message` для подписи. | | `POST /heth/subscription-requests/:id/confirm` | Подтвердить с `{"signature":"","env":"prod"}` после проверки точных условий. | | `POST /heth/subscription-requests/:id/reject` | Отклонить; тело `{"env":"prod"}`. | | `POST /heth/subscriptions/:id/revoke-mandate` | Остановить будущие списания; тело `{"env":"prod"}`. | Подпись связывает магазин, плательщика, организацию, контур, описание, сумму и её масштаб, валюту/сеть, интервал и период, правило первого платежа, nonce и срок действия. Для изменения условий нужны новый запрос и новое согласие. Повтор подтверждения или запланированного платежа не может дважды списать средства за один период. Временные метки API без часового пояса означают UTC; приложение показывает местное время устройства. ## Статусы и ошибки Статусы запроса: `pending`, `signed`, `rejected`, `expired`. У подтверждённого запроса заполнен `subscription_id`. Фактическое выполнение платежей отслеживается через API транзакций и настроенные webhooks. `401` означает отсутствие или недействительность авторизации; `403` — выключенные подписки или API-ключ только для чтения. Недоступный запрос возвращает `404`. `422` означает неверные условия, повтор UUID с другими условиями, недействительную подпись или истёкший/закрытый запрос. Магазин не может изменить подписанные условия активной подписки без нового согласия плательщика. ## ru: Платёж через агрегатора (приём в пользу мерчанта) Source: https://docs.heth.me/markdown/ru/transactions/aggregator_payment.md --- title: Платёж через агрегатора (приём в пользу мерчанта) last_update: date: 2026-10-20 --- # Платёж через агрегатора (приём в пользу мерчанта) Пример: `"1000000"` — 1 USDT при decimals=6. Замените все заполнители проверенными реквизитами получателя и инструмента. Отправка запроса может привести к списанию реальных средств. Проверьте и явно разрешите операцию до отправки. См. [начало интеграции](../business/quick-start.md). Данный тип транзакции позволяет Платёжному Агрегатору принимать платежи Покупателей в пользу подключённого Мерчанта. Средства списываются с Плательщика и автоматически распределяются: Мерчант получает сумму за вычетом комиссии, Агрегатор получает свою комиссию. ## Бизнес-процесс 1. Мерчант обращается к Агрегатору и проходит онбординг. 2. Агрегатор просит Мерчанта создать кошелёк в системе heth.me и предоставить `wallet_id`. 3. Используя свой API-ключ, Агрегатор формирует транзакцию типа `payment`, указывая кошелёк мерчанта в `money_storage_merchant` и платёжные реквизиты покупателя в `money_storage`. 4. После успешной обработки балансы Плательщика, Мерчанта и Агрегатора обновляются единым действием. 5. Статус транзакции отслеживается стандартным методом получения транзакции (переопрос, авторизация тем же API-ключом). ## Пример запроса ```bash curl --location --request POST 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage_merchant": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "08", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Платёж", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## Описание полей | Поле | Описание | Тип | Пример | | ----- | -------- | :--- | ------- | | amount | Сумма транзакции (целое в минорных единицах, строкой) | String | 1000000 | | currency | Валюта транзакции (по умолчанию USDT) | String | USDT | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | String | prod | | type | Тип транзакции (payment) | String | payment | | route | Роут обработки (должен соответствовать настроенному маппингу) | String | hot_hot_ETH | | money_storage_merchant | Дескриптор кошелька мерчанта (получателя) | Object | | | > wallet_id | Идентификатор кошелька мерчанта | String | YOUR_WALLET_ID | | > network | Blockchain-сеть (TRX или ETH) | String | ETH | | > type | Тип взаимодействия (например p2p_proxy) | String | p2p_proxy | | > currency | Валюта зачисления мерчанту (по умолчанию USDT) | String | USDT | | money_storage | Дескриптор платёжного инструмента плательщика | Object | | | > network | Blockchain-сеть (TRX или ETH) | String | ETH | | > type | Тип инструмента (bank_card) | String | bank_card | | > currency | Валюта плательщика (по умолчанию USDT) | String | USDT | | > cardnumber | Номер виртуальной карты | String | YOUR_CARD_NUMBER | | > cvv | CVV виртуальной карты | String | YOUR_CVV | | > exp_month | Месяц окончания срока действия | String | 08 | | > exp_year | Год окончания срока действия | String | 2026 | | > cardholder | Имя держателя карты | String | John Doe | | description | Описание | String | Платёж | | txid | Идемпотентный идентификатор транзакции (строка) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## Примечания * Комиссия Агрегатора учитывается автоматически согласно настройкам API-ключа. * Значение `route` должно соответствовать активному маршруту для данного API-ключа. * Используйте уникальный (идемпотентный) `txid` для каждого бизнес-действия, чтобы исключить повторные списания при ретраях. * Статус получайте стандартным GET-запросом транзакции до достижения терминального состояния. ## ru: Получение статуса транзакции Source: https://docs.heth.me/markdown/ru/transactions/get_transaction.md --- title: Получение статуса транзакции last_update: date: 2026-10-20 --- # Получение статуса транзакции Метод возвращает актуальный статус конкретной транзакции по ее `id` с использованием API-ключа. ## Запрос ``` GET /api/v1/transactions/{transaction_id}?env=prod Заголовок: x-api-key: ``` `{transaction_id}` — внутренний `id` транзакции (UUID), передаётся как сегмент пути. ## Поля ответа | Поле | Описание | | ----- | -------- | | amount | Сумма (минорные единицы) | | amount_with_fee | Сумма с комиссией (минорные единицы) | | amount_dest | Сумма зачисления при конвертации (минорные единицы), если применимо | | currency | Валюта | | currency_dest | Валюта зачисления при конвертации, если применимо | | description | Описание транзакции | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | | error_description | Описание ошибки при `rejected` | | finished | Время завершения (ISO) | | id | Внутренний UUID транзакции | | route | Использованный маршрут обработки | | started | Время старта (ISO) | | status | Текущий статус (см. раздел «Статусы» в Глоссарии; created, charging, charged, refunded, rejected, failed) | | txid | Внешний идентификатор клиента | | type | Тип (payment / payout) | | widget_url | Ссылка на виджет (если применимо) | | simple_auth_redirect_url | Ссылка для доп. авторизации / 3DS | ## Пример ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## Рекомендации * Используйте экспоненциальный backoff при опросе. * Определяйте результат по `status`: наличие или отсутствие `finished` само по себе не подтверждает исход. * Значения `txid` делайте идемпотентными. ## Восстановление по внешнему идентификатору ```bash curl --get 'https://app.heth.me/api/v1/transactions/example-order-001' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'by=txid' \ --data-urlencode 'env=prod' ``` ## ru: Список транзакций Source: https://docs.heth.me/markdown/ru/transactions/list_transactions.md --- title: "Список транзакций" last_update: date: 2026-10-20 --- # Список транзакций Чтение транзакций собственного аккаунта. Ответ — объект с data и cursor, а не массив верхнего уровня. Ограничивайте период и явно указывайте окружение. См. [начало интеграции](../business/quick-start.md), [авторизацию](../business/authentication.md) и [обработку ошибок](../business/errors.md). ```http GET /api/v1/transactions?env=prod&order_by=started&limit=30 x-api-key: YOUR_API_KEY ``` ## Фильтры | Фильтр | Значение | | --- | --- | | `started_from / updated_from` | Начало периода ISO 8601 | | `started_to / updated_to` | Конец периода ISO 8601 | | `type` | Фильтр типа | | `status` | Фильтр статуса | | `txid` | Точная строка внешнего идентификатора | | `order_by` | started или updated | | `limit` | Размер порции: 1–500, по умолчанию 100 | | `env` | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | | `cursor` | Время из cursor_value ответа | ```json { "data": [ { "id": "c033ceaa-3726-4479-8be3-c9af8a0b2336", "txid": "example-order-001", "type": "payment", "status": "charged", "amount": "1000000", "currency": "USDT", "env": "prod", "started": "2026-10-01T10:00:00Z" } ], "cursor": { "cursor_field": "started", "cursor_value": "2026-10-01T10:00:00Z" } } ``` ## Следующая порция Передавайте cursor.cursor_value из ответа строковым query-параметром cursor, а не весь объект. Сохраняйте окружение, фильтры и order_by. При order_by=updated поле cursor_field может быть updated_at. Завершайте обход при пустом data или отсутствии продвигающегося курсора. При изменении записей сверяйте их по id транзакции. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'order_by=started' \ --data-urlencode 'limit=30' \ --data-urlencode 'cursor=2026-10-01T10:00:00Z' ``` ## ru: Транзакционный API Source: https://docs.heth.me/markdown/ru/transactions/overview.md --- title: "Транзакционный API" last_update: date: 2026-10-20 --- # Транзакционный API Выберите сценарий включённого маршрута аккаунта. В этих примерах используются виртуальные инструменты Heth; это не обещание приёма и выплат на любые внешние банковские карты. См. [начало интеграции](../business/quick-start.md), [авторизацию](../business/authentication.md) и [обработку ошибок](../business/errors.md). ## Создание - [Платёж виртуальной картой](pcn.md) - [Выплата на виртуальную карту](wcn.md) - [Выплата по идентификатору кошелька](wid.md) - [Агрегаторский платёж](aggregator_payment.md) ## Чтение - [Получить транзакцию](get_transaction.md) - [Список транзакций](list_transactions.md) ## Справочник - [Суммы, идентификаторы и статусы](../field_conventions.md) ## ru: Проведение платежа по номеру карты Source: https://docs.heth.me/markdown/ru/transactions/pcn.md --- title: Проведение платежа по номеру карты last_update: date: 2026-10-20 --- # Проведение платежа по номеру карты Пример: `"1000000"` — 1 USDT при decimals=6. Замените все заполнители проверенными реквизитами получателя и инструмента. Отправка запроса может привести к списанию реальных средств. Проверьте и явно разрешите операцию до отправки. См. [начало интеграции](../business/quick-start.md). Инициация платежа с использованием виртуальной карты. ## Пример запроса ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "10", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Платёж", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` | Поле | Значение | Тип | Пример | | ----- | ----- | :--- | ----- | | amount | Сумма транзакции (целое в минорных единицах, строкой) | Строка | 1000000 | | currency | Валюта транзакции (по умолчанию USDT) | Строка | USDT | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | Строка | prod | | type | Тип транзакции (в данном случае payment) | Строка | payment | | route | Роут транзакции (проставлять роуты необходимо в соответствии с маппингом роутов) | Строка | hot\_hot\_ETH | | money_storage | Дескриптор платёжного инструмента | Объект | | | \>network | Blockchain-сеть (TRX или ETH) | Строка | ETH | | \>type | Тип инструмента (bank_card) | Строка | bank_card | | \>currency | Валюта инструмента (по умолчанию USDT) | Строка | USDT | | \>cardnumber | Номер виртуальной карты | Строка | YOUR_CARD_NUMBER | | \>cvv | CVV виртуальной карты | Строка | YOUR_CVV | | \>exp_month | Месяц окончания срока | Строка | 10 | | \>exp_year | Год окончания срока | Строка | 2026 | | \>cardholder | Имя держателя карты | Строка | John Doe | | description | Описание транзакции | Строка | Платёж | | txid | Идемпотентный идентификатор транзакции (строка) | Строка | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## ru: Выплата по идентификатору кошелька Source: https://docs.heth.me/markdown/ru/transactions/pid.md --- title: "Выплата по идентификатору кошелька" last_update: date: 2026-10-20 --- # Выплата по идентификатору кошелька Эта страница относится к тому же сценарию, что и основной справочник выплаты по wallet_id. Используйте его запрос и описание полей. [Выплата по идентификатору кошелька](wid.md) ## ru: Агрегаторский платёж виртуальной картой Source: https://docs.heth.me/markdown/ru/transactions/rcn.md --- title: "Агрегаторский платёж виртуальной картой" last_update: date: 2026-10-20 --- # Агрегаторский платёж виртуальной картой Эта страница относится к тому же сценарию приёма в пользу продавца, что и основной справочник агрегаторского платежа. Используйте его запрос и определения. [Агрегаторский платёж виртуальной картой](aggregator_payment.md) ## ru: Выплата по номеру карты Source: https://docs.heth.me/markdown/ru/transactions/wcn.md --- title: Выплата по номеру карты last_update: date: 2026-10-20 --- # Выплата по номеру карты Пример: `"1000000"` — 1 USDT при decimals=6. Замените все заполнители проверенными реквизитами получателя и инструмента. Отправка запроса может привести к списанию реальных средств. Проверьте и явно разрешите операцию до отправки. См. [начало интеграции](../business/quick-start.md). Инициация выплаты на карту. ## Пример запроса ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER" }, "description": "Выплата", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` | Поле | Значение | Тип | Пример | | ----- | ----- | :--- | ----- | | amount | Сумма транзакции (целое в минорных единицах, строкой) | Строка | 1000000 | | currency | Валюта транзакции (по умолчанию USDT) | Строка | USDT | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | Строка | prod | | route | Роут транзакции (проставлять роуты необходимо в соответствии с маппингом роутов) | Строка | hot\_hot\_ETH | | type | Тип транзакции (в данном случае payout) | Строка | payout | | money\_storage | Объект с данными получателя | Объект | | | \>network | Blockchain-сеть транзакции (TRX или ETH) | Строка | ETH | | \>type | Тип инструмента (bank\_card) | Строка | bank\_card | | \>currency | Валюта получателя транзакции (по умолчанию USDT) | Строка | USDT | | \>cardnumber | Номер карты получателя | Строка | YOUR_CARD_NUMBER | | description | Описание транзакции | Строка | Выплата | | txid | Идемпотентный идентификатор транзакции (строка) | Строка | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## ru: Выплата по идентификатору Source: https://docs.heth.me/markdown/ru/transactions/wid.md --- title: Выплата по идентификатору last_update: date: 2026-10-20 --- # Выплата по идентификатору Пример: `"1000000"` — 1 USDT при decimals=6. Замените все заполнители проверенными реквизитами получателя и инструмента. Отправка запроса может привести к списанию реальных средств. Проверьте и явно разрешите операцию до отправки. См. [начало интеграции](../business/quick-start.md). Выплата на идентификатор кошелька (wallet_id). ## Пример запроса ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Платёж", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` | Поле | Значение | Тип | Пример | | ----- | ----- | :--- | ----- | | amount | Сумма транзакции (целое в минорных единицах, строкой) | Строка | 1000000 | | currency | Валюта транзакции (по умолчанию USDT) | Строка | USDT | | env | `prod` (по умолчанию). Сохраняйте это значение при открытии и подтверждении запроса. | Строка | prod | | route | Роут транзакции (проставлять роуты необходимо в соответствии с маппингом роутов) | Строка | hot\_hot\_ETH | | type | Тип транзакции (в данном случае payout) | Строка | payout | | money\_storage | Объект с данными получателя | Объект | | | \>wallet\_id | Идентификатор кошелька получателя | Строка | YOUR_WALLET_ID | | \>network | Blockchain-сеть транзакции (TRX или ETH) | Строка | ETH | | \>type | Тип транзакции в разрезе кошельков (в данном случае p2p\_proxy) | Строка | p2p\_proxy | | \>currency | Валюта получателя транзакции (по умолчанию USDT) | Строка | USDT | | description | Описание транзакции | Строка | Выплата | | txid | Идемпотентный идентификатор транзакции (строка) | Строка | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## ru: Дополнительные возможности аккаунта Source: https://docs.heth.me/markdown/ru/user/features.md --- title: "Дополнительные возможности аккаунта" last_update: date: 2026-10-21 --- # Дополнительные возможности аккаунта Набор функций зависит от настроек аккаунта. Описание ниже не означает, что каждая функция включена у всех пользователей. ## @имена В настройках имени проверьте доступность и цену регистрации. Выберите подходящий кошелёк оплаты и следуйте инструкции. Неоплаченная бронь ещё не является действующим именем получения. Перед оплатой проверьте срок и условия продления; просроченное или приостановленное имя может не разрешаться в реквизиты. Освобождение имени может быть недоступно, пока его платёж обрабатывается. ## Подарочные карты На экране подарочных карт можно посмотреть свои выпуски, подготовить доступный выпуск или погасить код. Выпуск финансируется из собственного подходящего кошелька и требует подтверждения. Сохраните показанный код безопасно: обладание кодом может позволять погашение. Вводите код погашения в Heth; номинал определяет сервер. Отправленный запрос ещё не подтверждает зачисление. ## Газ Покупка газа — отдельная операция с доступным источником оплаты. Проверьте счёт получения, сумму и сеть. Оплата с cold-счёта может требовать подписи. Газ блокчейна учитывается отдельно от суммы переводимого токена. ## Донаты Откройте страницу автора и проверьте площадку, автора, актив, сеть, минимум и комиссию. Выберите доступный кошелёк Heth или внешний счёт и проверьте операцию до подтверждения. Срок реквизитов внешнего перевода может истечь; перед отправкой проверьте их актуальность. Итоговая страница показывает статус исходного доната. ## Уведомления и webhooks 1. Откройте **Настройки → Уведомления**, включите переключатель и подтвердите запрос системы или браузера. Мобильное приложение использует системные уведомления; веб-версия — службу уведомлений браузера, если она поддерживается. 2. Если доступ запрещён, разрешите уведомления для Heth в настройках устройства или браузера, заново откройте Heth и повторите попытку. Доставка также зависит от связи и ограничений устройства. 3. Чтобы отключить уведомления на этом устройстве, выключите тот же переключатель. Это не отменяет платежи, подписки или подключения ИИ. Нажатие на платёжное уведомление открывает Heth. Разблокируйте аккаунт и проверьте запрошенное действие: само нажатие ничего не подписывает и не подтверждает платёж. Окончательный результат проверяйте в истории операций. В настройках webhook можно указать URL получения событий и секрет интеграции. По этому адресу передаются события аккаунта — используйте свой endpoint. См. [интеграцию webhook](../business/webhooks.md). ## Подписки, hardware и multisig Управляйте запросами подписки и разрешениями на будущие списания в Heth. В [руководстве по подпискам и автоплатежам](../subscriptions.md) описаны согласие плательщика, запросы продавца, даты платежей и отзыв разрешений. Привязка платёжной карты и разрешение будущих списаний требуют вашего явного согласия. Для аппаратного или multisig-аккаунта проверьте, что устройство и способ подписи поддерживают выбранную сеть, прежде чем переводить средства. В **Настройках → Акцепты подписок**, если функция доступна аккаунту, можно посмотреть свои криптовалютные подписочные акцепты и лимит одного списания. Выберите разрешение, нажмите **«Отозвать акцепт»** и подтвердите в Heth, чтобы остановить будущие списания. Отзыв не возвращает уже проведённые платежи. ## Виджет донатов для OBS Studio Добавьте виджет Heth в OBS Studio как источник «Браузер»: он показывает QR для получения, темы оформления и уведомления о входящих платежах. Подключение создаётся в **Настройки → OBS Studio** в Heth. Не публикуйте приватную ссылку подключения и не передавайте её ИИ. Помощник через MCP может читать ограниченную ленту событий и менять доступные параметры оформления; права доступа подтверждаются в Heth. [Руководство по OBS](./obs.md). ## ru: OBS Studio: QR для получения и уведомления о переводах Source: https://docs.heth.me/markdown/ru/user/obs.md --- title: "OBS Studio: QR для получения и уведомления о переводах" last_update: date: 2026-10-21 --- # OBS Studio: QR для получения и уведомления о переводах Виджет Heth добавляется в OBS Studio как источник **«Браузер»**. Он показывает QR для получения и уведомления о завершённых входящих переводах Heth. Устанавливать отдельный нативный плагин не нужно. Виджет не управляет сценами, записью и трансляцией. Входящий перевод сам по себе не означает донат конкретному автору или платформе. ![Предпросмотр обновлённого виджета на русском. Событие учебное; QR предпросмотра не открывает платёж.](/img/obs-preview-ru.png) Предпросмотр обновлённого виджета на русском. Событие учебное; QR предпросмотра не открывает платёж. ## Подключение 1. Откройте Heth и войдите в аккаунт, на который будете принимать донаты. 2. Перейдите в **Настройки → OBS Studio**. Получатель — ваш аккаунт Heth, в который выполнен вход. 3. Выберите доступную пару валюты и сети. При необходимости задайте предлагаемую сумму, подпись, тему и язык. Пустая сумма позволяет плательщику выбрать её самостоятельно. 4. Сохраните оформление. Нажмите **«Разрешить и создать подключение OBS»**, чтобы выдать отдельный ограниченный доступ виджету. 5. Скопируйте ссылку подключения. В OBS добавьте источник **«Браузер»** и вставьте ссылку. Начните с размера **900 × 500** пикселей; затем измените размер или обрежьте источник под свою сцену. 6. Считайте QR телефоном и проверьте получателя, валюту и сеть. Перед любым платежом проверьте экран подтверждения. Сам QR не списывает деньги. Фон прозрачный. Не перекрывайте QR и оставьте его достаточно крупным для считывания. Проверьте результат в самой сцене, в том числе в разрешении, которое получают зрители. Язык виджета — русский или английский — выбирается независимо от языка интерфейса Heth. ## Доступ и приватность Подключение использует отдельный API-ключ с ограниченными правами OBS. Heth создаёт его и добавляет в ссылку подключения: копировать ключ из раздела «Бизнес» не нужно. Настройки webhook работают независимо: webhook отправляет события на ваш сервер, а браузерный источник OBS сам читает ограниченную ленту виджета. Для стандартного виджета свой сервер приёма webhook не нужен. Ключ OBS относится к вашему аккаунту и позволяет читать его ленту виджета. Разрешения MCP выдаются отдельно; отзыв подключения OBS и отзыв подключения ИИ — отдельные действия. Ссылка подключения содержит секретный токен OBS во фрагменте после `#`. Считайте всю ссылку приватной: не размещайте её в описании трансляции, скриншотах, публичных экспортируемых сценах и переписке с ИИ. QR для зрителей содержит платёжные реквизиты, а не этот токен. Доступ OBS позволяет читать идентификатор получателя, оформление и ограниченную ленту входящих платежей. Он не открывает баланс и полную историю, не позволяет отправлять деньги и менять настройки. В **Настройках → OBS Studio** отзовите старое подключение, если ссылка раскрыта или больше не нужна. Новое подключение создаётся в Heth. ## Как работают уведомления Показываются входящие переводы со статусом `charged`. Ожидающие, неуспешные и исходящие операции исключены. Сумма берётся на стороне получателя с сохранённой точностью, без округления до целого токена. Если точность неизвестна, виджет не придумывает сумму. Новое подключение начинает с новых событий. Работающий браузерный источник может продолжить чтение с сохранённого курсора после короткого перерыва; окно восстановления ограничено 24 часами. Перезагрузка или пересоздание источника не заменяют выгрузку истории аккаунта. Проверяйте поступление и окончательные данные операции в [истории операций](./payments.md), независимо от уведомления в эфире. ## Управление через ИИ Подключённый через [MCP](../ai/mcp.md) помощник с нужными разрешениями может читать настройки виджета, просматривать ограниченную ленту событий и предлагать подключение. Обычное оформление меняется с подтверждением в клиенте ИИ. Уже подключённый виджет подхватывает сохранённое оформление автоматически, обычно в течение 30 секунд. Создание и отзыв доступа, а также смена аккаунта получателя требуют подтверждения в Heth. Помощник даёт ссылку на экран настройки Heth; секретную ссылку подключения OBS он не получает. Примеры запросов: «Сделай английскую подпись и минималистичную тему виджета OBS» или «Покажи последние входящие события моего виджета». MCP не даёт помощнику управление самой программой OBS Studio. ## Своя вёрстка и настройка с помощью ИИ {#custom-layout} Обычные настройки Heth не требуют доступа к исходникам. Для произвольной вёрстки сделайте свою копию открытого [Heth OBS widget](https://github.com/Heth-me/obs-widget) под лицензией MIT. В [руководстве для ИИ](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md) есть примеры запросов, карта файлов и инструкции по размещению. В репозитории есть инструкции по сборке и размещению. ИИ для работы с кодом, получив доступ к вашей копии проекта, сможет изменить макет, CSS, шрифты, цвета и вид уведомлений, затем проверить учебный предпросмотр и собрать проект. Секретная ссылка OBS и платёжные ключи для дизайна ему не нужны. Собственную сборку нужно разместить: наличие репозитория само по себе не обеспечивает получение платёжных событий. Heth MCP позволяет читать события и менять поддержанные настройки оформления Heth. Он не редактирует репозиторий, не собирает собственную версию и не выдаёт ИИ доступ к вашему хостингу. Для произвольной HTML/CSS-вёрстки измените открытый проект. Стандартным виджетом на стороне Heth можно пользоваться без самостоятельной сборки. ## Если что-то не работает **Вместо виджета открывается 404 Heth:** обновите Heth, проверьте адрес источника «Браузер» и откройте его снова. Если ошибка сохраняется, обратитесь в поддержку. Создавать новые ключи для устранения ошибки загрузки страницы не нужно. - **Нет пункта OBS в настройках:** обновите Heth и уточните доступ аккаунта у поддержки. Не вставляйте обычный API-ключ аккаунта в ссылку виджета. - **QR есть, уведомления нет:** убедитесь, что перевод завершён и получен этим аккаунтом. Браузерный источник должен оставаться активным и иметь доступ к сети. - **Доступ отключён:** подключите виджет заново в Heth. Повторные попытки с отозванной ссылкой не восстановят разрешение. - **Неверная валюта или сеть:** исправьте настройки в Heth, дождитесь обновления виджета и снова считайте QR перед приёмом платежей. - **Старая ссылка содержит `api_key=`:** подключитесь заново через «Настройки → OBS Studio». Храните старую ссылку приватно и отзовите ненужный ключ аккаунта. ## ru: Оплата и приём платежей Source: https://docs.heth.me/markdown/ru/user/payments.md --- title: "Оплата и приём платежей" last_update: date: 2026-10-20 --- # Оплата и приём платежей ## Оплатить через Heth Откройте экран оплаты и выберите доступный способ. QR плательщика может разрешать списание: показывайте его только выбранному продавцу. Если приложение запрашивает подтверждение суммы, проверьте продавца и сумму. Не передавайте продавцу или ИИ фразу восстановления и платёжный секрет. Приложение может показывать кэшированные данные или формировать некоторые коды плательщика без связи. Для обработки платежа продавцу нужен интернет; обычные переводы не исполняются офлайн. См. [границы офлайн-режима](security.md). ## Подтверждение суммы платежа Следуйте способу подтверждения, который Heth показывает для этого платежа: 1. Откройте свой QR плательщика и покажите только выбранному продавцу. 2. Проверьте запрошенную сумму и получателя до подтверждения. 3. Если Heth предлагает сформировать код, после показа QR вернитесь на экран подтверждения суммы, укажите сумму платежа и сформируйте текущий код. 4. Назовите этот код кассиру только для выбранного платежа. Это не фраза восстановления, PIN или постоянный платёжный секрет — их нужно хранить в тайне. 5. Если QR или код истёк, откройте свежий и следуйте текущей подсказке. Если подтверждение не настроено, завершите настройку в Heth при подключении к интернету. 6. Проверьте статус исходной операции. Показанный QR, сформированный код или запрос кассира сами по себе не доказывают оплату. ## Принять платёж Heth 1. Откройте **Бизнес**. 2. Введите сумму и выберите доступные актив и сеть. 3. Отсканируйте Heth QR плательщика и отправьте запрос. 4. При необходимости дождитесь подтверждения плательщика. 5. Считайте платёж принятым только при статусе `charged`. Отказ, ожидание и таймаут — разные результаты. Для проверки сохраняйте идентификатор исходной операции. ## Отправить ссылку для получения Экран платёжной ссылки формирует URL Heth с вашим идентификатором, валютой и необязательной суммой. Плательщик проверяет и подтверждает перевод. Отправка ссылки сама по себе денег не списывает. Такая ссылка отличается от управляемого бизнес-ресурса, созданного через API. Нельзя предполагать, что локально сформированная ссылка имеет серверный реестр, срок действия или отмену. ## Другие QR-провайдеры Используйте только включённые для аккаунта способы. Логотип провайдера или распознавание QR сканером не подтверждают доступность платёжного маршрута. При проблеме обратитесь в поддержку; не подменяйте получателя или сеть ради успешного платежа. ## ru: Защита аккаунта и работа без связи Source: https://docs.heth.me/markdown/ru/user/security.md --- title: "Защита аккаунта и работа без связи" last_update: date: 2026-10-21 --- # Защита аккаунта и работа без связи ## Восстановление и подпись Храните фразы восстановления и приватные ключи в кошельке владельца. PIN и биометрия защищают доступ на текущем устройстве, но не заменяют резервную копию. Не передавайте seed, приватный ключ и постоянный платёжный секрет поддержке, продавцу или ИИ. Одноразовый платёжный QR показывайте только выбранному продавцу. Если режим Б прямо предлагает назвать код кассиру, делайте это только после проверки конкретного платежа и его суммы. Перед подписью проверьте источник запроса, получателя, сумму, валюту и сеть. Подключение аккаунта, смена сети или открытие окна подписи сами по себе не завершают платёж. На аппаратном кошельке проверьте реквизиты также на устройстве. ## Face ID / Touch ID и ключи доступа В **Настройки → Face ID / Touch ID** включите биометрическую разблокировку, если этот пункт доступен, и подтвердите системный запрос. Для локальной разблокировки Heth использует учётные данные WebAuthn (passkey). Поддержка зависит от устройства и браузера; если биометрия недоступна или запрос отменён, используйте PIN. Это разблокировка Heth на текущем устройстве. Она не заменяет фразу восстановления, не восстанавливает аккаунт на другом устройстве и не подтверждает подключение ИИ или платёж. Перед сменой устройства или переустановкой Heth сохраните резервную копию для восстановления. ## Границы офлайн-режима Без связи можно видеть кэш балансов и истории, но эти сведения могут устареть. Некоторые коды плательщика формируются локально для продавца, подключённого к сети. Отправка перевода, загрузка текущего баланса и получение подтверждённого результата обработки требуют связи. После восстановления интернета обновите историю до повторения операции. ## Комиссии и помощь Проверяйте комиссию и сумму конкретной операции. Плата за газ блокчейна может учитываться отдельно от комиссии сервиса. Не переносите стоимость и сроки одного вида перевода на другой. Обратитесь в [поддержку Heth](https://t.me/hethmesupport_bot) с идентификатором транзакции и описанием проблемы, без секретов аккаунта. [Политика конфиденциальности](https://app.heth.me/settings/legal/privacy-policy) и [условия использования](https://app.heth.me/settings/legal/terms-of-service) доступны в Heth. [Проблемы с платежом и статус операции](troubleshooting.md). ## ru: Переводы и вывод средств Source: https://docs.heth.me/markdown/ru/user/transfers.md --- title: "Переводы и вывод средств" last_update: date: 2026-10-20 --- # Переводы и вывод средств Сначала выберите источник: баланс кошелька или криптосчёт. Затем укажите получателя, актив и сеть. Перед подтверждением проверьте сумму, реквизиты и комиссии. ## Виды переводов | Перевод | Действие пользователя | | --- | --- | | Кошелёк → кошелёк | Укажите идентификатор получателя или действующий @username, затем проверьте перевод | | Кошелёк → криптосчёт | Укажите внешний адрес и сеть; проверьте вывод и комиссии | | Криптосчёт → кошелёк | Выберите исходный счёт и кошелёк зачисления; подпишите подготовленную транзакцию | | Криптосчёт → криптосчёт | Проверьте внешний адрес и подпишите перевод кошельком владельца | Внутренний перевод и вывод в блокчейн отличаются обработкой и комиссиями. Для блокчейна может требоваться баланс нативной монеты на газ. Покупка газа — отдельная операция: проверьте источник оплаты и счёт получения. ## Внешние и аппаратные кошельки Для watch-only используйте внешний кошелёк, управляющий этим адресом. Подключённый аккаунт и сеть должны совпадать с источником перевода. Доступные способы подписи зависят от сети, браузера и устройства. Переход по ссылке во внешний кошелёк может не вернуть хеш транзакции в Heth: открытие другого кошелька не подтверждает оплату. ## Если результат неизвестен Откройте историю и проверьте исходную операцию. Не повторяйте перевод только из-за таймаута или потери связи. Сохраните идентификатор и обратитесь в поддержку, если статус остаётся неясным. Операцию в обработке нельзя считать завершённым платежом. [Проблемы с платежом и статус операции](troubleshooting.md). ## ru: Проблемы с платежом и статус операции Source: https://docs.heth.me/markdown/ru/user/troubleshooting.md --- title: "Проблемы с платежом и статус операции" description: "Как найти исходный платёж Heth, проверить незавершённую операцию и разобраться с сетью, балансом или подтверждением QR." last_update: date: 2026-10-20 --- # Проблемы с платежом и статус операции ## Экран завис: отправлять ещё раз? 1. Восстановите связь и откройте историю операций в том же аккаунте и контуре. 2. Найдите исходную операцию по идентификатору, времени, сумме и получателю. Откройте её подробности, если они доступны. 3. Проверьте текущий статус. Если операция ещё обрабатывается или не находится, обратитесь в поддержку до повторной отправки. Отсутствие результата не доказывает, что деньги не списаны. 4. Сохраните исходный идентификатор для дальнейшей проверки. Для API используйте [получение статуса](../transactions/get_transaction.md) и тот же исходный `txid`; не меняйте его ради обхода таймаута. | Статус | Что делать | | --- | --- | | `created`, `pending`, `processing` | Обработка не завершена. Обновите исходную операцию; не считайте платёж полученным | | `auth_required` | Откройте Heth и выполните запрошенное подтверждение этой операции | | `charged` | Операция проведена. Проверьте сумму, получателя и комиссию в подробностях | | `rejected`, `failed` | Прочитайте исходную ошибку и устраните её причину перед новой операцией | | Нет статуса или статус незнаком | Результат остаётся неподтверждённым; уточните его, не делая вывода об успехе или отказе | Возврат или обратная проводка — отдельный результат. Проверьте его по исходной операции и фактическому зачислению на баланс. Закрытие Heth не отменяет перевод в блокчейне. ## Не сходится баланс или реквизиты получения - Проверьте аккаунт, актив, сеть и контур. Внутренний Wallet и Crypto Account — разные получатели. - Обновите данные после восстановления связи: офлайн-экран может показывать кэш. - Для внешнего пополнения сравните адрес и сеть в отправляющем кошельке с реквизитами Heth. Перевод в другой сети автоматически не зачисляется на этот аккаунт. - Если на другом устройстве не появился дополнительный холодный аккаунт, подключите его исходный кошелёк. См. [аккаунты и резервные копии](wallets.md). ## Не работает QR плательщика или подтверждение суммы Откройте свежий QR плательщика в Heth. Если приложение запрашивает код подтверждения, следуйте [инструкции по оплате](payments.md), проверьте сумму и используйте текущий код. QR не является чеком. Для обработки продавцу нужна связь. Если приложение сообщает, что подтверждение не настроено, завершите настройку в Heth при подключении к интернету. ## Обращение в поддержку Передайте [поддержке Heth](https://t.me/hethmesupport_bot) идентификатор операции, примерное время с часовым поясом, актив и сеть, сумму и текст ошибки. Закройте посторонние персональные данные на скриншотах. Не прикладывайте фразу восстановления, приватный ключ, API-ключ, QR плательщика, код подарочной карты или постоянный платёжный секрет. ## ru: Начало работы и устройство кошельков Source: https://docs.heth.me/markdown/ru/user/wallets.md --- title: "Начало работы и устройство кошельков" last_update: date: 2026-10-20 --- # Начало работы и устройство кошельков Откройте [Heth.me](https://app.heth.me). Создайте фразу восстановления или восстановите существующий аккаунт, затем следуйте шагам приложения для настройки PIN и, если поддерживается, биометрии. До получения денег сохраните фразу восстановления отдельно. См. [защиту аккаунта](security.md). ## Криптосчёт и кошелёк | Объект | Что это | Как подтверждается перевод | | --- | --- | --- | | Криптосчёт (cold) | Адрес блокчейна, созданный или подключённый в приложении | Владелец подписывает перевод локальным, внешним или поддерживаемым аппаратным кошельком | | Кошелёк (hot) | Баланс аккаунта для внутренних платежей и переводов | Сервис исполняет авторизованную операцию | | Адрес для наблюдения (watch-only) | Адрес, добавленный без приватного ключа | Просмотр не даёт права расходования; нужен кошелёк владельца | Список дополнительных cold-счетов и их названия могут храниться на устройстве. Вход с другого устройства не обязательно восстановит все подключённые счета. Резервную копию каждого счёта сохраняйте в исходном кошельке. ## Получение денег 1. Откройте нужный криптосчёт или кошелёк. 2. Проверьте актив и сеть: USDT в Ethereum и USDT в TRON требуют разных реквизитов. 3. Используйте показанные реквизиты или QR. Адрес блокчейна и внутренний идентификатор кошелька не взаимозаменяемы. 4. Проверьте поступление в истории. Ожидающий баланс отличается от доступных средств. При покупке через внешнюю биржу проверьте сеть вывода. Страница обменников содержит ссылки на внешние сервисы; доступность и условия определяет их поставщик. ## Доступные активы Используйте активы, показанные вашему аккаунту. В общем реестре могут быть токены, не включённые в интерфейсе или для конкретной операции. ## de: Einen KI-Assistenten verbinden Source: https://docs.heth.me/markdown/de/ai/mcp.md --- title: "Einen KI-Assistenten verbinden" last_update: date: 2026-10-21 --- # Einen KI-Assistenten verbinden Heth MCP gewährt einem Assistenten begrenzten Zugriff auf Ihr eigenes Konto einschließlich der verfügbaren Geschäftsfunktionen. Plattformadministration ist ausgeschlossen. Das Öffnen einer Seite erteilt keine Berechtigung. ## Assistenten verbinden 1. Öffnen Sie in der Heth-App mit Ihrem bereits geöffneten Wallet **Einstellungen → KI-Verbindungen** und erstellen Sie einen Verbindungscode. Der Einmalcode gehört genau zu diesem Konto und gilt fünf Minuten. 2. Fügen Sie im KI-Client `https://mcp.heth.me/mcp` hinzu, wählen Sie OAuth und starten Sie die Verbindung. 3. Geben Sie im Verbindungsfenster nur den Code aus Heth ein. Eine Wallet-Anmeldung in diesem Browser ist nicht nötig. Der Code adressiert die Anfrage an das Konto, das ihn erstellt hat; er gewährt keinen Zugriff. 4. Öffnen Sie die Push-Nachricht in Heth. Ohne Push finden Sie die Anfrage unter **Einstellungen → KI-Verbindungen → Verbindungsanfragen**. Vergleichen Sie den **Prüfcode der Anfrage** mit dem Verbindungsfenster. Prüfen Sie Konto, Client-Kennung und Dienstadresse; ein Anwendungsname allein beweist keine Identität. 5. Wählen Sie in Heth nur die gewünschten Berechtigungen und bestätigen oder verweigern Sie den Zugriff. Das Öffnen einer Push-Nachricht bestätigt nichts. 6. Kehren Sie zum KI-Client zurück. Das Verbindungsfenster beendet den Vorgang automatisch nach Ihrer Entscheidung. Wallet-Sitzung und Signaturschlüssel bleiben in Heth. Ein benutzter oder abgelaufener Code funktioniert nicht erneut. Erstellen Sie einen neuen Code in Heth; er ersetzt den vorherigen unbenutzten Code. Eine abgelaufene Verbindungsanfrage muss im KI-Client neu gestartet werden. ### In ChatGPT Öffnen Sie **Plugins → Add → Add custom MCP server**, geben Sie einen Namen wie Heth.me und die obige Serveradresse ein und lassen Sie **OAuth** ausgewählt. ChatGPT erkennt die Einstellungen automatisch. Wallet-API-Schlüssel, Client-Secret und Wiederherstellungsphrase sind nicht erforderlich. Erstellen Sie das persönliche Plugin, wählen Sie **Connect Heth.me** und folgen Sie den Schritten mit Code und Push. Standardberechtigungen können unter **Advanced OAuth settings** gewählt werden; die endgültige Zustimmung erfolgt in der Heth-App. Wählen Sie anschließend Heth.me im Chat und fragen Sie etwa: „Zeige meine Wallet-Salden über Heth.“ Die Werkzeuge hängen von den genehmigten Berechtigungen ab. ## Berechtigungen und Werkzeuge Nur angefragte und aktuell für Ihr Konto verfügbare Rechte können genehmigt werden. Werkzeuge werden entsprechend diesen Rechten angeboten. Die Tabelle beschreibt Werkzeuge zum Lesen von Kontodaten und zur OBS-Konfiguration. | Berechtigung | Werkzeuge und Zweck | | --- | --- | | `heth:wallets:read` | `get_wallet_balances`: eigene Wallet-Salden | | `heth:transactions:read` | `list_transactions`, `get_transaction`: eigener Verlauf und ursprünglicher Transaktionsstatus | | `heth:business:read` | `list_products`, `list_business_payment_links`, `list_business_subscriptions`: eigene Produkte, verwaltete Zahlungslinks und Händlerabonnements; `get_business_subscription`, `list_business_subscription_requests`: einzelne Vereinbarungen und ausgehende Anfragen | | `heth:payments:prepare` | `prepare_transfer`, `get_transfer_request`: Überweisung zur Bestätigung in Heth vorbereiten und Originalergebnis prüfen | | `heth:business:manage` | `create_business_product`, `update_business_product`, `delete_business_product`; `create_business_payment_link`, `update_business_payment_link`, `delete_business_payment_link`: normale Änderungen nach Bestätigung im KI-Client | | `heth:business:manage` | `request_business_subscription`: Zustimmung des Zahlers in Heth anfordern; `prepare_business_subscription_change`: Pause, Fortsetzung oder Kündigung in Heth prüfen | | `heth:obs:read` | `get_obs_widget`, `list_obs_events`: Einstellungen und eingehende Ereignisse | | `heth:obs:configure` | `prepare_obs_connection`, `update_obs_widget`: Link zur Freigabe in Heth oder Darstellung mit Bestätigung im KI-Client | `prepare_obs_connection` erteilt keine Freigabe und liefert kein OBS-Token. Darstellungsänderungen können Währung, Netzwerk, Empfänger, Schlüssel und Zugriffsrechte nicht ändern. Siehe [OBS einrichten und anpassen](../user/obs.md), einschließlich Quellcode und Anleitung für Programmierassistenten. ## Gültigkeit und Widerruf Die Verbindungserlaubnis gilt **bis zu Ihrem Widerruf**. Technische Tokens laufen separat ab: MCP-Zugriffstokens nach 15 Minuten; Refresh-Tokens werden bei Erneuerung ersetzt und laufen nach 30 Tagen ohne Erneuerung ab. Danach kann eine neue Anmeldung nötig sein, obwohl die Zustimmung noch gespeichert ist. Jede Anfrage prüft die aktuelle Zustimmung und Kontorechte. Heth verwendet für API-Aufrufe ein separates beschränktes Token mit höchstens 60 Sekunden Gültigkeit; die vollständige Wallet-Sitzung wird nicht an MCP weitergegeben. Widerruf und entzogene Rechte sperren folgende Anfragen auch mit noch gültigen Tokens. Bereits übermittelte Daten lassen sich nicht zurückholen. Öffnen Sie in Heth **Einstellungen → KI-Verbindungen**, prüfen Sie Client-Kennung, Dienstadresse, Rechte und Status. Widerrufen Sie den KI-Zugriff und bestätigen Sie dies in Heth. Abgeschlossene Zahlungen und Einzugsermächtigungen für Abonnements werden dadurch nicht aufgehoben; verwalten Sie diese separat in den [Abonnementeinstellungen](../user/features.md). Falls eine neue Verbindung verlangt wird, starten Sie die Autorisierung im KI-Client erneut. Widerruf, abgelaufene Tokens, entzogene Rechte oder ein erneut verwendetes Refresh-Token können den Zugriff beenden. Geben Sie dem Assistenten keine Wiederherstellungsphrase, Wallet-Schlüssel oder Browser-Sitzungsdaten. Ein nicht erreichbarer Dienst ist ein Fehler, kein leeres Konto und keine erfolgreiche Freigabe. ## Zahlungen und Änderungen Heth verlangt **eine separate Bestätigung jeder Geldoperation in Heth**. Die Verbindungserlaubnis erlaubt keine automatischen Abbuchungen. Gewöhnliche Produkt- und Zahlungslinkänderungen benötigen eine Bestätigung im KI-Client. Rechte, Auszahlungsempfänger und Ermächtigungen für künftige Abbuchungen benötigen Heth-Bestätigung. OBS-Darstellung folgt der Client-Bestätigung. Eine Werkzeugannotation belegt keine tatsächlich eingeholte Zustimmung. Sie können auch die [Heth-Anwendung](https://app.heth.me) oder eine unterstützte [API-Integration](../business/quick-start.md) verwenden. ## Überweisung mit einem Assistenten 1. Geben Sie Art, Empfänger, Währung, Netzwerk und Betrag an. `hot_hot` überweist zwischen internen Konten, `hot_cold` an eine Blockchain-Adresse, `cold_hot` von der Blockchain auf Ihr eigenes internes Konto und `cold_cold` zwischen Blockchain-Adressen. Bei `cold_hot` ist der Empfänger `self`. 2. `prepare_transfer` speichert die Bedingungen und liefert einen Heth-Prüflink. Dabei entsteht keine Zahlung. Betrag und `max_debit` sind exakte Ganzzahlzeichenfolgen in den kleinsten Token-Einheiten. `max_debit` begrenzt den Token-Abgang einschließlich Plattformgebühren. Bei Blockchain-Quellen begrenzt `max_network_fee` die Gasgebühr in wei (ETH/Base) oder sun (TRON). Base kann zusätzlich eine L1-Datengebühr berechnen. 3. Prüfen Sie in Heth Konto, KI-Client, Empfänger, Quelle, Betrag, Netzwerk und Gebührenlimits. Wählen Sie erst dann **Confirm and send in Heth**. Das Öffnen eines Links bestätigt oder sendet nichts. Anfragen gelten 15 Minuten. 4. Heth signiert den angezeigten Auftrag und verwendet den normalen Überweisungsablauf. Blockchain-Transaktionen werden auf Ihrem Gerät oder einem angeschlossenen Signiergerät signiert. Öffnen Sie Heth auf einem Gerät, das für die Quelle signieren kann. Der Assistent erhält keine privaten Schlüssel. 5. Mit `get_transfer_request` prüft der Assistent die ursprüngliche Transaktion. Bestätigt oder in Bearbeitung bedeutet noch nicht bezahlt. Prüfen Sie nach einem Timeout zuerst das Originalergebnis. Wiederholen Sie eine Vorbereitung nur mit derselben `request_id` und identischen Bedingungen; erstellen Sie keine zweite Überweisung zur Klärung der ersten. Ein Widerruf verhindert den Start neuer Überweisungen. Eine bereits zur Ausführung angenommene Transaktion kann noch abgeschlossen werden; der Widerruf einer KI-Verbindung storniert keine angenommene Blockchain-Transaktion. ## Produkte, Links und Abonnements Normale Produkt- und Zahlungslink-Änderungen werden im KI-Client bestätigt. Preise und Linkbeträge sind Ganzzahlzeichenfolgen in kleinsten Währungseinheiten; Produktmengen sind positive ganze Zahlen. Eine stabile `request_id` verhindert doppelte Änderungen bei Wiederholungen. Diese Werkzeuge ändern weder Zahlungsrouting noch Auszahlungsempfänger, Schlüssel oder Zugriffsrechte. Das Löschen eines Links oder Produkts erstattet keine frühere Zahlung. `request_business_subscription` erstellt eine Anfrage, die der Zahler in Heth prüft. Die Anfrage allein erteilt keine Berechtigung für künftige Belastungen und erzeugt keine Zahlung. Vor der Signatur prüft der Zahler Betrag, Rhythmus und erste Belastung. `list_business_subscription_requests` zeigt Anfragen; `get_business_subscription` und `list_business_subscriptions` zeigen bestehende Vereinbarungen. `prepare_business_subscription_change` öffnet die Prüfung einer Pause, Fortsetzung oder Kündigung in Heth. Erst die Bestätigung des Inhabers ändert die Vereinbarung. Eine Fortsetzung erlaubt geplante Belastungen im Rahmen der bestehenden Zahlungsberechtigung. Eine Kündigung stoppt künftige Belastungen und erstattet keine abgeschlossenen Zahlungen. Neue Abrechnungsbedingungen erfordern eine neue Zustimmung des Zahlers. ## de: Authentifizierung und API-Schlüssel Source: https://docs.heth.me/markdown/de/business/authentication.md --- title: "Authentifizierung und API-Schlüssel" last_update: date: 2026-10-20 --- # Authentifizierung und API-Schlüssel Die folgenden Menünamen beziehen sich auf die englische App-Oberfläche. Die Sprache dieser Anleitung und die verfügbaren App-Sprachen können sich unterscheiden. ## Schlüssel ausstellen und widerrufen 1. Bei [Heth](https://app.heth.me) anmelden und **Business** öffnen. 2. Über **Connect** zur Integration wechseln. 3. In **API integration** mit **+** einen Schlüssel erstellen. 4. Schlüssel als Geheimnis der serverseitigen Integration speichern. 5. Zum Widerruf den Schlüsseleintrag entfernen. Bei Ersatz die Integration aktualisieren. Verwenden Sie keine Schlüssel aus Screenshots oder Dokumentationsbeispielen. Hier stehen Platzhalter statt nutzbarer Zugangsdaten. ## Anfrage-Header | Header | Verwendung | | --- | --- | | `x-api-key` | Erforderlich für Schlüssel-Authentifizierung | | `Content-Type: application/json` | Erforderlich bei JSON-Übermittlung | Bei `https://app.heth.me` stellt das Heth-Gateway den Organisationskontext bereit. Dies gilt für diesen Host, nicht automatisch für andere Plattform-URLs. Der Schlüssel ist an Konto und Berechtigungen gebunden. ## Schlüssel und Nutzersitzungen Die Transaktionsintegration akzeptiert API-Schlüssel. Interaktive Wallet-Funktionen können die Bearer-Sitzung des Nutzers verlangen; ein Schlüssel eröffnet nicht automatisch Wallets, Profil, @Namen und alle Geschäftsfunktionen. Kundensitzungen für Abonnements sind eine weitere Autorisierungsart. Ersetzen Sie keine Tokenarten gegeneinander und hinterlegen Sie keinen Seed in einer Integration. Siehe [Funktionen](capabilities.md) und [Fehler](errors.md). Fordern Sie nur benötigten Zugriff an. ## de: Geschäftsfunktionen und Verfügbarkeit Source: https://docs.heth.me/markdown/de/business/capabilities.md --- title: "Geschäftsfunktionen und Verfügbarkeit" last_update: date: 2026-10-20 --- # Geschäftsfunktionen und Verfügbarkeit Verwenden Sie nur für Ihr Konto aktivierte Funktionen. Ein Plattform-Endpunkt garantiert keine Verfügbarkeit für Konto, Netzwerk und Route. | Funktion | Integrationsgrenze | | --- | --- | | Zahlungen und Auszahlungen | Transaktions-API, konfigurierte Route, zulässiges Instrument und Umgebung | | Heth-Empfangslink | In der App erzeugte URL; Teilen erzeugt keine Abbuchung | | Verwaltete Zahlungslinks und Produkte | Separate Geschäftsressourcen mit Kontoberechtigung | | Händler-Abonnements | Rechnungen an Kunden mit unterstütztem Zahlungsmittel und Kundenzustimmung | | Eigene Abbuchungsmandate des Zahlers | Separate Kundenautorisierung und ausdrückliche Bestätigung oder Widerruf | | Erstattung oder Stornierung | Nur bei Unterstützung der ursprünglichen Zahlung; Blockchain-Transfers sind nicht beliebig umkehrbar | | Wallets, @Namen, Geschenkkarten, Webhooks | Nutzersitzung und zusätzliche Bestätigung können erforderlich sein | | Spenden | Plattform-/Autorenablauf mit eigenem Empfänger, Mindestbetrag, Gebühr und Ablauf | Das Tokenregister liefert Konfiguration, keine Zahlungsberechtigung für jeden Token. Prüfen Sie Token, Netzwerk und wirksame Kontokonfiguration. USDT/ETH und USDT/TRX sind nicht austauschbar. ## Grenzen der Referenz Die [Transaktionsreferenz](../transactions/overview.md) beschreibt dokumentierte Anfrageformate. Beschaffen Sie zur Fehlerbehebung keine Betreiberrechte und ändern Sie keine Terminals oder Routen. Geben Sie dem Support bei einer fehlenden Route die Transaktions-ID. Die [Anleitung zur KI-Verbindung](../ai/mcp.md) erklärt Berechtigungen und Bestätigungen für die verfügbaren Kontofunktionen. ## de: Fehler, Status und Wiederholungen Source: https://docs.heth.me/markdown/de/business/errors.md --- title: "Fehler, Status und Wiederholungen" last_update: date: 2026-10-20 --- # Fehler, Status und Wiederholungen Prüfen Sie HTTP-Ergebnis und Transaktions-`status`. Auch 200 oder 201 kann eine abgelehnte oder ausstehende Transaktion enthalten. | HTTP-Ergebnis | Vorgehen | | --- | --- | | 400 / 422 | Felder, Typen, Betragsskalierung, Umgebung und Empfänger prüfen; unverändert ungültige Anfragen nicht endlos wiederholen | | 401 | Zugangsdaten, Gültigkeit und API-Host prüfen | | 403 | Konto oder Schlüssel hat keine Berechtigung; Konto oder Umgebung nicht automatisch wechseln | | 404 | ID und Kontokontext prüfen; beweist nicht das Fehlen einer Ressource in einem anderen Konto | | 409 | Konflikt prüfen und ursprüngliche Operation wiederherstellen | | 429 | `Retry-After` beachten, falls vorhanden; Lesezugriffe mit begrenztem Backoff wiederholen | | Timeout / 5xx | Ergebnis möglicherweise unbekannt; ursprüngliche Operation über `id` oder `txid` prüfen | Fehlerformate können je Endpunkt abweichen. Verwenden Sie dokumentierte maschinenlesbare Fehlercodes, falls vorhanden. `error_description` ist kein stabiler Code. Entfernen Sie Zugangsdaten und Zahlungsinstrumentdaten aus Logs. ## Transaktionsergebnisse - `charged`: erfolgreich abgeschlossen. - `rejected` oder `failed`: Grund und Originaloperation prüfen; kein Erfolg. - `refunded` oder `reversed`: anderes Ergebnis als eine neu abgeschlossene Zahlung. - Ausstehend, Aktion erforderlich oder unbekannter Status: Zustand und Nutzeraktion anzeigen. Weder unbekannter Status noch Zeitstempel beweisen Erfolg. Prüfen Sie über [GET Transaktion](../transactions/get_transaction.md). Gleiche Geschäftsanweisung behält bei Wiederholung dieselbe `txid`. Webhook-Zustellfehler und Zahlungsfehler sind verschiedene Ereignisse. ## de: API-Integration beginnen Source: https://docs.heth.me/markdown/de/business/quick-start.md --- title: "API-Integration beginnen" last_update: date: 2026-10-20 --- # API-Integration beginnen Verwenden Sie einen Schlüssel Ihres eigenen Heth-Kontos. Lesen Sie [Authentifizierung](authentication.md), [Beträge und Status](../field_conventions.md) sowie [Geschäftsfunktionen](capabilities.md). ## Zugang ohne Geldbewegung prüfen Speichern Sie `HETH_API_KEY` im Geheimnisspeicher Ihrer Integration, nicht im Quellcode, Browser-Bundle, URL oder KI-Chat. Diese Anfrage liest Kontotransaktionen, ohne Geld zu bewegen. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'limit=10' \ --data-urlencode 'order_by=started' ``` Ein leeres `data`-Array ist gültig. Bei 401 oder 403 prüfen Sie Anmeldung und Kontoberechtigungen. ## Erste Zahlung 1. Prüfen Sie die für Ihr Konto freigeschalteten Zahlungswege und beschaffen Sie die Empfänger- oder Zahlungsinstrumentdaten. 2. Wählen Sie das passende [Transaktionsbeispiel](../transactions/overview.md) und ersetzen Sie alle Platzhalter durch geprüfte Angaben zu Ihrer Operation. 3. Kleinen Betrag nutzen: bei USDT mit sechs Dezimalstellen bedeutet `"1000000"` 1 USDT. 4. Eindeutige `txid` vor der Übermittlung erzeugen und speichern. 5. Einmal senden, zurückgegebene `id` speichern und [Status prüfen](../transactions/get_transaction.md). 6. Bei Timeout ursprüngliche `txid` nachschlagen oder identische Anfrage mit derselben ID wiederholen. Keine Ersatz-ID erzeugen. Das Absenden eines Zahlungsauftrags kann echtes Geld bewegen. Prüfen Sie vorher Empfänger, Betrag, Währung, Netzwerk und Gebühren. Ein API-Schlüssel erlaubt nur die für sein Konto freigeschalteten Operationen. ## de: Produkte, verwaltete Links und Abonnements Source: https://docs.heth.me/markdown/de/business/resources.md --- title: "Produkte, verwaltete Links und Abonnements" last_update: date: 2026-10-20 --- # Produkte, verwaltete Links und Abonnements Diese Geschäftsressourcen gehören dem Konto. Erforderlich sind API-Schlüssel oder Partner-Bearer und die freigeschalteten Funktionen. Ein Schlüssel aktiviert keine Zahlungsroute. Siehe [Authentifizierung](authentication.md). Bei Lesen und Löschen ist env ein Query-Filter. Bei Erstellen und Ändern von Produkten/Links gehört env in den JSON-Body. Der Eigentümer folgt aus dem Zugang; keine fremde partner_id senden. Ressourcenpreise können endpunktspezifische Integer-Typen haben; amount der Transaktions-API bleibt ein exakter Integer-String. ## Produkte ```http GET /api/v1/products?env=prod&limit=10 GET /api/v1/products/{id}?env=prod POST /api/v1/products PUT /api/v1/products/{id} DELETE /api/v1/products/{id}?env=prod ``` Ein Produkt definiert header, text, price, qty und currency und ist selbst keine Zahlung. Listen liefern data/total, Produktdetails und Erstellung data. Der Beispielpreis ist 1 USDT bei decimals=6. ```json { "env": "prod", "header": "Example item", "text": "Example item", "price": 1000000, "qty": "1", "currency": "USDT" } ``` ## Verwaltete Zahlungslinks ```http GET /api/v1/links?env=prod&limit=10 POST /api/v1/links PUT /api/v1/links/{id} DELETE /api/v1/links/{id}?env=prod ``` Links sind eigene Serverressourcen mit Betrag, Zahlungskonfiguration und optionalen Produkten. Verwenden Sie zurückgegebene URL-/Formulardaten, keine erfundene URL. Der lokal erzeugte Heth-Empfangslink ist ein anderes Objekt. Linklöschung erstattet keine abgeschlossene Zahlung. ## Händler-Abonnements ```http GET /api/v1/recurrents?env=prod&limit=10 GET /api/v1/recurrents/{id}?env=prod POST /api/v1/recurrents PUT /api/v1/recurrents/{id} POST /api/v1/recurrents/{id}/pause POST /api/v1/recurrents/{id}/resume POST /api/v1/recurrents/{id}/cancel ``` Ein Abonnement basiert auf einer erfolgreichen Initialzahlung des Kontos. POST /recurrents erwartet payment_id und recurrent. interval akzeptiert daily, weekly, monthly oder yearly; period zählt Intervalle. Die Umgebung wird von der Initialzahlung übernommen. Der Zahler muss Zahlungsmethode und wiederkehrende Abbuchungen erlauben. Ein erstellter Datensatz beweist kein nutzbares Mandat. Lebenszyklus: `POST /recurrents/{id}/pause`, /resume und /cancel. Status prüfen; Stornierung künftiger Abbuchungen erstattet keine früheren. Eigene Krypto-Mandate verwaltet der Heth-Zahler mit seiner Wallet-Sitzung unter Einstellungen → Subscription mandates, sofern aktiviert. Dies ist von Händler-Abonnements getrennt. ## de: Webhook-Integration Source: https://docs.heth.me/markdown/de/business/webhooks.md --- title: "Webhook-Integration" last_update: date: 2026-10-20 --- # Webhook-Integration Ein Webhook meldet Kontoereignisse an Ihre Empfangs-URL. Prüfen Sie den maßgeblichen Zustand über [GET Transaktion](../transactions/get_transaction.md). ## Empfänger einrichten Hinterlegen Sie in Heth eine eigene URL und das Integrationsgeheimnis und aktivieren Sie die Zustellung. Eine URL-Änderung ändert den Empfänger der Kontoereignisse. Schützen Sie den Endpunkt und vermeiden Sie Weiterleitungen an Dritte. Die Konfiguration verlangt eine Nutzersitzung; der Transaktionsschlüssel genügt nicht automatisch. ## Mitteilungen verarbeiten 1. Kontosignatur und Wiederholungsschutz wie unten beschrieben prüfen. 2. Ereignis-/Transaktions-ID ohne sensible Felder protokollieren. 3. Idempotent verarbeiten: doppelte oder verspätete Zustellung erzeugt keine weitere Zahlung. 4. Transaktion mit eigenen Zugangsdaten abrufen und Status abgleichen. 5. Die im Zustellvertrag geforderte Antwort senden. Browser-Push ist kein Webhook und garantiert keine Zustellung. Diese Übersicht verspricht weder Reihenfolge noch Wiederholungsintervalle noch einen gemeinsamen Authentifizierungsstandard. Klären Sie den tatsächlichen Zustellvertrag vor Produktionsautomatisierung. ## Format des Konto-Webhooks Dieses Format gilt für die in Heth konfigurierten Konto-Webhooks. Andere Callbacks können abweichen. Bei gesetztem Geheimnis enthalten Anfragen x-webhook-signature (hex HMAC-SHA256), x-webhook-timestamp (Unix-Sekunden) und x-webhook-event-id. HMAC über timestamp + "." + die unveränderten HTTP-Body-Bytes mit dem Geheimnis prüfen; JSON vorher nicht neu serialisieren. Body-Zeitstempel mit Header vergleichen, mehr als 5 Minuten Zeitabweichung ablehnen, Signatur zeitkonstant vergleichen und event_id deduplizieren. Wiederholungen behalten event_id und erhalten neuen Zeitstempel/Signatur. Ohne Geheimnis können Signaturheader fehlen; vor Automatisierung Geheimnis einrichten. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` Der Umschlag enthält event_id, timestamp, type und data. Transaktionsdaten enthalten tx_id, txid, type, status, amount, currency und event_type. amount kann ein JSON-Integer sein: verlustfrei parsen. Bei Spenden kann donation hinzukommen. Nach Prüfung und Speicherung HTTP 2xx zurückgeben; wiederholte geprüfte event_id darf keine erneute Geschäftsanweisung auslösen. Transaktion trotzdem per GET prüfen. ## de: Feldkonventionen & Glossar Source: https://docs.heth.me/markdown/de/field_conventions.md --- title: Feldkonventionen & Glossar last_update: date: 2026-10-20 --- # Feldkonventionen & Glossar ## Anfrage-Header | Header | Erforderlich | Definition | | ------ | ------------ | ---------- | | x-api-key | Ja | In der App ("Business") ausgestellter API-Key. Die Organisation wird anhand des Anfrage-Hosts ermittelt | | Content-Type | Ja (POST) | `application/json` für Erstellungsanfragen | ## Betrag & Währung | Begriff | Definition | | ------- | ---------- | | amount | String einer Ganzzahl in kleinsten Einheiten | | amount_with_fee | Betrag inkl. Gebühr | | currency | Währungs-/Token-Code (USDT) | | currency_dest | Zielwährung für Konvertierung (FX). Optional; Standard ist currency | ## Bezeichner | Begriff | Definition | | ------- | ---------- | | id | Interne Transaktions-UUID | | txid | Vom Client gesetzter String für eine Geschäftsanweisung; UUID ist praktisch, aber nicht vorgeschrieben | ## Routing & Umgebung | Begriff | Definition | | ------- | ---------- | | route | Verarbeitungsalias (konfiguriert für API-Key) | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | ## Status | Status | Bedeutung | | ------ | --------- | | created | Angenommen, wartet | | new | Anfangszustand vor Verarbeitungsbeginn | | authorizing | Autorisierung läuft | | pre_authorized_3ds | Wartet auf 3DS-Authentifizierung | | action_required | Zusätzliche Aktion erforderlich (3DS / weitere Autorisierung) | | charging | In Verarbeitung | | payment_suspended | Eingehende Transaktion vorübergehend ausgesetzt | | payout_suspended | Ausgehende Transaktion vorübergehend ausgesetzt | | charged | Erfolgreich abgeschlossen (terminal) | | reversed | Buchung storniert (terminal) | | refunded | Erstattet (terminal) | | rejected | Abgelehnt (terminal) | | failed | Fehlgeschlagen (terminal) | Terminale Status: `charged`, `reversed`, `refunded`, `rejected`, `failed`. Typischer Happy-Path: `created → charging → charged`. ## Zeitfelder | Feld | Bedeutung | | ---- | --------- | | started | Startzeit (ISO) | | finished | Abschlusszeit (ISO) | ## money_storage Felder | Feld | Bedeutung | | ---- | --------- | | network | Blockchain-Netzwerk | | type | Instrumenttyp | | wallet_id | Wallet-ID | | cardnumber | Virtuelle Kartennummer | | cvv | Virtueller Karten-CVV | | exp_month / exp_year | Ablaufdaten | | cardholder | Karteninhaber | ## Fehler | Feld | Bedeutung | | ---- | --------- | | error_description | Fehlertext (nicht stabil) | ## Idempotenz Verwenden Sie eine eindeutige (idempotente) `txid` je Geschäftsanweisung und speichern Sie sie vor dem Senden. Der Wert ist ein String; UUID ist praktisch, aber nicht erforderlich. Dieselbe Anweisung verwendet im selben Konto und derselben Umgebung dieselbe ID. Nicht für einen anderen Betrag oder Empfänger wiederverwenden. Nach Timeout die ursprüngliche Operation wiederherstellen, statt unbemerkt eine weitere Zahlung zu erstellen. ## Polling Lesezugriffe mit begrenztem Backoff wiederholen, z. B. 1s → 2s → 4s → 8s bei 30s Wartebudget. Bei bekanntem Endstatus oder Budgetende stoppen. Bei Timeout ursprüngliche `id`/`txid` behalten und ausstehendes/unbekanntes Ergebnis melden. Unbekannt ist kein Erfolg. Siehe [Fehler](business/errors.md). ## Webhook Informativ – Status immer per GET verifizieren. ## Betragsskalierung Beträge sind ganzzahlige Strings in kleinsten Einheiten, keine Gleitkommazahlen. Decimals je Währung, Netzwerk und Umgebung liefert `GET https://app.heth.me/api/v1/contracts?env=prod`. USDT/ETH und USDT/TRX verwenden derzeit 6 Stellen: 1 USDT = `"1000000"`, 0,25 USDT = `"250000"`. ETH hat 18 Stellen, nicht jeder Ethereum-Token. Bei unbekannter Skalierung muss die Umrechnung stoppen. Siehe [API-Schema](/openapi.json). ## de: Heth.me nutzen: Wallets, Überweisungen und Zahlungen Source: https://docs.heth.me/markdown/de/intro.md --- slug: "/" sidebar_position: 1 title: "Wallets, Überweisungen und Zahlungs-API" sidebar_label: "Erste Schritte" description: "Heth.me-Wallet einrichten, USDT überweisen, per QR bezahlen und Zahlungen annehmen. Nutzeranleitungen, Geschäftsintegration und API-Referenz." last_update: date: 2026-10-20 --- # Heth.me nutzen: Wallets, Überweisungen und Zahlungen Hier erfahren Sie, wie Sie ein Heth.me-Konto einrichten, Geld empfangen und überweisen, Einkäufe bezahlen und Zahlungen annehmen. Nutzeranleitungen erklären die App; die API-Referenz beschreibt Integrationsanfragen. ## Mit der Wallet beginnen - [Konto erstellen oder wiederherstellen](user/wallets.md) und Kryptokonten sowie Wallet-Guthaben verstehen. - [Geld empfangen, überweisen oder auszahlen](user/transfers.md), Netzwerk und Signiermethode wählen. - [Per QR bezahlen oder Zahlungen annehmen](user/payments.md), Empfangslink teilen. - [@Namen, Geschenkkarten und Spenden nutzen](user/features.md), Mitteilungen einrichten. - [Kontozugang schützen](user/security.md) und Offline-Grenzen verstehen. USDT auf Ethereum und TRON benötigt unterschiedliche Empfängerdaten. Vor Bestätigung Token, Netzwerk, Empfänger und Betrag prüfen. ## Geschäftszahlungen integrieren Beginnen Sie mit einer [Leseanfrage ohne Geldbewegung](business/quick-start.md), dann wählen Sie: - [Authentifizierung und API-Schlüssel](business/authentication.md). - [Zahlungen, Auszahlungen und Status](transactions/overview.md). - [Produkte, Zahlungslinks und Abonnements](business/resources.md). - [Webhooks: Signatur und Ereignisverarbeitung](business/webhooks.md). - [Beträge und IDs](field_conventions.md), [Fehler und Wiederholungen](business/errors.md). Geschäftsfunktionen hängen vom [Kontozugriff](business/capabilities.md) ab. HTTP-Erfolg bestätigt keine Zahlung: Status der Originaltransaktion prüfen. ## KI mit Heth.me verbinden [Verbinden Sie Ihren KI-Assistenten über Heth MCP](ai/mcp.md) mit Ihrem eigenen Konto und den verfügbaren Geschäftsfunktionen. Sie wählen die Berechtigungen und bestätigen jede Geldoperation in Heth. Die Anleitung erklärt Verbindung, Überweisungen, Geschäftsänderungen, OBS und Widerruf. Für KI-Integrationen stehen [API-Teilschema](/openapi.json), [Dokumentationsindex](/llms.txt) und [Volltext](/llms-full.txt) bereit. Aktuelle Guthaben, Berechtigungen und Ergebnisse müssen über die API gelesen werden. ## App und Hilfe [Heth.me öffnen](https://app.heth.me) · [Support kontaktieren](https://t.me/hethmesupport_bot) ## de: Abonnements und automatische Zahlungen Source: https://docs.heth.me/markdown/de/subscriptions.md --- title: Abonnements und automatische Zahlungen --- # Abonnements und automatische Zahlungen Ein Händler kann einen Heth.me-Nutzer um die Zustimmung zu wiederkehrenden Zahlungen bitten. Der Zahler prüft und unterschreibt die Bedingungen mit seinem regulär entsperrten HethWallet. Ein separates E-Mail-Konto oder eine Anmeldung im Customer Portal ist nicht erforderlich. Die Zahlungen belasten das **Heth-Kontoguthaben** in der vereinbarten Währung und im vereinbarten Netzwerk. ## Für Zahler 1. Öffnen Sie **Settings → Subscriptions and autopay**. Neue Anfragen stehen getrennt von bestehenden Abonnements. 2. Prüfen Sie Händler, Betrag je Zahlung, Währung/Netzwerk und Abrechnungsintervall. Der Bestätigungslink öffnet denselben Bildschirm. Ein gesperrtes Wallet fragt nach der üblichen PIN und kehrt zur Anfrage zurück. 3. Wählen Sie **Enable subscription** oder **Reject**. Das Öffnen eines Links oder der Empfang einer Benachrichtigung erteilt keine Zustimmung. 4. Nach der Zustimmung wird die erste Zahlung geplant. Die Liste zeigt Betrag, Intervall und nächsten Zahlungstermin; bei einem erneuten Zahlungsversuch dessen nächsten Zeitpunkt. 5. Widerrufen Sie das Abonnement, um künftige Abbuchungen zu stoppen. Bereits ausgeführte Zahlungen werden dadurch nicht erstattet. Die Bestätigung speichert die Zustimmung und plant eine Zahlung; sie bedeutet nicht, dass die Zahlung erfolgreich war. Prüfen Sie den Transaktionsstatus. Zum Ausführungszeitpunkt muss ausreichend Guthaben vorhanden sein. ## Benachrichtigung über neue Anfragen Bei einem erkannten Zahler sendet der Server eine Push-Benachrichtigung zur Abonnementanfrage an registrierte Geräte mit dem Link `/subscriptions/confirm/?env=`. Ein Eintrag wird auch unter der Benachrichtigungsglocke gespeichert, selbst wenn kein Gerät den Push empfangen kann. Offene Anfragen bleiben unter **Settings → Subscriptions and autopay** verfügbar. Installierte PWAs verwenden Web-Push. Heth.me für iOS und Android verwendet ab Version 1.0.0 (Build 5) Systembenachrichtigungen. Aktivieren Sie Benachrichtigungen im Wallet und erlauben Sie diese in den Geräteeinstellungen. Durch Antippen einer Abonnementanfrage öffnet sich deren Bestätigungsseite; ein gesperrtes Wallet fragt zuerst nach der üblichen PIN oder einem verfügbaren Passkey. Der Empfang oder das Öffnen einer Benachrichtigung bestätigt das Abonnement nicht. Öffnen Sie bei fehlender Benachrichtigung die Liste offener Anfragen oder den Bestätigungslink des Händlers. ## Für Händler Öffnen Sie in HethWallet **Business → Subscriptions and autopay**. Geben Sie Wallet-Adresse, `@username` oder Heth-Kartennummer des Zahlers, Namen des Abonnements, Betrag je Zahlung, Währung/Netzwerk und Intervall ein. Senden Sie die Anfrage und kopieren Sie den Bestätigungslink. Hier können Sie eigene Anfragen einsehen und noch offene Anfragen stornieren. Der Betreiber muss Heth-Abonnements für die Organisation aktivieren und einen funktionierenden Zahlungsweg konfigurieren. Die Erstellung einer Anfrage erlaubt keine Abbuchung. ## Anfrage über die API erstellen Verwenden Sie den API-Schlüssel des Händlers oder seine reguläre Partner-Bearer-Sitzung. Auf `app.heth.me` wird die Organisation anhand des Hosts ermittelt. Ein schreibgeschützter Schlüssel kann Anfragen weder erstellen noch stornieren. ```bash curl -X POST 'https://app.heth.me/api/v1/heth/subscription-requests' \ -H "x-api-key: $HETH_API_KEY" \ -H 'Content-Type: application/json' \ -d '{ "request_id": "b56b2c66-4ae5-4cb9-92ea-7a3297b72b55", "payer": "@alice", "description": "Monthly membership", "amount": "1000000", "currency": "USDT", "network": "ETH", "interval": "monthly", "period": 1, "env": "prod" }' ``` | Feld | Beschreibung | Typ | Beispiel | | --- | --- | --- | --- | | `request_id` | Eindeutige idempotente UUID. Bei Wiederholung derselben Anfrage mit identischen Bedingungen wiederverwenden. | String | `b56b2c66-4ae5-4cb9-92ea-7a3297b72b55` | | `payer` | Wallet-Adresse, Benutzername oder Heth-Kartennummer. | String | `@alice` | | `description` | Name des Abonnements, 1–250 Zeichen ohne Zeilenumbrüche. | String | `Monthly membership` | | `amount` | Positive Ganzzahl in kleinsten Token-Einheiten. Bei USDT mit 6 Dezimalstellen bedeutet `1000000` genau 1 USDT. | String | `1000000` | | `currency`, `network` | Aktiviertes Token/Netzwerk-Paar der gewählten Umgebung. Netzwerke: `ETH`, `TRX`, `BASE`. | String | `USDT`, `ETH` | | `interval` | `daily`, `weekly`, `monthly` oder `yearly`. | String | `monthly` | | `period` | Anzahl der Intervalle, 1–365; Standardwert 1. | Number | `1` | | `env` | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | String | `prod` | HTTP `201` liefert die Anfrage direkt zurück, darunter `id`, `status`, `amount_decimals`, `confirm_url`, `expires_at`, `subscription_id` und `next_charge_at`. Anfragen verfallen nach sieben Tagen. Die erfolgreiche Erstellung verrät nicht, ob der angegebene Zahler existiert; nur der tatsächliche Empfänger kann die Anfrage lesen und bestätigen. ## API-Operationen Alle folgenden Pfade beginnen mit `/api/v1`. Händleroperationen erfordern seinen API-Schlüssel oder seine Partner-Bearer-Sitzung. | Methode und Pfad | Zweck | | --- | --- | | `POST /heth/subscription-requests` | Anfrage erstellen. | | `GET /heth/subscription-requests?env=prod&limit=50` | Händleranfragen in `data` und `total` auflisten. | | `POST /heth/subscription-requests/:id/cancel` | Offene Anfrage stornieren; Body `{"env":"prod"}`. | Lassen Sie `page` für die erste Seite weg. Verwenden Sie `page=1` für die nächste Seite und erhöhen Sie danach den Wert; `limit` bestimmt die Seitengröße. Wallet-Operationen erfordern die reguläre Wallet-Bearer-Sitzung des Zahlers. Der API-Schlüssel des Händlers kann nicht für den Zahler zustimmen. | Methode und Pfad | Zweck | | --- | --- | | `GET /heth/subscriptions?env=prod&limit=50` | Eigene Abonnements in `data`/`total`, offene Anfragen in `requests`/`requests_total`. | | `GET /heth/subscription-requests/:id?env=prod` | Empfangene Anfrage und kanonische Signaturnachricht `message` lesen. | | `POST /heth/subscription-requests/:id/confirm` | Nach Prüfung der genauen Bedingungen mit `{"signature":"","env":"prod"}` bestätigen. | | `POST /heth/subscription-requests/:id/reject` | Ablehnen; Body `{"env":"prod"}`. | | `POST /heth/subscriptions/:id/revoke-mandate` | Künftige Abbuchungen stoppen; Body `{"env":"prod"}`. | Die Signatur bindet Händler, Zahler, Organisation, Umgebung, Beschreibung, Betrag und Dezimalstellen, Währung/Netzwerk, Intervall und Periode, erste Zahlungsregel, Nonce und Ablaufdatum. Neue Bedingungen erfordern eine neue Anfrage und Zustimmung. Wiederholte Bestätigungen oder geplante Zahlungen können denselben Zeitraum nicht doppelt belasten. API-Zeitstempel ohne Zeitzone sind UTC; die App zeigt die lokale Gerätezeit. ## Status und Fehler Anfragestatus: `pending`, `signed`, `rejected`, `expired`. Eine genehmigte Anfrage enthält eine `subscription_id`. Verfolgen Sie den tatsächlichen Zahlungsabschluss über die Transaktions-API und konfigurierte Webhooks. `401` bedeutet fehlende/ungültige Authentifizierung; `403` bedeutet deaktivierte Abonnements oder einen schreibgeschützten API-Schlüssel. Eine nicht zugängliche Anfrage liefert `404`. `422` kennzeichnet ungültige Bedingungen, eine wiederverwendete UUID mit anderen Bedingungen, eine ungültige Signatur oder eine abgelaufene/geschlossene Anfrage. Ein Händler kann unterschriebene Bedingungen eines aktiven Abonnements nicht ohne erneute Zustimmung ändern. ## de: Aggregierte Zahlung (Einzug für Händler) Source: https://docs.heth.me/markdown/de/transactions/aggregator_payment.md --- title: Aggregierte Zahlung (Einzug für Händler) last_update: date: 2026-10-20 --- # Aggregierte Zahlung (Einzug für Händler) Beispiel: `"1000000"` entspricht 1 USDT bei decimals=6. Ersetzen Sie alle Platzhalter durch geprüfte Empfänger- und Instrumentdaten. Diese Anfrage kann echtes Geld bewegen. Prüfen und genehmigen Sie die Operation ausdrücklich vor dem Absenden. Siehe [Einstieg](../business/quick-start.md). Dieser Transaktionstyp ermöglicht es einem Zahlungs-Aggregator, Kundenzahlungen im Namen eines angebundenen Händlers zu akzeptieren. Der Betrag wird beim Zahler belastet und anschließend automatisch zwischen Händler (Netto nach Gebühr) und Aggregator (Gebühr) verteilt. ## Geschäftsablauf 1. Händler schließt Onboarding / Vertrag mit dem Aggregator ab. 2. Aggregator fordert den Händler auf, in heth.me eine Wallet anzulegen und die `wallet_id` bereitzustellen. 3. Mit seinem eigenen API-Key erstellt der Aggregator eine `payment`-Transaktion: Händlerdaten in `money_storage_merchant`, Zahlerinstrument in `money_storage`. 4. Nach erfolgreicher Verarbeitung werden die Salden von Zahler, Händler und Aggregator in einem einzigen Schritt aktualisiert. 5. Der Transaktionsstatus wird über den Standard-Endpunkt (Polling mit demselben API-Key) abgefragt. ## Beispiel-Request ```bash curl --location --request POST 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage_merchant": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "08", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Zahlung", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## Feldreferenz | Feld | Beschreibung | Typ | Beispiel | | ----- | ------------ | :--- | -------- | | amount | Transaktionsbetrag (Ganzzahl in kleinsten Einheiten, als String) | String | 1000000 | | currency | Transaktionswährung (Standard USDT) | String | USDT | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | String | prod | | type | Transaktionstyp (payment) | String | payment | | route | Verarbeitungsroute (muss konfigurierter Zuordnung entsprechen) | String | hot_hot_ETH | | money_storage_merchant | Händler-Wallet-Descriptor | Object | | | > wallet_id | Händler-Wallet-ID | String | YOUR_WALLET_ID | | > network | Blockchain-Netzwerk (TRX oder ETH) | String | ETH | | > type | Interaktionstyp (z.B. p2p_proxy) | String | p2p_proxy | | > currency | Händler-Abrechnungswährung (Standard USDT) | String | USDT | | money_storage | Zahlungsverfahren des Zahlers | Object | | | > network | Blockchain-Netzwerk (TRX oder ETH) | String | ETH | | > type | Instrumenttyp (bank_card) | String | bank_card | | > currency | Zahlerwährung (Standard USDT) | String | USDT | | > cardnumber | Virtuelle Kartennummer | String | YOUR_CARD_NUMBER | | > cvv | Virtueller Karten-CVV | String | YOUR_CVV | | > exp_month | Ablaufmonat | String | 08 | | > exp_year | Ablaufjahr | String | 2026 | | > cardholder | Karteninhaber | String | John Doe | | description | Beschreibung | String | Zahlung | | txid | Idempotenter Transaktionsbezeichner (String) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## Hinweise * Die Aggregator-Gebühr wird automatisch gemäß API-Key-Konfiguration angewendet. * `route` muss einer aktivierten Route für diesen API-Key entsprechen. * Verwenden Sie idempotente `txid` Werte zur Vermeidung von Doppelbuchungen. * Status über den Standard-GET-Endpunkt abfragen (Polling bis Endzustand). ## de: Transaktionsstatus abrufen Source: https://docs.heth.me/markdown/de/transactions/get_transaction.md --- title: Transaktionsstatus abrufen last_update: date: 2026-10-20 --- # Transaktionsstatus abrufen Liefert den aktuellen Status einer Transaktion anhand ihrer `id` mittels API-Key. ## Anfrage ``` GET /api/v1/transactions/{transaction_id}?env=prod Header: x-api-key: ``` `{transaction_id}` ist die interne `id` (UUID) der Transaktion, als Pfadsegment. ## Antwortfelder | Feld | Beschreibung | | ----- | ------------ | | amount | Betrag (kleinste Einheiten) | | amount_with_fee | Betrag inkl. Gebühr | | amount_dest | Zielbetrag bei Konvertierung (kleinste Einheiten), falls zutreffend | | currency | Währung | | currency_dest | Zielwährung bei Konvertierung, falls zutreffend | | description | Beschreibung | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | | error_description | Fehlertext bei `rejected` | | finished | Abschlusszeit (ISO) | | id | Interne UUID | | route | Verwendete Verarbeitungsroute | | started | Startzeit (ISO) | | status | Status (siehe Abschnitt „Status" im Glossar; created, charging, charged, refunded, rejected, failed) | | txid | Externe ID (Client) | | type | Typ (payment / payout) | | widget_url | Widget-URL (falls vorhanden) | | simple_auth_redirect_url | URL für Zusatzauth / 3DS | ## Beispiel ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## Hinweise * Exponentielles Backoff beim Polling. * Ergebnis anhand von `status` prüfen; `finished` allein beweist keinen Ausgang. * `txid` idempotent halten. ## Über externe Operations-ID wiederherstellen ```bash curl --get 'https://app.heth.me/api/v1/transactions/example-order-001' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'by=txid' \ --data-urlencode 'env=prod' ``` ## de: Transaktionen auflisten Source: https://docs.heth.me/markdown/de/transactions/list_transactions.md --- title: "Transaktionen auflisten" last_update: date: 2026-10-20 --- # Transaktionen auflisten Lesen Sie die Transaktionen Ihres Kontos. Die Antwort ist ein Objekt mit data und cursor, kein Array auf oberster Ebene. Zeitraum begrenzen und Umgebung ausdrücklich wählen. Siehe [Einstieg](../business/quick-start.md), [Authentifizierung](../business/authentication.md) und [Fehler](../business/errors.md). ```http GET /api/v1/transactions?env=prod&order_by=started&limit=30 x-api-key: YOUR_API_KEY ``` ## Filter | Filter | Bedeutung | | --- | --- | | `started_from / updated_from` | Beginn des Zeitraums ISO 8601 | | `started_to / updated_to` | Ende des Zeitraums ISO 8601 | | `type` | Transaktionstyp | | `status` | Statusfilter | | `txid` | Exakte externe ID als String | | `order_by` | started oder updated | | `limit` | Seitengröße 1–500, Standard 100 | | `env` | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | | `cursor` | Zeitstempel aus cursor_value | ```json { "data": [ { "id": "c033ceaa-3726-4479-8be3-c9af8a0b2336", "txid": "example-order-001", "type": "payment", "status": "charged", "amount": "1000000", "currency": "USDT", "env": "prod", "started": "2026-10-01T10:00:00Z" } ], "cursor": { "cursor_field": "started", "cursor_value": "2026-10-01T10:00:00Z" } } ``` ## Nächste Seite Den zurückgegebenen cursor.cursor_value als String im Query-Parameter cursor senden, nicht das gesamte Objekt. Umgebung, Filter und order_by beibehalten. Bei order_by=updated kann cursor_field updated_at sein. Bei leerem data oder fehlendem fortschreitendem Cursor stoppen. Bei Änderungen während des Abrufs anhand der Transaktions-ID abgleichen. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'order_by=started' \ --data-urlencode 'limit=30' \ --data-urlencode 'cursor=2026-10-01T10:00:00Z' ``` ## de: Transaktions-API Source: https://docs.heth.me/markdown/de/transactions/overview.md --- title: "Transaktions-API" last_update: date: 2026-10-20 --- # Transaktions-API Wählen Sie den Ablauf Ihrer aktivierten Kontoroute. Die Beispiele verwenden virtuelle Heth-Instrumente und versprechen keine allgemeinen Zahlungen mit beliebigen externen Bankkarten. Siehe [Einstieg](../business/quick-start.md), [Authentifizierung](../business/authentication.md) und [Fehler](../business/errors.md). ## Erstellen - [Zahlung mit virtueller Karte](pcn.md) - [Auszahlung auf virtuelle Karte](wcn.md) - [Auszahlung an Wallet-ID](wid.md) - [Aggregator-Zahlung](aggregator_payment.md) ## Lesen - [Transaktion abrufen](get_transaction.md) - [Transaktionen auflisten](list_transactions.md) ## Referenz - [Beträge, IDs und Status](../field_conventions.md) ## de: Zahlung per Kartennummer Source: https://docs.heth.me/markdown/de/transactions/pcn.md --- title: Zahlung per Kartennummer last_update: date: 2026-10-20 --- # Zahlung per Kartennummer Beispiel: `"1000000"` entspricht 1 USDT bei decimals=6. Ersetzen Sie alle Platzhalter durch geprüfte Empfänger- und Instrumentdaten. Diese Anfrage kann echtes Geld bewegen. Prüfen und genehmigen Sie die Operation ausdrücklich vor dem Absenden. Siehe [Einstieg](../business/quick-start.md). Initialisierung einer Zahlung über eine virtuelle Karte. ## Anfragebeispiel ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "10", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Zahlung", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` | Feld | Beschreibung | Typ | Beispiel | | ----- | ----- | :--- | ----- | | amount | Transaktionsbetrag (Ganzzahl in kleinsten Einheiten, als String) | String | 1000000 | | currency | Transaktionswährung (Standard USDT) | String | USDT | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | String | prod | | type | Transaktionstyp (in diesem Fall payment) | String | payment | | route | Transaktionsroute (muss der Routenzuordnung entsprechen) | String | hot\_hot\_ETH | | money_storage | Karten-Instrument | Objekt | | | \>network | Blockchain-Netzwerk (TRX oder ETH) | String | ETH | | \>type | Instrumenttyp (bank_card) | String | bank_card | | \>currency | Instrumentwährung (Standard USDT) | String | USDT | | \>cardnumber | Virtuelle Kartennummer | String | YOUR_CARD_NUMBER | | \>cvv | Virtueller Karten-CVV | String | YOUR_CVV | | \>exp_month | Ablaufmonat | String | 10 | | \>exp_year | Ablaufjahr | String | 2026 | | \>cardholder | Karteninhaber | String | John Doe | | description | Transaktionsbeschreibung | String | Zahlung | | txid | Idempotenter Transaktionsbezeichner (String) | String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## de: Auszahlung an Wallet-ID Source: https://docs.heth.me/markdown/de/transactions/pid.md --- title: "Auszahlung an Wallet-ID" last_update: date: 2026-10-20 --- # Auszahlung an Wallet-ID Diese Seite entspricht dem Ablauf der kanonischen Wallet-ID-Referenz. Verwenden Sie deren Anfrage und Felddefinitionen. [Auszahlung an Wallet-ID](wid.md) ## de: Aggregator-Zahlung mit virtueller Karte Source: https://docs.heth.me/markdown/de/transactions/rcn.md --- title: "Aggregator-Zahlung mit virtueller Karte" last_update: date: 2026-10-20 --- # Aggregator-Zahlung mit virtueller Karte Diese Seite entspricht dem Händler-Einzugsablauf der kanonischen Aggregator-Referenz. Verwenden Sie deren Anfrage und Definitionen. [Aggregator-Zahlung mit virtueller Karte](aggregator_payment.md) ## de: Auszahlung per Kartennummer Source: https://docs.heth.me/markdown/de/transactions/wcn.md --- title: Auszahlung per Kartennummer last_update: date: 2026-10-20 --- # Auszahlung per Kartennummer Beispiel: `"1000000"` entspricht 1 USDT bei decimals=6. Ersetzen Sie alle Platzhalter durch geprüfte Empfänger- und Instrumentdaten. Diese Anfrage kann echtes Geld bewegen. Prüfen und genehmigen Sie die Operation ausdrücklich vor dem Absenden. Siehe [Einstieg](../business/quick-start.md). Auszahlung auf eine Karte. ## Anfragebeispiel ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER" }, "description": "Auszahlung", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` | Feld | Beschreibung | Typ | Beispiel | | ----- | ----- | :--- | ----- | | amount | Transaktionsbetrag (Ganzzahl in kleinsten Einheiten, als String) | String | 1000000 | | currency | Transaktionswährung (Standard USDT) | String | USDT | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | String | prod | | route | Transaktionsroute (muss der Routenzuordnung entsprechen) | String | hot\_hot\_ETH | | type | Transaktionstyp (in diesem Fall payout) | String | payout | | money\_storage | Empfängerdatenobjekt | Objekt | | | \>network | Blockchain-Netzwerk (TRX oder ETH) | String | ETH | | \>type | Instrumenttyp (bank\_card) | String | bank\_card | | \>currency | Empfängerwährung (Standard USDT) | String | USDT | | \>cardnumber | Empfänger-Kartennummer | String | YOUR_CARD_NUMBER | | description | Transaktionsbeschreibung | String | Auszahlung | | txid | Idempotenter Transaktionsbezeichner (String) | String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## de: Auszahlung per ID Source: https://docs.heth.me/markdown/de/transactions/wid.md --- title: Auszahlung per ID last_update: date: 2026-10-20 --- # Auszahlung per ID Beispiel: `"1000000"` entspricht 1 USDT bei decimals=6. Ersetzen Sie alle Platzhalter durch geprüfte Empfänger- und Instrumentdaten. Diese Anfrage kann echtes Geld bewegen. Prüfen und genehmigen Sie die Operation ausdrücklich vor dem Absenden. Siehe [Einstieg](../business/quick-start.md). Auszahlung an eine Wallet-ID. ## Anfragebeispiel ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Auszahlung", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` | Feld | Beschreibung | Typ | Beispiel | | ----- | ----- | :--- | ----- | | amount | Transaktionsbetrag (Ganzzahl in kleinsten Einheiten, als String) | String | 1000000 | | currency | Transaktionswährung (Standard USDT) | String | USDT | | env | `prod` (Standard). Beim Öffnen und Bestätigen der Anfrage beibehalten. | String | prod | | route | Transaktionsroute (muss der Routenzuordnung entsprechen) | String | hot\_hot\_ETH | | type | Transaktionstyp (in diesem Fall payout) | String | payout | | money\_storage | Empfängerdatenobjekt | Objekt | | | \>wallet\_id | Empfänger-Wallet-ID | String | YOUR_WALLET_ID | | \>network | Blockchain-Netzwerk (TRX oder ETH) | String | ETH | | \>type | Transaktionstyp für Wallets (in diesem Fall p2p\_proxy) | String | p2p\_proxy | | \>currency | Empfängerwährung (Standard USDT) | String | USDT | | description | Transaktionsbeschreibung | String | Auszahlung | | txid | Idempotenter Transaktionsbezeichner (String) | String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## de: Weitere Kontofunktionen Source: https://docs.heth.me/markdown/de/user/features.md --- title: "Weitere Kontofunktionen" last_update: date: 2026-10-21 --- # Weitere Kontofunktionen Die Einstellungen Ihres Kontos bestimmen den Funktionsumfang. Diese Beschreibung bedeutet nicht, dass jede Funktion allen Nutzern zur Verfügung steht. ## @Namen Prüfen Sie in den Namenseinstellungen Verfügbarkeit und Preis. Wählen Sie das zulässige Finanzierungs-Wallet und folgen Sie den Zahlungsschritten. Eine unbezahlte Reservierung ist noch kein aktiver Empfangsname. Prüfen Sie Laufzeit und Verlängerung; abgelaufene oder gesperrte Namen werden möglicherweise nicht aufgelöst. Bei laufender Zahlung kann die Freigabe eines Namens abgelehnt werden. ## Geschenkkarten Die Geschenkkartenansicht zeigt eigene Ausgaben und unterstützt je nach Freigabe Ausgabe und Einlösung. Die Ausgabe wird aus Ihrem eigenen zulässigen Wallet finanziert und erfordert eine Bestätigung. Bewahren Sie den angezeigten Code sicher auf: sein Besitz kann zur Einlösung berechtigen. Geben Sie den Einlösecode in Heth ein; den Nennwert bestimmt der Server. Die Anfrage allein bestätigt keine Gutschrift. ## Gas Ein Gaskauf ist eine separate Operation. Prüfen Sie Quelle, Zielkonto, Betrag und Netzwerk. Eine Cold-Quelle kann eine Signatur erfordern. Blockchain-Gas ist vom übertragenen Tokenbetrag zu unterscheiden. ## Spenden Prüfen Sie auf der Autorenseite Plattform, Autor, Token, Netzwerk, Mindestbetrag und Gebühr. Wählen Sie verfügbares Heth-Wallet oder externes Konto und prüfen Sie die Operation vor der Autorisierung. Externe Zahlungsdaten können ablaufen. Die Ergebnisseite zeigt den Status der ursprünglichen Spende. ## Mitteilungen und Webhooks 1. Öffnen Sie **Settings → Notifications** (englische Oberfläche), aktivieren Sie den Schalter und bestätigen Sie die System- oder Browserabfrage. Die mobile App verwendet Systembenachrichtigungen; die Webversion verwendet den Benachrichtigungsdienst des Browsers, sofern unterstützt. 2. Bei verweigerter Berechtigung erlauben Sie Heth-Benachrichtigungen in den Geräte- oder Browsereinstellungen, öffnen Heth erneut und versuchen es noch einmal. Die Zustellung hängt auch von der Verbindung und Geräteeinschränkungen ab. 3. Zum Abschalten auf diesem Gerät deaktivieren Sie denselben Schalter. Dies kündigt weder Zahlungen noch Abonnements oder KI-Verbindungen. Das Antippen einer Zahlungsbenachrichtigung öffnet Heth. Entsperren Sie das Konto und prüfen Sie die angeforderte Aktion. Das Antippen allein signiert oder bestätigt keine Zahlung. Prüfen Sie das Endergebnis im Transaktionsverlauf. In den Webhook-Einstellungen hinterlegen Sie eine eigene Empfangs-URL und ein Integrationsgeheimnis. Die URL erhält Kontoereignisse. Siehe [Webhooks](../business/webhooks.md). ## Abonnements, Hardware und Multisig Verwalten Sie Abonnementanfragen und Berechtigungen für künftige Abbuchungen in Heth. Die [Anleitung zu Abonnements und automatischen Zahlungen](../subscriptions.md) erklärt die Zustimmung des Zahlers, Händleranfragen, Zahlungstermine und den Widerruf. Kartenverknüpfung und künftige Abbuchungen erfordern Ihre ausdrückliche Zustimmung. Prüfen Sie bei Hardware- oder Multisig-Konten vor einer Überweisung, ob Gerät und Signaturmethode das gewählte Netzwerk unterstützen. Unter **Einstellungen → Subscription mandates** können berechtigte Konten ihre eigenen Krypto-Abonnementfreigaben und Limits je Belastung sehen. Wählen Sie **Revoke mandate** und bestätigen Sie in Heth, um künftige Belastungen zu stoppen. Bereits abgeschlossene Zahlungen werden dadurch nicht erstattet. ## Spenden-Widget für OBS Studio Fügen Sie das Heth-Widget als Browserquelle in OBS Studio hinzu: Es zeigt Empfangs-QR, Designs und Hinweise auf eingehende Zahlungen. Erstellen Sie die Verbindung unter **Einstellungen → OBS Studio** in Heth. Teilen Sie die geheime Verbindungs-URL weder öffentlich noch mit einer KI. Ein Assistent kann über MCP eingeschränkte Ereignisse lesen und unterstützte Designeinstellungen ändern; Zugriffsrechte werden in Heth bestätigt. [OBS-Einrichtung](./obs.md). ## de: OBS Studio: Empfangs-QR und Zahlungshinweise Source: https://docs.heth.me/markdown/de/user/obs.md --- title: "OBS Studio: Empfangs-QR und Zahlungshinweise" last_update: date: 2026-10-21 --- # OBS Studio: Empfangs-QR und Zahlungshinweise Das Heth-Widget wird in OBS Studio als **Browser-Quelle** hinzugefügt. Es zeigt einen Empfangs-QR und Hinweise auf abgeschlossene eingehende Heth-Überweisungen. Ein natives OBS-Plugin ist nicht erforderlich. Szenen, Aufzeichnung und Streaming werden nicht gesteuert. Eine eingehende Überweisung ist nicht automatisch eine Spende an einen bestimmten Autor oder eine Plattform. ![Vorschau des aktualisierten Widgets auf Englisch. Beispielereignis; der Vorschau-QR löst keine Zahlung aus.](/img/obs-preview-en.png) Vorschau des aktualisierten Widgets auf Englisch. Beispielereignis; der Vorschau-QR löst keine Zahlung aus. ## Einrichtung 1. Öffnen Sie Heth und melden Sie sich beim Konto an, das Spenden empfangen soll. 2. Öffnen Sie **Einstellungen → OBS Studio**. Empfänger ist Ihr angemeldetes Heth-Konto. 3. Wählen Sie ein verfügbares Währungs-/Netzwerkpaar. Betrag, Beschriftung, Design und Sprache sind anpassbar. Ein leerer Betrag lässt dem Zahlenden die Wahl. 4. Speichern Sie das Design und bestätigen Sie die Erstellung einer OBS-Verbindung. Dabei wird ein eigener eingeschränkter Zugang angelegt. 5. Kopieren Sie die Verbindungs-URL und fügen Sie sie in OBS in eine **Browser-Quelle** ein. Beginnen Sie mit **900 × 500** Pixeln; passen Sie Größe und Ausschnitt an Ihre Szene an. 6. Scannen Sie den QR mit dem Telefon. Prüfen Sie Empfänger, Währung und Netzwerk vor jeder Zahlungsbestätigung. Der QR selbst löst keine Zahlung aus. Der Hintergrund ist transparent. Lassen Sie den QR frei und ausreichend groß. Prüfen Sie ihn in der tatsächlichen Szene und der Auflösung Ihrer Zuschauer. Das Widget unterstützt Russisch und Englisch unabhängig von der Heth-Oberflächensprache. ## Zugang und Datenschutz Die Verbindung nutzt einen eigenen API-Schlüssel mit eingeschränkten OBS-Rechten. Heth erstellt ihn und fügt ihn in die Verbindungs-URL ein; ein Schlüssel aus den Business-Einstellungen ist nicht nötig. Webhooks arbeiten unabhängig davon: Sie senden Ereignisse an Ihren Server, während die OBS-Browser-Quelle den eingeschränkten Ereignisstrom des Widgets direkt liest. Für das Standard-Widget benötigen Sie keinen eigenen Webhook-Empfänger. Ein OBS-Schlüssel gehört zu Ihrem Konto und kann dessen Widget-Ereignisse lesen. MCP-Berechtigungen werden getrennt erteilt; OBS- und KI-Verbindungen werden jeweils separat widerrufen. Die Verbindungs-URL enthält nach `#` ein geheimes OBS-Token. Halten Sie die ganze URL privat: nicht in Stream-Beschreibungen, Screenshots, öffentlichen Szenenexporten oder KI-Chats teilen. Der angezeigte QR enthält Zahlungsdaten, nicht dieses Token. OBS darf Empfängerkennung, Design und einen eingeschränkten Strom eingehender Zahlungsereignisse lesen. Kontostand, vollständige Historie, Überweisungen und Einstellungsänderungen sind ausgeschlossen. Widerrufen Sie nicht mehr benötigte oder offengelegte Verbindungen unter **Einstellungen → OBS Studio** und erstellen Sie bei Bedarf eine neue. ## Zahlungshinweise Berücksichtigt werden nur eingehende Überweisungen mit Status `charged`. Ausgehende, ausstehende und fehlgeschlagene Vorgänge fehlen. Angezeigt werden Empfängerbetrag und gespeicherte Genauigkeit, ohne Rundung auf ganze Token. Bei unbekannter Genauigkeit wird kein Betrag erfunden. Eine neue Verbindung beginnt mit neuen Ereignissen. Eine laufende Browser-Quelle kann nach einer kurzen Unterbrechung ihren gespeicherten Cursor fortsetzen; das Wiederaufnahmefenster beträgt höchstens 24 Stunden. Das Neuladen einer Quelle ersetzt keinen Historienexport. Prüfen Sie Zahlungseingang und endgültige Details in der [Transaktionshistorie](./payments.md). ## Mit einem KI-Assistenten Über den [MCP-Dienst](../ai/mcp.md) kann ein berechtigter Assistent Einstellungen und eingeschränkte Ereignisse lesen sowie eine Verbindung vorschlagen. Gewöhnliche Designänderungen werden im KI-Client bestätigt. Das verbundene Widget übernimmt gespeicherte Änderungen normalerweise innerhalb von 30 Sekunden. Zugangserteilung, Widerruf und ein anderes Empfängerkonto erfordern eine Bestätigung in Heth. Der Assistent liefert den Link zur Heth-Einrichtung, erhält aber nicht die geheime OBS-URL. Beispiel: „Nutze eine englische Beschriftung und ein minimalistisches Design“. MCP steuert OBS Studio selbst nicht. ## Eigenes Layout mit KI-Unterstützung {#custom-layout} Die normalen Heth-Einstellungen benötigen keinen Quellcodezugang. Für freie Layouts erstellen Sie einen Fork des öffentlichen [Heth OBS Widget](https://github.com/Heth-me/obs-widget) unter MIT-Lizenz. Der [KI-Leitfaden](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md) enthält Beispiele, eine Dateiübersicht und Hosting-Hinweise. Das Repository enthält Anleitungen zum Bauen und Hosten. Ein Coding-Assistent mit Zugriff auf Ihre Kopie kann Layout, CSS, Schriften, Farben und Hinweise ändern und anschließend mit Beispieldaten prüfen und bauen. Er benötigt weder die private OBS-URL noch Zahlungsschlüssel. Eine eigene Version braucht Hosting; ein öffentliches Repository allein liefert noch keine Zahlungsereignisse. Heth MCP liest Ereignisse und ändert unterstützte Heth-Designeinstellungen. Es bearbeitet kein Repository, baut keine eigene Version und erteilt keinen Zugriff auf Ihr Hosting. Das Standard-Widget von Heth erfordert keinen eigenen Build. ## Fehlerbehebung **Heth zeigt 404 statt des Widgets:** Aktualisieren Sie Heth, prüfen Sie die URL der Browser-Quelle und öffnen Sie sie erneut. Wenden Sie sich bei anhaltenden Fehlern an den Support. Neue Schlüssel lösen keine Fehler beim Laden der Seite. - **Kein OBS-Eintrag:** Aktualisieren Sie Heth und fragen Sie den Support nach Ihrem Kontozugriff. Verwenden Sie keinen allgemeinen Konto-API-Schlüssel. - **QR ohne Hinweis:** Empfängerkonto und abgeschlossenen Status prüfen. Die Browser-Quelle muss aktiv und online sein. - **Zugang deaktiviert:** In Heth neu verbinden; ein widerrufener Link wird durch Wiederholen nicht gültig. - **Falsche Währung oder Netzwerk:** In Heth korrigieren, Aktualisierung abwarten und den QR erneut prüfen. - **Alte URL mit `api_key=`:** Verbinden Sie OBS erneut über die Heth-Einstellungen und widerrufen Sie nicht mehr benötigte Kontoschlüssel. ## de: Bezahlen und Zahlungen empfangen Source: https://docs.heth.me/markdown/de/user/payments.md --- title: "Bezahlen und Zahlungen empfangen" last_update: date: 2026-10-20 --- # Bezahlen und Zahlungen empfangen ## Mit Heth bezahlen Öffnen Sie die Zahlungsansicht und verwenden Sie eine verfügbare Methode. Ein Zahler-QR kann eine Abbuchung autorisieren: zeigen Sie ihn nur dem vorgesehenen Händler. Prüfen Sie Händler und Betrag, wenn eine Bestätigung verlangt wird. Geben Sie Händlern oder KI-Assistenten weder Wiederherstellungsphrase noch Zahlungsgeheimnis. Einige zwischengespeicherte Daten und Zahlercodes sind ohne Verbindung verfügbar. Der Händler benötigt zur Verarbeitung eine Internetverbindung; normale Überweisungen werden nicht offline ausgeführt. Siehe [Offline-Grenzen](security.md). ## Zahlungsbetrag bestätigen Der von Heth für diese Zahlung angezeigten Bestätigung folgen: 1. Eigenen Zahler-QR öffnen und nur dem vorgesehenen Händler zeigen. 2. Angeforderten Betrag und Empfänger vor der Freigabe prüfen. 3. Verlangt Heth einen Code, nach Anzeige des QR zur Betragsbestätigung zurückkehren, den Zahlungsbetrag eingeben und den aktuellen Code erzeugen. 4. Diesen Code nur für diese Zahlung dem Kassierer nennen. Wiederherstellungsphrase, PIN und wiederverwendbares Zahlungsgeheimnis dagegen geheim halten. 5. Abgelaufenen QR oder Code neu öffnen und der aktuellen Anzeige folgen. Falls die Bestätigung nicht eingerichtet ist, die Einrichtung online in Heth abschließen. 6. Status des ursprünglichen Vorgangs prüfen. Angezeigter QR, erzeugter Code oder Kassenanfrage beweisen für sich allein keine Zahlung. ## Heth-Zahlung annehmen 1. Öffnen Sie **Business**. 2. Geben Sie den Betrag ein und wählen Sie verfügbaren Token und Netzwerk. 3. Scannen Sie den Heth-QR des Zahlers und senden Sie die Anfrage. 4. Warten Sie gegebenenfalls auf die Bestätigung des Zahlers. 5. Erst `charged` bestätigt die erfolgreiche Zahlung. Ablehnung, ausstehende Verarbeitung und Timeout sind unterschiedliche Ergebnisse. Verwenden Sie zur Prüfung die ursprüngliche Operations-ID. ## Empfangslink teilen Die Linkansicht erzeugt eine Heth-URL mit Ihrer Empfänger-ID, Währung und optional einem Betrag. Der Zahler prüft und autorisiert die Überweisung. Das Teilen belastet niemanden. Dieser Link unterscheidet sich von einem verwalteten Geschäftslink aus einer API. Für einen lokal erzeugten Link darf kein serverseitiges Verzeichnis, Ablaufdatum oder Stornierungsverfahren angenommen werden. ## Weitere QR-Anbieter Verwenden Sie nur freigeschaltete Methoden. Ein Anbieterlogo oder erkannter QR-Typ beweist keine verfügbare Zahlungsroute. Kontaktieren Sie bei Problemen den Support; ändern Sie nicht Empfänger oder Netzwerk, um eine Zahlung zu erzwingen. ## de: Kontoschutz und Offline-Nutzung Source: https://docs.heth.me/markdown/de/user/security.md --- title: "Kontoschutz und Offline-Nutzung" last_update: date: 2026-10-21 --- # Kontoschutz und Offline-Nutzung ## Wiederherstellung und Signatur Bewahren Sie Phrasen und private Schlüssel in der Wallet des Eigentümers auf. PIN und Biometrie schützen das aktuelle Gerät und ersetzen keine Wiederherstellungssicherung. Teilen Sie Seed, private Schlüssel und wiederverwendbare Zahlungsgeheimnisse weder mit Support, Händler noch KI. Einen einmaligen Zahlungs-QR nur dem vorgesehenen Händler zeigen. Wenn Modus B ausdrücklich verlangt, dem Kassierer einen Code vorzulesen, zuerst konkrete Zahlung und Betrag prüfen. Prüfen Sie Ursprung der Anfrage, Empfänger, Betrag, Währung und Netzwerk vor jeder Signatur. Verbinden eines Kontos, Netzwerkwechsel und Öffnen einer Signieranfrage schließen keine Zahlung ab. Prüfen Sie bei Hardware-Wallets auch die Geräteanzeige. ## Face ID / Touch ID und Passkeys Aktivieren Sie unter **Settings → Face ID / Touch ID** (englische Oberfläche) die biometrische Entsperrung, sofern diese Option verfügbar ist, und bestätigen Sie die Systemabfrage. Heth verwendet einen WebAuthn-Schlüssel (Passkey) zum lokalen Entsperren. Die Verfügbarkeit hängt von Gerät und Browser ab. Wenn Biometrie nicht verfügbar ist oder abgebrochen wird, verwenden Sie Ihre PIN. Damit entsperren Sie Heth auf dem aktuellen Gerät. Dies ersetzt weder die Wiederherstellungsphrase noch die Wiederherstellung auf einem anderen Gerät und bestätigt weder eine KI-Verbindung noch eine Zahlung. Sichern Sie Ihre Wiederherstellungsdaten vor einem Gerätewechsel oder einer Neuinstallation. ## Offline-Grenzen Zwischengespeicherte Guthaben und Verläufe können veraltet sein. Manche Zahlercodes werden lokal für einen online verbundenen Händler erzeugt. Überweisungen, aktuelle Guthaben und bestätigte Verarbeitungsergebnisse benötigen eine Verbindung. Aktualisieren Sie den Verlauf nach Wiederverbindung, bevor Sie eine Operation wiederholen. ## Gebühren und Hilfe Prüfen Sie Gebühren der konkreten Operation. Blockchain-Gas kann zusätzlich zur Servicegebühr anfallen. Übertragen Sie Gebühren oder Laufzeiten einer Überweisungsart nicht auf eine andere. Nennen Sie dem [Heth-Support](https://t.me/hethmesupport_bot) Transaktions-ID und Problem, ohne Geheimnisse. [Datenschutz](https://app.heth.me/settings/legal/privacy-policy) und [Nutzungsbedingungen](https://app.heth.me/settings/legal/terms-of-service) sind in Heth verfügbar. [Zahlungsprobleme und Status](troubleshooting.md). ## de: Überweisen und auszahlen Source: https://docs.heth.me/markdown/de/user/transfers.md --- title: "Überweisen und auszahlen" last_update: date: 2026-10-20 --- # Überweisen und auszahlen Wählen Sie zuerst die Quelle: Wallet-Guthaben oder Kryptokonto. Wählen Sie danach Empfänger, Token und Netzwerk. Prüfen Sie Betrag, Empfänger und Gebühren vor der Autorisierung. ## Überweisungsarten | Überweisung | Nutzeraktion | | --- | --- | | Wallet → Wallet | Empfänger-ID eingeben oder aktiven @username auflösen und Überweisung prüfen | | Wallet → Kryptokonto | Externe Adresse und Netzwerk angeben; Auszahlung und Gebühren prüfen | | Kryptokonto → Wallet | Quelle und Ziel-Wallet auswählen; vorbereitete Blockchain-Transaktion signieren | | Kryptokonto → Kryptokonto | Externen Empfänger prüfen und mit der Wallet des Eigentümers signieren | Interne Überweisungen und Blockchain-Auszahlungen unterscheiden sich bei Verarbeitung und Gebühren. Für Blockchain-Transaktionen kann natives Gas-Guthaben erforderlich sein. Der Gaskauf ist eine separate Operation: Finanzierungsquelle und Zielkonto prüfen. ## Externe und Hardware-Wallets Verwenden Sie bei Watch-only-Adressen die Wallet, die diese Adresse kontrolliert. Verbundenes Konto und Netzwerk müssen zur Quelle passen. Signiermöglichkeiten hängen von Netzwerk, Browser und Gerät ab. Ein Wallet-Link liefert möglicherweise keinen Transaktionshash an Heth zurück. Das Öffnen der Wallet bestätigt keine Zahlung. ## Unklares Ergebnis Prüfen Sie die ursprüngliche Operation im Verlauf. Wiederholen Sie eine Überweisung nicht allein wegen eines Timeouts oder Verbindungsabbruchs. Bewahren Sie die ID auf und wenden Sie sich bei weiter unklarem Status an den Support. Eine ausstehende Operation ist keine abgeschlossene Zahlung. [Zahlungsprobleme und Status](troubleshooting.md). ## de: Zahlungsprobleme und Transaktionsstatus Source: https://docs.heth.me/markdown/de/user/troubleshooting.md --- title: "Zahlungsprobleme und Transaktionsstatus" description: "Die ursprüngliche Heth-Zahlung finden, ausstehende Ergebnisse prüfen und Probleme mit Netzwerk, Guthaben oder QR-Bestätigung lösen." last_update: date: 2026-10-20 --- # Zahlungsprobleme und Transaktionsstatus ## Zeitüberschreitung: erneut senden? 1. Verbindung wiederherstellen und den Verlauf im selben Konto und derselben Umgebung öffnen. 2. Den ursprünglichen Vorgang anhand von Kennung, Zeit, Betrag und Empfänger suchen. Falls verfügbar, die Details öffnen. 3. Den aktuellen Status prüfen. Bei ausstehendem oder nicht auffindbarem Vorgang vor erneutem Senden den Support kontaktieren. Ein fehlendes Ergebnis beweist nicht, dass kein Geld bewegt wurde. 4. Die ursprüngliche Kennung aufbewahren. Bei API-Integrationen den [Status abrufen](../transactions/get_transaction.md) und dieselbe ursprüngliche `txid` verwenden; eine Zeitüberschreitung nicht durch eine neue Kennung umgehen. | Status | Nächster Schritt | | --- | --- | | `created`, `pending`, `processing` | Verarbeitung läuft. Ursprünglichen Vorgang aktualisieren; noch nicht als Zahlungseingang werten | | `auth_required` | Heth öffnen und die angeforderte Freigabe dieses Vorgangs durchführen | | `charged` | Vorgang abgerechnet. Betrag, Empfänger und Gebühr in den Details prüfen | | `rejected`, `failed` | Ursprünglichen Fehler lesen und seine Ursache vor einem neuen Vorgang beheben | | Kein oder unbekannter Status | Ergebnis bleibt unbestätigt. Klärung anfordern, ohne Erfolg oder Misserfolg anzunehmen | Eine Erstattung oder Rückbuchung ist ein eigenes Ergebnis. Den ursprünglichen Vorgang und die tatsächliche Gutschrift prüfen. Das Schließen von Heth storniert keine Blockchain-Überweisung. ## Guthaben oder Empfangsdaten stimmen nicht - Konto, Vermögenswert, Netzwerk und Umgebung prüfen. Internes Wallet und Crypto Account haben unterschiedliche Empfangsdaten. - Nach Wiederherstellung der Verbindung aktualisieren: Offline-Daten können veraltet sein. - Bei externer Einzahlung Adresse und Netzwerk der sendenden Wallet mit Heth abgleichen. Eine Überweisung in einem anderen Netzwerk wird diesem Konto nicht automatisch gutgeschrieben. - Fehlt auf einem anderen Gerät ein zusätzliches Cold-Konto, dessen ursprüngliche Wallet erneut verbinden. Siehe [Konten und Sicherung](wallets.md). ## QR oder Betragsbestätigung funktioniert nicht Einen frischen Zahler-QR in Heth öffnen. Falls ein Bestätigungscode verlangt wird, der [Zahlungsanleitung](payments.md) folgen, den Betrag prüfen und den aktuellen Code verwenden. Ein QR ist kein Zahlungsbeleg. Der Händler benötigt eine Verbindung. Meldet Heth eine fehlende Einrichtung, diese online abschließen. ## Support kontaktieren Dem [Heth-Support](https://t.me/hethmesupport_bot) Transaktionskennung, ungefähre Zeit mit Zeitzone, Vermögenswert/Netzwerk, Betrag und sichtbaren Fehler senden. Unbeteiligte personenbezogene Daten auf Bildern verdecken. Niemals Wiederherstellungsphrase, privaten Schlüssel, API-Schlüssel, Zahler-QR, Gutscheincode oder wiederverwendbares Zahlungsgeheimnis mitsenden. ## de: Einstieg und Wallet-Arten Source: https://docs.heth.me/markdown/de/user/wallets.md --- title: "Einstieg und Wallet-Arten" last_update: date: 2026-10-20 --- # Einstieg und Wallet-Arten Öffnen Sie [Heth.me](https://app.heth.me). Erstellen Sie eine Wiederherstellungsphrase oder stellen Sie Ihr Konto wieder her. Richten Sie gemäß den Schritten der App eine PIN und gegebenenfalls biometrisches Entsperren ein. Sichern Sie die Phrase vor dem Empfang von Geld separat. Siehe [Kontoschutz](security.md). ## Kryptokonto und Wallet | Objekt | Bedeutung | Autorisierung | | --- | --- | --- | | Kryptokonto (cold) | In der App erzeugte oder verbundene Blockchain-Adresse | Der Eigentümer signiert lokal, extern oder mit einer unterstützten Hardware-Wallet | | Wallet (hot) | Kontoguthaben für interne Zahlungen und Überweisungen | Der Dienst verarbeitet die autorisierte Operation | | Watch-only-Konto | Adresse ohne privaten Schlüssel zur Ansicht | Anzeigen erlaubt keine Ausgabe; die Wallet des Eigentümers muss signieren | Zusätzliche Cold-Konten und Namen können auf dem Gerät gespeichert sein. Eine Anmeldung auf einem anderen Gerät stellt nicht zwangsläufig alle verbundenen Konten wieder her. Sichern Sie jedes Konto in seiner ursprünglichen Wallet. ## Geld empfangen 1. Öffnen Sie das gewünschte Kryptokonto oder Wallet. 2. Prüfen Sie Token und Netzwerk: USDT auf Ethereum und USDT auf TRON benötigen unterschiedliche Empfängerdaten. 3. Verwenden Sie die angezeigten Daten oder den QR-Code. Eine Blockchain-Adresse ersetzt keine interne Wallet-ID. 4. Prüfen Sie den Eingang im Verlauf. Ausstehendes Guthaben ist nicht dasselbe wie verfügbares Guthaben. Prüfen Sie bei einer externen Börse das Auszahlungsnetzwerk. Die Börsenseite enthält externe Links; Verfügbarkeit und Bedingungen legt der jeweilige Anbieter fest. ## Verfügbare Token Verwenden Sie die in Ihrem Konto angezeigten Token. Das globale Register kann Token enthalten, die weder in Ihrer Oberfläche noch für eine bestimmte Operation freigeschaltet sind.. ## fr: Connecter un assistant IA Source: https://docs.heth.me/markdown/fr/ai/mcp.md --- title: "Connecter un assistant IA" last_update: date: 2026-10-21 --- # Connecter un assistant IA Heth MCP donne à un assistant un accès limité à votre propre compte, y compris aux fonctions professionnelles disponibles. Il ne donne aucun droit d’administration de la plateforme. Ouvrir une page ne donne aucune autorisation. ## Connecter un assistant 1. Dans l’application Heth où votre portefeuille est déjà ouvert, allez dans **Paramètres → Connexions IA** et créez un code de connexion. Ce code à usage unique appartient exactement à ce compte et expire après cinq minutes. 2. Ajoutez `https://mcp.heth.me/mcp` dans le client IA, choisissez OAuth et démarrez la connexion. 3. Dans la fenêtre de connexion, saisissez uniquement le code de Heth. Il n’est pas nécessaire de se connecter au portefeuille dans ce navigateur. Le code adresse une demande au compte qui l’a créé ; il n’accorde aucun accès. 4. Ouvrez la notification dans Heth. Sans notification, ouvrez **Paramètres → Connexions IA → Demandes de connexion**. Comparez le **code de vérification de la demande** avec la fenêtre de connexion. Vérifiez le compte, l’identifiant du client et l’adresse du service ; le nom seul ne prouve pas l’identité. 5. Dans Heth, décochez les autorisations inutiles et approuvez la sélection, ou refusez l’accès. Ouvrir la notification ne confirme rien. 6. Revenez au client IA. Sa fenêtre termine automatiquement la connexion après votre décision. La session du portefeuille et les clés restent dans Heth. Un code utilisé ou expiré ne peut pas être réutilisé. Créez-en un nouveau dans Heth ; il remplace le précédent code inutilisé. Une demande de connexion expirée doit être relancée depuis le client IA. ### Dans ChatGPT Ouvrez **Plugins → Add → Add custom MCP server**, indiquez un nom comme Heth.me et l’adresse ci-dessus, puis gardez **OAuth**. ChatGPT découvre automatiquement les paramètres ; aucune clé API du portefeuille, aucun client secret ni phrase de récupération ne sont nécessaires. Créez le plugin personnel, choisissez **Connect Heth.me** et suivez les étapes avec code et notification. Les autorisations par défaut se règlent dans **Advanced OAuth settings** ; le choix final est confirmé dans l’application Heth. Sélectionnez ensuite Heth.me dans le chat et essayez : « Affiche les soldes de mes portefeuilles via Heth ». Les outils disponibles dépendent des autorisations approuvées. ## Autorisations et outils Seules les autorisations demandées et actuellement disponibles pour votre compte peuvent être accordées. Les outils sont proposés selon ces droits. Les outils couvrent les données du compte, les transferts, les modifications commerciales ordinaires, les demandes d’abonnement et OBS. | Autorisation | Outils et usage | | --- | --- | | `heth:wallets:read` | `get_wallet_balances` : soldes de vos portefeuilles | | `heth:transactions:read` | `list_transactions`, `get_transaction` : votre historique et le statut original des opérations | | `heth:business:read` | `list_products`, `list_business_payment_links`, `list_business_subscriptions` : vos produits, liens de paiement gérés et abonnements marchands; `get_business_subscription`, `list_business_subscription_requests` : accord individuel et demandes envoyées | | `heth:payments:prepare` | `prepare_transfer`, `get_transfer_request` : préparer un transfert à confirmer dans Heth et vérifier le résultat initial | | `heth:business:manage` | `create_business_product`, `update_business_product`, `delete_business_product` ; `create_business_payment_link`, `update_business_payment_link`, `delete_business_payment_link` : modifications ordinaires confirmées dans le client IA | | `heth:business:manage` | `request_business_subscription` : demander l’accord du payeur dans Heth ; `prepare_business_subscription_change` : vérifier une pause, reprise ou annulation dans Heth | | `heth:obs:read` | `get_obs_widget`, `list_obs_events` : réglages et événements entrants | | `heth:obs:configure` | `prepare_obs_connection`, `update_obs_widget` : lien de validation dans Heth ou présentation avec confirmation dans le client IA | `prepare_obs_connection` n’accorde aucun accès et ne renvoie aucun jeton OBS. Une modification de présentation ne peut changer ni devise, ni réseau, ni destinataire, ni clés, ni droits d’accès. Consultez le [guide OBS et personnalisation](../user/obs.md), avec le code ouvert et les instructions pour les assistants de programmation. ## Durée et révocation Votre autorisation reste valable **jusqu’à sa révocation**. Les jetons techniques expirent séparément : 15 minutes pour l’accès MCP ; les jetons de renouvellement sont remplacés à chaque renouvellement et expirent après 30 jours sans renouvellement. Une reconnexion peut alors être nécessaire même si le consentement reste enregistré. Chaque requête vérifie le consentement et les droits actuels du compte. Heth utilise un jeton API distinct et limité, valable au maximum 60 secondes ; la session complète du portefeuille n’est pas transmise à MCP. Une révocation ou un retrait de droits bloque les requêtes suivantes, même avec des jetons non expirés. Les données déjà reçues par le client ne peuvent être rappelées. Dans Heth, ouvrez **Paramètres → Connexions IA**, vérifiez l’identifiant du client, l’adresse, les droits et le statut. Révoquez l’accès et confirmez dans Heth. Cela n’annule ni les paiements terminés ni les mandats de prélèvement des abonnements ; gérez-les séparément dans les [paramètres des abonnements](../user/features.md). Si une reconnexion est demandée, relancez l’autorisation depuis le client IA. Une révocation, des jetons expirés, un retrait de droits ou la réutilisation détectée d’un jeton de renouvellement peuvent arrêter l’accès. Ne transmettez jamais de phrase de récupération, de clés du portefeuille ou de session du navigateur pour réparer la connexion. Un service indisponible est une erreur, pas un compte vide ni une autorisation réussie. ## Paiements et modifications Heth impose **une confirmation distincte dans Heth pour chaque opération monétaire**. L’autorisation de connexion ne permet pas les prélèvements automatiques. Les modifications ordinaires des produits et liens de paiement nécessitent une confirmation dans le client IA. Les droits, destinataires de versements et autorisations de futurs prélèvements exigent une confirmation dans Heth. La présentation OBS suit la confirmation du client. Une annotation d’outil seule ne prouve pas que le consentement a été recueilli. Vous pouvez aussi utiliser l’[application Heth](https://app.heth.me) ou une [intégration API](../business/quick-start.md) prise en charge. ## Effectuer un transfert avec un assistant 1. Indiquez le type, le destinataire, la devise, le réseau et le montant. `hot_hot` transfère entre comptes internes, `hot_cold` vers une adresse blockchain, `cold_hot` depuis la blockchain vers votre propre compte interne et `cold_cold` entre adresses blockchain. Pour `cold_hot`, le destinataire est `self`. 2. `prepare_transfer` enregistre les conditions et renvoie un lien de vérification Heth, sans créer de paiement. Le montant et `max_debit` sont des chaînes entières exactes en unités minimales du jeton. `max_debit` limite le débit du jeton, frais de plateforme compris. Pour une source blockchain, `max_network_fee` limite les frais de gaz en wei (ETH/Base) ou sun (TRON). Base peut aussi facturer des frais de données L1. 3. Dans Heth, vérifiez le compte, le client IA, le destinataire, la source, le montant, le réseau et les plafonds de frais. Choisissez **Confirmer et envoyer dans Heth** seulement si tout est correct. Ouvrir le lien n’autorise ni n’envoie rien. La demande expire après 15 minutes. 4. Heth signe l’instruction affichée et utilise son transfert habituel. La transaction blockchain est signée sur votre appareil ou un appareil de signature connecté. Ouvrez Heth là où la source peut être signée. L’assistant ne reçoit jamais vos clés privées. 5. L’assistant utilise `get_transfer_request` pour lire la transaction initiale. Une approbation ou un traitement en cours ne signifie pas que les fonds sont arrivés. Après un délai d’attente, vérifiez le résultat initial. Réutilisez la même `request_id` et les mêmes conditions pour répéter une préparation ; ne créez pas un second transfert pour vérifier le premier. La révocation bloque le démarrage de nouveaux transferts. Une transaction déjà acceptée pour exécution peut encore aboutir : révoquer la connexion IA n’annule pas un transfert blockchain accepté. ## Produits, liens et abonnements L’assistant présente les modifications ordinaires de produits ou de liens de paiement pour confirmation dans le client IA. Prix et montants sont des chaînes entières en unités minimales ; les quantités sont des entiers positifs. Une `request_id` stable évite les modifications en double lors d’une nouvelle tentative. Ces outils ne modifient ni routage, ni bénéficiaires de versements, ni clés, ni droits d’accès. Supprimer un produit ou un lien ne rembourse pas un paiement antérieur. `request_business_subscription` crée une demande à vérifier par le payeur dans Heth. La demande seule ne donne aucun droit de prélèvement futur et ne crée aucun paiement. Avant de signer, le payeur vérifie montant, fréquence et premier prélèvement. `list_business_subscription_requests` affiche les demandes ; `get_business_subscription` et `list_business_subscriptions` lisent les accords existants. `prepare_business_subscription_change` renvoie l’écran Heth pour suspendre, reprendre ou annuler un accord. Rien ne change avant la confirmation du propriétaire. La reprise permet les prélèvements programmés couverts par l’autorisation existante. L’annulation arrête les prélèvements futurs sans rembourser ceux déjà effectués. De nouvelles conditions nécessitent un nouvel accord du payeur. ## fr: Authentification et clés API Source: https://docs.heth.me/markdown/fr/business/authentication.md --- title: "Authentification et clés API" last_update: date: 2026-10-20 --- # Authentification et clés API ## Émettre et révoquer une clé 1. Connectez-vous à [Heth](https://app.heth.me) et ouvrez **Entreprise**. 2. Ouvrez l’intégration avec **Se connecter**. 3. Dans **Intégration API**, utilisez **+**. 4. Stockez la clé comme secret de l’intégration serveur. 5. Pour révoquer, supprimez son entrée. Mettez l’intégration à jour lors du remplacement. N’utilisez pas de clé provenant d’un exemple ou d’une capture. Les exemples emploient des placeholders. ## En-têtes | En-tête | Usage | | --- | --- | | `x-api-key` | Requis pour l’authentification par clé | | `Content-Type: application/json` | Requis pour envoyer du JSON | Pour `https://app.heth.me`, la passerelle Heth fournit le contexte d’organisation. Cette règle est propre à cet hôte, pas à toute URL de plateforme. La clé est liée au compte et à ses droits. ## Clés et sessions utilisateur L’intégration des transactions accepte une clé. Les fonctions interactives peuvent exiger la session Bearer de l’utilisateur ; une clé ne donne pas automatiquement accès aux portefeuilles, profil, @noms et fonctions commerciales. Les sessions client d’abonnement sont une autorisation distincte. Ne substituez pas les types de jetons et ne placez pas de seed dans la configuration. Voir [fonctions](capabilities.md) et [erreurs](errors.md). Demandez seulement les droits nécessaires. ## fr: Fonctions commerciales et disponibilité Source: https://docs.heth.me/markdown/fr/business/capabilities.md --- title: "Fonctions commerciales et disponibilité" last_update: date: 2026-10-20 --- # Fonctions commerciales et disponibilité Utilisez les fonctions activées pour votre compte. Un endpoint de plateforme ne garantit pas l’accès pour votre compte, réseau ou route. | Fonction | Conditions | | --- | --- | | Paiements et versements | API des transactions, route configurée, instrument et environnement autorisés | | Lien de réception Heth | URL créée dans l’application ; son partage ne crée pas de débit | | Liens gérés et produits | Ressources commerciales distinctes avec contrôle des droits | | Abonnements du commerçant | Facturation aux clients avec moyen compatible et autorisation du client | | Propres mandats du payeur | Autorisation client séparée, approbation ou révocation explicite | | Remboursement ou annulation | Seulement si la transaction et le moyen le permettent ; un transfert blockchain n’est pas arbitrairement réversible | | Portefeuilles, @noms, cartes-cadeaux, webhooks | Session utilisateur et confirmation supplémentaire possibles | | Dons | Flux plateforme/auteur avec destinataire, minimum, frais et expiration propres | Le registre public fournit une configuration, pas le droit de payer avec tous les actifs. Vérifiez actif, réseau et configuration effective. USDT/ETH et USDT/TRX ne sont pas interchangeables. ## Limites de la référence La [référence](../transactions/overview.md) décrit les formats documentés. N’obtenez pas de droits opérateur et ne modifiez pas terminaux ou routage pour contourner un refus. Contactez le support avec l’identifiant si une route manque. Le [guide de connexion IA](../ai/mcp.md) explique les autorisations et les confirmations des fonctions disponibles pour votre compte. ## fr: Erreurs, statuts et répétitions Source: https://docs.heth.me/markdown/fr/business/errors.md --- title: "Erreurs, statuts et répétitions" last_update: date: 2026-10-20 --- # Erreurs, statuts et répétitions Vérifiez HTTP et `status`. Un 200 ou 201 peut contenir une transaction refusée ou en attente. | Résultat HTTP | Action | | --- | --- | | 400 / 422 | Vérifier champs, types, échelle, environnement et destinataire ; ne pas répéter indéfiniment une requête inchangée invalide | | 401 | Vérifier identifiants, validité et hôte | | 403 | Droits insuffisants ; ne pas changer automatiquement compte ou environnement | | 404 | Vérifier identifiant et contexte ; ne prouve pas l’absence dans un autre compte | | 409 | Examiner le conflit et retrouver l’opération initiale | | 429 | Respecter `Retry-After` s’il existe ; limiter les répétitions de lecture | | Délai dépassé / 5xx | Résultat possiblement inconnu ; rechercher l’opération par `id` ou `txid` avant renvoi | Les formats d’erreur varient selon l’endpoint. Utilisez les codes machine documentés quand disponibles ; `error_description` est un texte non stable. Supprimez identifiants secrets et données de paiement des journaux. ## Résultats - `charged` : opération réussie. - `rejected` ou `failed` : vérifier raison et opération initiale ; aucun succès confirmé. - `refunded` ou `reversed` : résultat différent d’un nouveau paiement réglé. - Attente, action requise ou statut inconnu : afficher l’état et l’action nécessaire. Ni statut inconnu ni horodatage ne prouvent un succès. Vérifiez par [GET transaction](../transactions/get_transaction.md). Une répétition de la même instruction conserve sa `txid`. Échec de livraison webhook et échec du paiement sont distincts. ## fr: Démarrer une intégration API Source: https://docs.heth.me/markdown/fr/business/quick-start.md --- title: "Démarrer une intégration API" last_update: date: 2026-10-20 --- # Démarrer une intégration API Utilisez une clé de votre propre compte. Lisez [authentification](authentication.md), [montants et statuts](../field_conventions.md) et [fonctions commerciales](capabilities.md). ## Vérifier l’accès sans déplacer de fonds Conservez `HETH_API_KEY` dans le stockage de secrets, jamais dans le code, navigateur, URL ou conversation IA. Cette requête lit les transactions du compte sans déplacer de fonds. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'limit=10' \ --data-urlencode 'order_by=started' ``` Un tableau `data` vide est valide. En cas de réponse 401 ou 403, vérifiez l’authentification et les droits du compte. ## Premier paiement 1. Vérifiez les routes de paiement activées pour votre compte et obtenez les coordonnées du destinataire ou de l’instrument de paiement. 2. Choisissez l’[exemple de transaction](../transactions/overview.md) adapté et remplacez chaque champ fictif par les données vérifiées de votre opération. 3. Utilisez un petit montant : avec USDT à six décimales, `"1000000"` représente 1 USDT. 4. Créez et enregistrez une `txid` unique avant l’envoi. 5. Envoyez une fois, conservez l’`id` et [vérifiez le statut](../transactions/get_transaction.md). 6. En cas de délai dépassé, recherchez la `txid` initiale ou répétez la requête identique avec celle-ci. Ne créez pas de nouvel identifiant. L’envoi d’une demande de paiement peut déplacer des fonds réels. Vérifiez le destinataire, le montant, la devise, le réseau et les frais avant l’envoi. Une clé API autorise uniquement les opérations disponibles pour son compte. ## fr: Produits, liens gérés et abonnements Source: https://docs.heth.me/markdown/fr/business/resources.md --- title: "Produits, liens gérés et abonnements" last_update: date: 2026-10-20 --- # Produits, liens gérés et abonnements Ces ressources commerciales appartiennent au compte. Clé API ou Bearer partenaire et fonctions activées sont requis. Une clé n’active pas de route. Voir [authentification](authentication.md). Pour lecture et suppression, env est un filtre query. Pour création et modification de produits/liens, placez env dans le corps JSON. Le propriétaire est déterminé par l’accès ; ne fournissez pas une autre partner_id. Les prix des ressources peuvent être des entiers propres à l’endpoint ; amount des transactions reste une chaîne d’entier exacte. ## Produits ```http GET /api/v1/products?env=prod&limit=10 GET /api/v1/products/{id}?env=prod POST /api/v1/products PUT /api/v1/products/{id} DELETE /api/v1/products/{id}?env=prod ``` Un produit définit header, text, price, qty et currency ; ce n’est pas un paiement. Les listes renvoient data/total, les détails et la création du produit data. Le prix d’exemple est 1 USDT avec decimals=6. ```json { "env": "prod", "header": "Example item", "text": "Example item", "price": 1000000, "qty": "1", "currency": "USDT" } ``` ## Liens de paiement gérés ```http GET /api/v1/links?env=prod&limit=10 POST /api/v1/links PUT /api/v1/links/{id} DELETE /api/v1/links/{id}?env=prod ``` Les liens sont des ressources serveur avec montant, configuration de paiement et produits facultatifs. Utilisez URL/paramètres de formulaire retournés, sans inventer d’adresse. Le lien de réception Heth créé localement est distinct. Supprimer un lien ne rembourse pas une opération déjà réglée. ## Abonnements du commerçant ```http GET /api/v1/recurrents?env=prod&limit=10 GET /api/v1/recurrents/{id}?env=prod POST /api/v1/recurrents PUT /api/v1/recurrents/{id} POST /api/v1/recurrents/{id}/pause POST /api/v1/recurrents/{id}/resume POST /api/v1/recurrents/{id}/cancel ``` Un abonnement repose sur un paiement initial réussi du compte. POST /recurrents accepte payment_id et recurrent ; interval vaut daily, weekly, monthly ou yearly, period compte les intervalles. L’environnement est hérité du paiement initial. Le payeur doit autoriser le moyen et les débits récurrents. Créer un abonnement ne prouve pas un mandat utilisable. Actions : `POST /recurrents/{id}/pause`, /resume et /cancel. Vérifiez le statut ; annuler les prochains débits ne rembourse pas les précédents. Le payeur Heth gère ses propres mandats crypto avec sa session de portefeuille dans Paramètres → Subscription mandates, si cette fonction est activée. Ils sont distincts des abonnements commerçants. ## fr: Intégration webhook Source: https://docs.heth.me/markdown/fr/business/webhooks.md --- title: "Intégration webhook" last_update: date: 2026-10-20 --- # Intégration webhook Un webhook signale un événement à votre URL. Vérifiez l’état de référence par [GET transaction](../transactions/get_transaction.md). ## Configurer le destinataire Dans Heth, définissez une URL que vous contrôlez, le secret et activez la livraison. Modifier l’URL change le destinataire des événements du compte. Protégez l’endpoint et évitez les redirections vers des tiers. La configuration nécessite la session utilisateur ; la clé transactionnelle ne suffit pas automatiquement. ## Traiter les événements 1. Vérifiez signature et protection contre les répétitions selon le contrat ci-dessous. 2. Enregistrez les identifiants sans champs sensibles. 3. Traitez de façon idempotente : une livraison double ou tardive ne doit pas créer de paiement. 4. Récupérez la transaction avec vos identifiants et rapprochez le statut. 5. Retournez la réponse prévue par le contrat de livraison. Une notification push n’est pas un webhook et ne garantit pas la livraison. Cet aperçu ne promet ni ordre, ni intervalles de répétition, ni authentification identique pour toutes les intégrations. Obtenez le contrat effectif avant l’automatisation en production. ## Format du webhook du compte Ce format concerne les webhooks configurés dans Heth. Les autres callbacks peuvent différer. Avec un secret non vide, les en-têtes comprennent x-webhook-signature (HMAC-SHA256 hex), x-webhook-timestamp (secondes Unix) et x-webhook-event-id. Vérifiez le HMAC de timestamp + "." + les octets HTTP bruts avec le secret ; ne re-sérialisez pas le JSON avant vérification. Comparez timestamp du corps signé et en-tête, refusez un écart supérieur à 5 minutes, comparez la signature en temps constant et dédupliquez par event_id. Les répétitions conservent event_id avec nouvel horodatage/signature. Sans secret, les en-têtes de signature peuvent manquer ; définissez le secret avant automatisation. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` L’enveloppe contient event_id, timestamp, type et data. Les événements de transaction comprennent tx_id, txid, type, status, amount, currency et event_type. amount peut être un entier JSON : utilisez un parseur sans perte. donation peut s’ajouter pour un don. Après vérification et enregistrement, répondez HTTP 2xx ; une event_id vérifiée répétée ne doit pas répéter l’action. Confirmez toujours la transaction par GET. ## fr: Conventions de champs & Glossaire Source: https://docs.heth.me/markdown/fr/field_conventions.md --- title: Conventions de champs & Glossaire last_update: date: 2026-10-20 --- # Conventions de champs & Glossaire ## En-têtes de requête | En-tête | Requis | Définition | | ------- | ------ | ---------- | | x-api-key | Oui | Clé API émise dans l'application (section « Business »). L'organisation est déterminée à partir de l'hôte de la requête | | Content-Type | Oui (POST) | `application/json` pour les requêtes de création | ## Montant & Devise | Terme | Définition | | ----- | ---------- | | amount | Chaîne d'un entier en unités mineures | | amount_with_fee | Montant incluant la commission | | currency | Code devise / token (USDT) | | currency_dest | Devise de destination pour conversion (FX). Optionnel ; par défaut égal à currency | ## Identifiants | Terme | Définition | | ----- | ---------- | | id | UUID interne de transaction | | txid | Identifiant texte d’une opération fourni par le client ; UUID pratique mais non obligatoire | ## Routage & Environnement | Terme | Définition | | ----- | ---------- | | route | Alias de traitement configuré | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | ## Statuts | Statut | Signification | | ------ | ------------ | | created | Acceptée, en attente | | new | État initial avant le début du traitement | | authorizing | Autorisation en cours | | pre_authorized_3ds | En attente d'authentification 3DS | | action_required | Action supplémentaire requise (3DS / autorisation additionnelle) | | charging | En cours | | payment_suspended | Transaction entrante temporairement suspendue | | payout_suspended | Transaction sortante temporairement suspendue | | charged | Terminée avec succès (terminal) | | reversed | Débit annulé (terminal) | | refunded | Remboursée (terminal) | | rejected | Rejetée (terminal) | | failed | Échouée (terminal) | Statuts terminaux : `charged`, `reversed`, `refunded`, `rejected`, `failed`. Parcours typique : `created → charging → charged`. ## Temps | Champ | Signification | | ----- | ------------ | | started | Horodatage de début (ISO) | | finished | Horodatage de fin (ISO) | ## money_storage | Champ | Signification | | ----- | ------------ | | network | Réseau blockchain | | type | Type d'instrument | | wallet_id | Identifiant de wallet | | cardnumber | Numéro de carte virtuelle | | cvv | CVV virtuel | | exp_month / exp_year | Expiration | | cardholder | Titulaire | ## Erreurs | Champ | Signification | | ----- | ------------ | | error_description | Message d'erreur (non stable) | ## Idempotence Utilisez un `txid` unique (idempotent) par opération et conservez-le avant l’envoi. Sa valeur est une chaîne ; le format UUID est pratique, sans être obligatoire. Répétez la même instruction avec le même identifiant dans le même compte et environnement. Ne le réutilisez pas pour un autre montant ou destinataire. Après un délai dépassé, retrouvez l’opération initiale plutôt que de créer un nouveau paiement. ## Polling Répétez la lecture avec attente bornée, par exemple 1s → 2s → 4s → 8s et un budget de 30s. Arrêtez à un état final connu ou à l’expiration du budget. Conservez `id`/`txid` et affichez attente ou résultat inconnu après dépassement. Un statut inconnu ne prouve pas un succès. Voir [erreurs](business/errors.md). ## Webhook Informative uniquement — confirmer par GET. ## Échelle des montants Les montants sont des chaînes d’entiers en unités mineures, sans virgule flottante. Obtenez les décimales par devise, réseau et environnement avec `GET https://app.heth.me/api/v1/contracts?env=prod`. USDT/ETH et USDT/TRX utilisent actuellement 6 décimales : 1 USDT = `"1000000"`, 0,25 USDT = `"250000"`. ETH en utilise 18, pas tous les jetons Ethereum. Arrêtez la conversion si l’échelle est inconnue. Voir le [schéma API](/openapi.json). ## fr: Utiliser Heth.me : portefeuilles, virements et paiements Source: https://docs.heth.me/markdown/fr/intro.md --- slug: "/" sidebar_position: 1 title: "Portefeuilles, virements et API de paiement" sidebar_label: "Bien démarrer" description: "Configurer Heth.me, transférer des USDT, payer par QR et encaisser des paiements. Guides utilisateurs, intégration commerciale et référence API." last_update: date: 2026-10-20 --- # Utiliser Heth.me : portefeuilles, virements et paiements Découvrez comment configurer un compte Heth.me, recevoir et transférer des fonds, payer des achats et intégrer les encaissements. Les guides utilisateurs expliquent l’application ; la référence API décrit les requêtes d’intégration. ## Démarrer avec le portefeuille - [Créer ou restaurer un compte](user/wallets.md) et comprendre comptes crypto et soldes. - [Recevoir, transférer ou retirer des fonds](user/transfers.md), choisir réseau et signature. - [Payer ou encaisser par QR](user/payments.md), partager un lien de réception. - [Utiliser @noms, cartes-cadeaux et dons](user/features.md), configurer les notifications. - [Protéger l’accès au compte](user/security.md) et comprendre les limites hors ligne. Les USDT sur Ethereum et TRON utilisent des coordonnées différentes. Vérifiez actif, réseau, destinataire et montant avant confirmation. ## Intégrer les paiements professionnels Commencez par une [requête de lecture sans déplacement de fonds](business/quick-start.md), puis choisissez : - [Authentification et clés API](business/authentication.md). - [Paiements, versements et statut](transactions/overview.md). - [Produits, liens de paiement et abonnements](business/resources.md). - [Webhooks : signature et traitement](business/webhooks.md). - [Montants et identifiants](field_conventions.md), [erreurs et répétitions](business/errors.md). Les fonctions dépendent des [droits du compte](business/capabilities.md). Un succès HTTP ne confirme pas un paiement : vérifiez la transaction d’origine. ## Connecter une IA à Heth.me [Connectez votre assistant IA avec Heth MCP](ai/mcp.md) pour utiliser votre compte et ses fonctions professionnelles disponibles. Vous choisissez les permissions et confirmez chaque opération monétaire dans Heth. Le guide explique la connexion, les virements, les modifications professionnelles, OBS et la révocation. Les intégrations IA disposent du [schéma API partiel](/openapi.json), de l’[index](/llms.txt) et du [texte complet](/llms-full.txt). Consultez l’API pour les soldes, droits et résultats actuels. ## Application et assistance [Ouvrir Heth.me](https://app.heth.me) · [Contacter le support](https://t.me/hethmesupport_bot) ## fr: Abonnements et paiements automatiques Source: https://docs.heth.me/markdown/fr/subscriptions.md --- title: Abonnements et paiements automatiques --- # Abonnements et paiements automatiques Un commerçant peut demander à un utilisateur Heth.me d'autoriser des paiements récurrents. Le payeur vérifie et signe les conditions avec son HethWallet habituel déverrouillé. Aucun compte email ni accès séparé au Customer Portal n'est nécessaire. Les paiements débitent le **solde du compte Heth** dans la devise et le réseau convenus. ## Pour le payeur 1. Ouvrez **Paramètres → Abonnements et paiements automatiques**. Les nouvelles demandes sont séparées des abonnements existants. 2. Vérifiez le commerçant, le montant par paiement, la devise/le réseau et la période. Le lien de confirmation ouvre le même écran. Un portefeuille verrouillé demande son PIN habituel, puis revient à la demande. 3. Choisissez **Confirmer l’abonnement** ou **Refuser**. Ouvrir un lien ou recevoir une notification n'accorde aucune autorisation. 4. Après accord, le premier paiement est planifié. La liste affiche le montant, la période et la date du prochain prélèvement ; en cas de nouvelle tentative après échec, elle affiche sa date. 5. Révoquez l'abonnement pour arrêter les futurs prélèvements. Cela ne rembourse pas les paiements déjà effectués. La confirmation enregistre l'accord et planifie un paiement ; elle ne signifie pas que le paiement a réussi. Vérifiez le statut de la transaction. Le solde doit être suffisant au moment de l'exécution. ## Notification des nouvelles demandes Pour un payeur identifié, le serveur envoie une notification de demande d’abonnement aux appareils enregistrés pour les push, avec le lien `/subscriptions/confirm/?env=`. Une entrée est aussi conservée sous la cloche des notifications, même si aucun appareil ne peut recevoir le push. Les demandes en attente restent accessibles dans **Paramètres → Abonnements et paiements automatiques**. Les PWA installées utilisent le web push. Heth.me pour iOS et Android, à partir de la version 1.0.0 (build 5), utilise les notifications système. Activez les notifications dans le portefeuille et autorisez-les dans les réglages de l’appareil. Toucher une demande d’abonnement ouvre son écran de confirmation ; un portefeuille verrouillé demande d’abord le PIN habituel ou une clé d’accès disponible. Recevoir ou ouvrir une notification n’autorise pas l’abonnement. Si la notification n’arrive pas, ouvrez les demandes en attente ou le lien fourni par le commerçant. ## Pour le commerçant Dans HethWallet, ouvrez **Business → Abonnements et paiements automatiques**. Indiquez l'adresse du portefeuille, le `@username` ou le numéro de carte Heth du payeur, le nom de l'abonnement, le montant par paiement, la devise/le réseau et la période. Envoyez la demande et copiez son lien de confirmation. Vous pouvez consulter vos demandes et annuler celles qui sont encore en attente. L'opérateur doit activer les abonnements Heth pour l'organisation et configurer un circuit de paiement fonctionnel. Créer une demande n'autorise aucun débit. ## Créer une demande par API Utilisez la clé API du commerçant ou sa session Bearer partenaire habituelle. Sur `app.heth.me`, l'organisation est déterminée par le domaine. Une clé en lecture seule ne peut ni créer ni annuler de demande. ```bash curl -X POST 'https://app.heth.me/api/v1/heth/subscription-requests' \ -H "x-api-key: $HETH_API_KEY" \ -H 'Content-Type: application/json' \ -d '{ "request_id": "b56b2c66-4ae5-4cb9-92ea-7a3297b72b55", "payer": "@alice", "description": "Monthly membership", "amount": "1000000", "currency": "USDT", "network": "ETH", "interval": "monthly", "period": 1, "env": "prod" }' ``` | Champ | Description | Type | Exemple | | --- | --- | --- | --- | | `request_id` | UUID unique idempotent. Réutilisez-le avec les mêmes conditions pour réessayer la même demande. | String | `b56b2c66-4ae5-4cb9-92ea-7a3297b72b55` | | `payer` | Adresse du portefeuille, nom d'utilisateur ou numéro de carte Heth. | String | `@alice` | | `description` | Nom de l'abonnement : 1–250 caractères sans saut de ligne. | String | `Monthly membership` | | `amount` | Entier positif dans les unités minimales du token. Pour USDT à 6 décimales, `1000000` signifie 1 USDT. | String | `1000000` | | `currency`, `network` | Paire token/réseau activée dans l'environnement choisi. Réseaux : `ETH`, `TRX`, `BASE`. | String | `USDT`, `ETH` | | `interval` | `daily`, `weekly`, `monthly` ou `yearly`. | String | `monthly` | | `period` | Nombre d'intervalles de 1 à 365 ; valeur par défaut 1. | Number | `1` | | `env` | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | String | `prod` | HTTP `201` renvoie directement la demande, dont `id`, `status`, `amount_decimals`, `confirm_url`, `expires_at`, `subscription_id` et `next_charge_at`. Les demandes expirent après sept jours. La création réussie ne révèle pas si le payeur indiqué existe ; seul le destinataire réel peut lire et approuver la demande. ## Opérations API Tous les chemins ci-dessous commencent par `/api/v1`. Les opérations du commerçant nécessitent sa clé API ou sa session Bearer partenaire. | Méthode et chemin | Fonction | | --- | --- | | `POST /heth/subscription-requests` | Créer une demande. | | `GET /heth/subscription-requests?env=prod&limit=50` | Lister les demandes du commerçant dans `data` et `total`. | | `POST /heth/subscription-requests/:id/cancel` | Annuler une demande en attente ; corps `{"env":"prod"}`. | Pour la première page, omettez `page`. Utilisez `page=1` pour la suivante, puis incrémentez la valeur ; `limit` fixe la taille des pages. Les opérations du portefeuille nécessitent la session Bearer habituelle du payeur. La clé API du commerçant ne peut pas approuver à sa place. | Méthode et chemin | Fonction | | --- | --- | | `GET /heth/subscriptions?env=prod&limit=50` | Abonnements du payeur dans `data`/`total`, demandes en attente dans `requests`/`requests_total`. | | `GET /heth/subscription-requests/:id?env=prod` | Lire la demande reçue et le message canonique `message` à signer. | | `POST /heth/subscription-requests/:id/confirm` | Après vérification des conditions exactes, approuver avec `{"signature":"","env":"prod"}`. | | `POST /heth/subscription-requests/:id/reject` | Refuser ; corps `{"env":"prod"}`. | | `POST /heth/subscriptions/:id/revoke-mandate` | Arrêter les futurs prélèvements ; corps `{"env":"prod"}`. | La signature lie le commerçant, le payeur, l'organisation, l'environnement, la description, le montant et son échelle, la devise/le réseau, l'intervalle et la période, la règle du premier paiement, le nonce et l'expiration. Modifier les conditions exige une nouvelle demande et un nouvel accord. Réessayer une confirmation ou un paiement planifié ne peut pas débiter deux fois la même période. Les dates API sans fuseau sont en UTC ; l'application affiche l'heure locale de l'appareil. ## Statuts et erreurs Statuts de demande : `pending`, `signed`, `rejected`, `expired`. Une demande approuvée contient un `subscription_id`. Suivez l'exécution réelle des paiements avec l'API des transactions et les webhooks configurés. `401` indique une authentification absente/invalide ; `403`, des abonnements désactivés ou une clé API en lecture seule. Une demande inaccessible renvoie `404`. `422` indique des conditions invalides, un UUID réutilisé avec d'autres conditions, une signature invalide ou une demande expirée/fermée. Le commerçant ne peut pas modifier les conditions signées d'un abonnement actif sans nouvel accord du payeur. ## fr: Paiement agrégé (encaissement pour le marchand) Source: https://docs.heth.me/markdown/fr/transactions/aggregator_payment.md --- title: Paiement agrégé (encaissement pour le marchand) last_update: date: 2026-10-20 --- # Paiement agrégé (encaissement pour le marchand) Exemple : `"1000000"` représente 1 USDT avec decimals=6. Remplacez tous les champs fictifs par les coordonnées vérifiées du destinataire et de l’instrument. Cette requête peut déplacer des fonds réels. Vérifiez et autorisez explicitement l’opération avant l’envoi. Voir [démarrage](../business/quick-start.md). Ce type de transaction permet à un Agrégateur de services de paiement d'encaisser les paiements des Clients pour le compte d'un Marchand intégré. Les fonds sont débités du Payeur puis répartis automatiquement : le Marchand reçoit le montant net après commission, l'Agrégateur reçoit sa commission. ## Flux métier 1. Le Marchand s'onboarde auprès de l'Agrégateur. 2. L'Agrégateur demande au Marchand de créer un wallet dans heth.me et de fournir la `wallet_id`. 3. Avec son propre API key, l'Agrégateur crée une transaction `payment` en indiquant le wallet marchand dans `money_storage_merchant` et la carte virtuelle du payeur dans `money_storage`. 4. Une fois la transaction réussie, les soldes du Payeur, du Marchand et de l'Agrégateur sont mis à jour en une seule étape. 5. Le statut est consulté via la méthode standard de récupération d'une transaction (polling avec la même clé API). ## Exemple de requête ```bash curl --location --request POST 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage_merchant": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "08", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Paiement", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## Référence des champs | Champ | Description | Type | Exemple | | ----- | ----------- | :--- | ------- | | amount | Montant (entier en unités mineures, en chaîne) | String | 1000000 | | currency | Devise (par défaut USDT) | String | USDT | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | String | prod | | type | Type de transaction (payment) | String | payment | | route | Route de traitement (doit correspondre au mapping configuré) | String | hot_hot_ETH | | money_storage_merchant | Descripteur du wallet marchand | Object | | | > wallet_id | Identifiant du wallet marchand | String | YOUR_WALLET_ID | | > network | Réseau blockchain (TRX ou ETH) | String | ETH | | > type | Type d'interaction (ex. p2p_proxy) | String | p2p_proxy | | > currency | Devise de règlement marchand (par défaut USDT) | String | USDT | | money_storage | Instrument de paiement du payeur | Object | | | > network | Réseau blockchain (TRX ou ETH) | String | ETH | | > type | Type d'instrument (bank_card) | String | bank_card | | > currency | Devise du payeur (par défaut USDT) | String | USDT | | > cardnumber | Numéro de carte virtuelle | String | YOUR_CARD_NUMBER | | > cvv | CVV de la carte virtuelle | String | YOUR_CVV | | > exp_month | Mois d'expiration | String | 08 | | > exp_year | Année d'expiration | String | 2026 | | > cardholder | Titulaire de la carte | String | John Doe | | description | Description | String | Paiement | | txid | Identifiant de transaction idempotent (String) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## Notes * La commission de l'Agrégateur est appliquée automatiquement selon la configuration de la clé API. * `route` doit correspondre à une route active pour cette clé API. * Utilisez des valeurs `txid` idempotentes pour éviter les doublons. * Récupérez le statut via l'endpoint standard jusqu'à l'état final. ## fr: Récupérer le statut d'une transaction Source: https://docs.heth.me/markdown/fr/transactions/get_transaction.md --- title: Récupérer le statut d'une transaction last_update: date: 2026-10-20 --- # Récupérer le statut d'une transaction Retourne l'état actuel d'une transaction via son `id` (API key). ## Requête ``` GET /api/v1/transactions/{transaction_id}?env=prod Header: x-api-key: ``` `{transaction_id}` est l'`id` interne (UUID) de la transaction, en segment de chemin. ## Champs de réponse | Champ | Description | | ----- | ----------- | | amount | Montant (unités mineures) | | amount_with_fee | Montant incluant la commission | | amount_dest | Montant de destination en cas de conversion (unités mineures), si applicable | | currency | Devise | | currency_dest | Devise de destination en cas de conversion, si applicable | | description | Description | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | | error_description | Détail erreur si `rejected` | | finished | Horodatage de fin (ISO) | | id | UUID interne | | route | Route de traitement utilisée | | started | Horodatage de début (ISO) | | status | Statut (voir la section « Statuts » du Glossaire ; created, charging, charged, refunded, rejected, failed) | | txid | Identifiant externe client | | type | Type (payment / payout) | | widget_url | URL du widget si applicable | | simple_auth_redirect_url | URL d'authentification 3DS/additionnelle | ## Exemple ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## Notes * Backoff exponentiel conseillé pour le polling. * Vérifiez `status` ; `finished` seul ne prouve pas le résultat. * Utilisez des `txid` idempotents. ## Retrouver par identifiant externe ```bash curl --get 'https://app.heth.me/api/v1/transactions/example-order-001' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'by=txid' \ --data-urlencode 'env=prod' ``` ## fr: Lister les transactions Source: https://docs.heth.me/markdown/fr/transactions/list_transactions.md --- title: "Lister les transactions" last_update: date: 2026-10-20 --- # Lister les transactions Lisez les transactions de votre compte. La réponse est un objet avec data et cursor, pas un tableau racine. Limitez la période et précisez l’environnement. Voir [démarrage](../business/quick-start.md), [authentification](../business/authentication.md) et [erreurs](../business/errors.md). ```http GET /api/v1/transactions?env=prod&order_by=started&limit=30 x-api-key: YOUR_API_KEY ``` ## Filtres | Filtre | Sens | | --- | --- | | `started_from / updated_from` | Début de période ISO 8601 | | `started_to / updated_to` | Fin de période ISO 8601 | | `type` | Type de transaction | | `status` | Statut | | `txid` | Identifiant externe exact sous forme de chaîne | | `order_by` | started ou updated | | `limit` | Taille 1–500, défaut 100 | | `env` | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | | `cursor` | Horodatage reçu dans cursor_value | ```json { "data": [ { "id": "c033ceaa-3726-4479-8be3-c9af8a0b2336", "txid": "example-order-001", "type": "payment", "status": "charged", "amount": "1000000", "currency": "USDT", "env": "prod", "started": "2026-10-01T10:00:00Z" } ], "cursor": { "cursor_field": "started", "cursor_value": "2026-10-01T10:00:00Z" } } ``` ## Page suivante Envoyez cursor.cursor_value reçu comme paramètre texte cursor, pas l’objet complet. Gardez environnement, filtres et order_by identiques. Avec order_by=updated, cursor_field peut être updated_at. Arrêtez si data est vide ou si le curseur n’avance plus. Rapprochez par id si des transactions changent pendant le parcours. ```bash curl --get 'https://app.heth.me/api/v1/transactions' \ --header "x-api-key: $HETH_API_KEY" \ --data-urlencode 'env=prod' \ --data-urlencode 'order_by=started' \ --data-urlencode 'limit=30' \ --data-urlencode 'cursor=2026-10-01T10:00:00Z' ``` ## fr: API des transactions Source: https://docs.heth.me/markdown/fr/transactions/overview.md --- title: "API des transactions" last_update: date: 2026-10-20 --- # API des transactions Choisissez le flux de la route activée pour votre compte. Ces exemples utilisent des instruments virtuels Heth et ne promettent pas de paiements avec toutes les cartes bancaires externes. Voir [démarrage](../business/quick-start.md), [authentification](../business/authentication.md) et [erreurs](../business/errors.md). ## Création - [Paiement par carte virtuelle](pcn.md) - [Versement sur carte virtuelle](wcn.md) - [Versement par identifiant de portefeuille](wid.md) - [Paiement agrégé](aggregator_payment.md) ## Lecture - [Lire une transaction](get_transaction.md) - [Lister les transactions](list_transactions.md) ## Référence - [Montants, identifiants et statuts](../field_conventions.md) ## fr: Paiement par numéro de carte Source: https://docs.heth.me/markdown/fr/transactions/pcn.md --- title: Paiement par numéro de carte last_update: date: 2026-10-20 --- # Paiement par numéro de carte Exemple : `"1000000"` représente 1 USDT avec decimals=6. Remplacez tous les champs fictifs par les coordonnées vérifiées du destinataire et de l’instrument. Cette requête peut déplacer des fonds réels. Vérifiez et autorisez explicitement l’opération avant l’envoi. Voir [démarrage](../business/quick-start.md). Initialisation d'un paiement via carte virtuelle. ## Exemple de requête ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payment", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER", "cvv": "YOUR_CVV", "exp_month": "10", "exp_year": "2026", "cardholder": "John Doe" }, "description": "Paiement", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` | Champ | Description | Type | Exemple | | ----- | ----- | :--- | ----- | | amount | Montant de la transaction (entier en unités mineures, en chaîne) | String | 1000000 | | currency | Devise de la transaction (par défaut USDT) | String | USDT | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | String | prod | | type | Type de transaction (dans ce cas payment) | String | payment | | route | Route de transaction (doit correspondre au mappage de route) | String | hot\_hot\_ETH | | money_storage | Instrument carte | Objet | | | \>network | Réseau blockchain (TRX ou ETH) | String | ETH | | \>type | Type d'instrument (bank_card) | String | bank_card | | \>currency | Devise de l'instrument (USDT par défaut) | String | USDT | | \>cardnumber | Numéro de carte virtuelle | String | YOUR_CARD_NUMBER | | \>cvv | CVV virtuel | String | YOUR_CVV | | \>exp_month | Mois d'expiration | String | 10 | | \>exp_year | Année d'expiration | String | 2026 | | \>cardholder | Titulaire | String | John Doe | | description | Description de la transaction | String | Paiement | | txid | Identifiant de transaction idempotent (String) | String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## fr: Versement par identifiant de portefeuille Source: https://docs.heth.me/markdown/fr/transactions/pid.md --- title: "Versement par identifiant de portefeuille" last_update: date: 2026-10-20 --- # Versement par identifiant de portefeuille Cette page correspond au même flux que la référence canonique wallet_id. Utilisez sa requête et ses définitions. [Versement par identifiant de portefeuille](wid.md) ## fr: Paiement agrégé par carte virtuelle Source: https://docs.heth.me/markdown/fr/transactions/rcn.md --- title: "Paiement agrégé par carte virtuelle" last_update: date: 2026-10-20 --- # Paiement agrégé par carte virtuelle Cette page correspond au même encaissement commerçant que la référence canonique agrégée. Utilisez sa requête et ses définitions. [Paiement agrégé par carte virtuelle](aggregator_payment.md) ## fr: Retrait par numéro de carte Source: https://docs.heth.me/markdown/fr/transactions/wcn.md --- title: Retrait par numéro de carte last_update: date: 2026-10-20 --- # Retrait par numéro de carte Exemple : `"1000000"` représente 1 USDT avec decimals=6. Remplacez tous les champs fictifs par les coordonnées vérifiées du destinataire et de l’instrument. Cette requête peut déplacer des fonds réels. Vérifiez et autorisez explicitement l’opération avant l’envoi. Voir [démarrage](../business/quick-start.md). Retrait vers une carte. ## Exemple de requête ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "network": "ETH", "type": "bank_card", "currency": "USDT", "cardnumber": "YOUR_CARD_NUMBER" }, "description": "Retrait", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` | Champ | Description | Type | Exemple | | ----- | ----- | :--- | ----- | | amount | Montant de la transaction (entier en unités mineures, en chaîne) | String | 1000000 | | currency | Devise de la transaction (par défaut USDT) | String | USDT | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | String | prod | | route | Route de transaction (doit correspondre au mappage de route) | String | hot\_hot\_ETH | | type | Type de transaction (dans ce cas payout) | String | payout | | money\_storage | Objet de données du destinataire | Objet | | | \>network | Réseau blockchain (TRX ou ETH) | String | ETH | | \>type | Type d'instrument (bank\_card) | String | bank\_card | | \>currency | Devise du destinataire (par défaut USDT) | String | USDT | | \>cardnumber | Numéro de carte du destinataire | String | YOUR_CARD_NUMBER | | description | Description de la transaction | String | Retrait | | txid | Identifiant de transaction idempotent (String) | String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## fr: Retrait par ID Source: https://docs.heth.me/markdown/fr/transactions/wid.md --- title: Retrait par ID last_update: date: 2026-10-20 --- # Retrait par ID Exemple : `"1000000"` représente 1 USDT avec decimals=6. Remplacez tous les champs fictifs par les coordonnées vérifiées du destinataire et de l’instrument. Cette requête peut déplacer des fonds réels. Vérifiez et autorisez explicitement l’opération avant l’envoi. Voir [démarrage](../business/quick-start.md). Retrait vers un identifiant de portefeuille. ## Exemple de requête ```bash curl --location 'https://app.heth.me/api/v1/transactions' \ --header 'Content-Type: application/json' \ --header "x-api-key: $HETH_API_KEY" \ --data '{ "params": { "amount": "1000000", "currency": "USDT", "env": "prod", "type": "payout", "route": "hot_hot_ETH", "money_storage": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Retrait", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` | Champ | Description | Type | Exemple | | ----- | ----- | :--- | ----- | | amount | Montant de la transaction (entier en unités mineures, en chaîne) | String | 1000000 | | currency | Devise de la transaction (par défaut USDT) | String | USDT | | env | `prod` (par défaut). Conservez cette valeur à l’ouverture et à la confirmation de la demande. | String | prod | | route | Route de transaction (doit correspondre au mappage de route) | String | hot\_hot\_ETH | | type | Type de transaction (dans ce cas payout) | String | payout | | money\_storage | Objet de données du destinataire | Objet | | | \>wallet\_id | Identifiant du portefeuille du destinataire | String | YOUR_WALLET_ID | | \>network | Réseau blockchain (TRX ou ETH) | String | ETH | | \>type | Type de transaction pour les portefeuilles (dans ce cas p2p\_proxy) | String | p2p\_proxy | | \>currency | Devise du destinataire (par défaut USDT) | String | USDT | | description | Description de la transaction | String | Retrait | | txid | Identifiant de transaction idempotent (String) | String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## fr: Autres fonctions du compte Source: https://docs.heth.me/markdown/fr/user/features.md --- title: "Autres fonctions du compte" last_update: date: 2026-10-21 --- # Autres fonctions du compte Les paramètres du compte déterminent les fonctions accessibles. Leur description ne signifie pas qu’elles sont toutes activées pour chacun. ## @noms Dans les paramètres du nom, vérifiez disponibilité et prix. Choisissez le portefeuille éligible et suivez le paiement. Une réservation impayée n’est pas encore un nom de réception actif. Vérifiez durée et renouvellement ; un nom expiré ou suspendu peut ne pas être résolu. Sa libération peut être refusée pendant un paiement en cours. ## Cartes-cadeaux L’écran permet de consulter vos émissions et, selon les droits, d’émettre une carte ou d’utiliser un code. L’émission est financée par votre propre portefeuille éligible et demande confirmation. Conservez le code révélé en sécurité : sa possession peut permettre l’utilisation. Saisissez le code dans Heth ; le serveur détermine sa valeur. Une requête soumise ne confirme pas le crédit. ## Gas L’achat de gas est une opération distincte. Vérifiez source, compte destinataire, montant et réseau. Une source cold peut demander une signature. Le gas blockchain est distinct du montant de jetons transféré. ## Dons Sur la page de l’auteur, vérifiez plateforme, auteur, actif, réseau, minimum et frais. Choisissez un portefeuille Heth ou un compte externe disponible et vérifiez avant d’autoriser. Les coordonnées externes peuvent expirer. La page de résultat affiche le statut du don d’origine. ## Notifications et webhooks 1. Ouvrez **Paramètres → Notifications**, activez les notifications et confirmez la demande du système ou du navigateur. L’application mobile utilise les notifications système ; la version web utilise le service du navigateur lorsqu’il est pris en charge. 2. Si l’autorisation a été refusée, autorisez les notifications Heth dans les réglages de l’appareil ou du navigateur, rouvrez Heth et réessayez. La réception dépend aussi de la connexion et des restrictions de l’appareil. 3. Pour arrêter les notifications sur cet appareil, désactivez le même interrupteur. Cela n’annule ni les paiements, ni les abonnements, ni les connexions IA. Toucher une notification de paiement ouvre Heth. Déverrouillez le compte et vérifiez l’action demandée ; toucher la notification ne signe ni ne confirme un paiement. Vérifiez le résultat final dans l’historique des transactions. Les paramètres webhook permettent de définir votre URL de réception et un secret. Cette URL reçoit des événements du compte. Voir [webhooks](../business/webhooks.md). ## Abonnements, matériel et multisig Gérez les demandes d’abonnement et les autorisations de débit futur dans Heth. Le [guide des abonnements et paiements automatiques](../subscriptions.md) explique l’accord du payeur, les demandes du commerçant, les échéances et la révocation. L’association d’une carte et les débits futurs nécessitent votre consentement explicite. Pour un compte matériel ou multisig, vérifiez avant un virement que votre appareil et votre méthode de signature prennent en charge le réseau choisi. Dans **Paramètres → Subscription mandates**, les comptes disposant de cette fonction peuvent voir leurs propres autorisations d’abonnement crypto et les plafonds par débit. Choisissez **Revoke mandate** et confirmez dans Heth pour arrêter les débits futurs. La révocation ne rembourse pas les paiements déjà effectués. ## Widget de dons pour OBS Studio Ajoutez le widget Heth comme source Navigateur dans OBS Studio pour afficher un QR de réception, des thèmes et des alertes de paiement entrant. Créez la connexion dans **Paramètres → OBS Studio** de Heth. Ne publiez pas l’URL secrète et ne la transmettez pas à une IA. Un assistant peut lire le flux restreint et modifier les réglages d’apparence avec MCP ; les droits d’accès sont confirmés dans Heth. [Guide OBS](./obs.md). ## fr: OBS Studio : QR de réception et alertes de paiement Source: https://docs.heth.me/markdown/fr/user/obs.md --- title: "OBS Studio : QR de réception et alertes de paiement" last_update: date: 2026-10-21 --- # OBS Studio : QR de réception et alertes de paiement Le widget Heth s’ajoute à OBS Studio comme source **Navigateur**. Il affiche un QR de réception et des alertes pour les virements Heth entrants terminés. Il ne nécessite pas de plugin OBS natif et ne contrôle ni les scènes, ni l’enregistrement, ni la diffusion. Un virement entrant n’est pas automatiquement un don à un auteur ou à une plateforme. ![Aperçu du nouveau widget en anglais. Événement de démonstration ; le QR d’aperçu ne déclenche pas de paiement.](/img/obs-preview-en.png) Aperçu du nouveau widget en anglais. Événement de démonstration ; le QR d’aperçu ne déclenche pas de paiement. ## Connexion 1. Ouvrez Heth et connectez-vous au compte qui recevra les dons. 2. Ouvrez **Paramètres → OBS Studio**. Le destinataire est le compte Heth connecté. 3. Choisissez une paire devise/réseau disponible. Le montant suggéré, le texte, le thème et la langue sont facultatifs. Un montant vide laisse le payeur choisir. 4. Enregistrez l’apparence, puis confirmez la création d’une connexion OBS. Un accès distinct et restreint est créé. 5. Copiez l’URL dans une source **Navigateur** d’OBS. Commencez par **900 × 500** pixels, puis ajustez ou recadrez selon votre scène. 6. Scannez le QR avec votre téléphone. Vérifiez le destinataire, la devise et le réseau avant de confirmer un paiement. Le QR seul ne transfère pas d’argent. Le fond est transparent. Laissez le QR dégagé et assez grand pour être scanné. Vérifiez le résultat dans la scène et à la résolution reçue par les spectateurs. Le widget prend en charge le russe et l’anglais, indépendamment de la langue de Heth. ## Accès et confidentialité La connexion utilise une clé API distincte avec des droits limités à OBS. Heth la crée et l’ajoute à l’URL de connexion : vous n’avez pas à copier une clé depuis les paramètres Business. Les webhooks fonctionnent indépendamment : ils envoient les événements à votre serveur, tandis que la source Navigateur d’OBS lit directement le flux restreint du widget. Le widget standard ne nécessite pas de serveur de réception de webhooks. Une clé OBS appartient à votre compte et peut lire son flux de widget. Les autorisations MCP sont accordées séparément ; la révocation d’une connexion OBS et celle d’une connexion IA sont deux actions distinctes. L’URL de connexion contient un jeton OBS secret dans le fragment après `#`. Gardez toute l’URL privée : ne la partagez pas dans la description du direct, des captures, des exports publics de scènes ou une conversation avec l’IA. Le QR affiché contient les informations de paiement, pas ce jeton. OBS peut lire l’identifiant du destinataire, l’apparence et un flux restreint de paiements entrants. Il ne peut ni lire le solde ou l’historique complet, ni envoyer de l’argent, ni modifier les paramètres. Révoquez une connexion divulguée ou inutile dans **Paramètres → OBS Studio** et créez-en une nouvelle si nécessaire. ## Alertes Seuls les virements entrants au statut `charged` apparaissent. Les opérations sortantes, en attente ou échouées sont exclues. Le montant reçu conserve sa précision enregistrée, sans arrondi au jeton entier. Si cette précision manque, le widget n’invente pas de montant. Une nouvelle connexion commence avec les nouveaux événements. Une source active peut reprendre son curseur enregistré après une courte interruption ; la fenêtre de reprise est limitée à 24 heures. Recharger une source ne remplace pas un export d’historique. Vérifiez la réception et les détails définitifs dans l’[historique des opérations](./payments.md). ## Avec un assistant IA Avec le [MCP distant](../ai/mcp.md), un assistant autorisé peut lire les paramètres, consulter le flux restreint et proposer une connexion. Les modifications ordinaires d’apparence sont confirmées dans le client IA. Le widget connecté applique normalement les changements enregistrés sous 30 secondes. L’octroi ou la révocation d’accès et le changement de compte destinataire exigent une confirmation dans Heth. L’assistant fournit un lien vers les paramètres Heth ; il ne reçoit pas l’URL OBS secrète. Exemple : « Mets une légende anglaise et un thème minimaliste ». MCP ne contrôle pas OBS Studio lui-même. ## Votre mise en page avec l’aide de l’IA {#custom-layout} Les réglages Heth ordinaires ne nécessitent pas d’accès au code. Pour une mise en page libre, créez une copie du [widget OBS Heth public](https://github.com/Heth-me/obs-widget), sous licence MIT. Le [guide pour l’IA](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md) fournit des exemples, une carte des fichiers et des instructions d’hébergement. Le dépôt contient les instructions de compilation et d’hébergement. Un assistant de développement ayant accès à votre copie peut modifier la structure, le CSS, les polices, les couleurs et les alertes, puis vérifier un aperçu fictif et compiler le projet. Il n’a besoin ni de l’URL OBS privée ni de clés de paiement. Une version personnalisée doit être hébergée ; le dépôt seul ne fournit pas les événements de paiement. Heth MCP lit les événements et modifie les réglages d’apparence pris en charge. Il ne modifie pas un dépôt, ne compile pas votre version et ne donne pas accès à votre hébergement. Pour une mise en page HTML/CSS libre, personnalisez le projet ouvert. Le widget standard hébergé par Heth ne nécessite aucune compilation personnelle. ## Dépannage **Heth affiche 404 au lieu du widget :** mettez Heth à jour, vérifiez l’URL de la source navigateur et rouvrez-la. Si le problème persiste, contactez le support. Ne créez pas de nouvelles clés pour corriger une erreur de chargement. - **Entrée OBS absente :** mettez Heth à jour et vérifiez vos droits avec le support. N’utilisez pas de clé API générale du compte. - **QR sans alerte :** vérifiez le destinataire et le statut terminé. La source doit rester active et connectée. - **Accès désactivé :** reconnectez le widget dans Heth ; réessayer une URL révoquée ne rétablit pas l’accès. - **Mauvaise devise ou mauvais réseau :** corrigez les paramètres, attendez leur actualisation et rescannez le QR. - **Ancienne URL avec `api_key=` :** reconnectez OBS depuis les paramètres Heth et révoquez les anciennes clés devenues inutiles. ## fr: Payer et encaisser Source: https://docs.heth.me/markdown/fr/user/payments.md --- title: "Payer et encaisser" last_update: date: 2026-10-20 --- # Payer et encaisser ## Payer avec Heth Ouvrez l’écran de paiement et choisissez une méthode disponible. Un QR de payeur peut autoriser un débit : ne le présentez qu’au commerçant prévu. Vérifiez commerçant et montant si une confirmation est demandée. Ne communiquez ni phrase de récupération ni secret de paiement à un commerçant ou une IA. Certaines informations en cache et certains codes peuvent être disponibles hors ligne. Le commerçant doit être connecté pour traiter le paiement ; les virements ordinaires ne s’exécutent pas hors ligne. Voir les [limites hors ligne](security.md). ## Confirmer le montant du paiement Suivez la méthode de confirmation affichée par Heth pour ce paiement : 1. Ouvrez votre QR de payeur et montrez-le uniquement au commerçant choisi. 2. Vérifiez le montant demandé et le destinataire avant validation. 3. Si Heth demande de générer un code, revenez à la confirmation du montant après avoir affiché votre QR, saisissez le montant du paiement et générez le code actuel. 4. Communiquez ce code au caissier uniquement pour ce paiement. Il ne s’agit ni d’une phrase de récupération, ni d’un PIN, ni d’un secret de paiement réutilisable : ceux-ci restent privés. 5. Si le QR ou le code expire, ouvrez-en un nouveau et suivez l’indication actuelle. Si la confirmation n’est pas configurée, terminez sa configuration en ligne dans Heth. 6. Vérifiez le statut de l’opération d’origine. L’affichage d’un QR, la génération d’un code ou une demande de caisse ne prouvent pas seuls le paiement. ## Encaisser un paiement Heth 1. Ouvrez **Entreprise**. 2. Saisissez le montant et sélectionnez actif et réseau disponibles. 3. Scannez le QR Heth du payeur et envoyez la demande. 4. Attendez son approbation si nécessaire. 5. Seul le statut `charged` confirme le succès. Refus, attente et délai dépassé sont distincts. Conservez l’identifiant initial pour vérifier le résultat. ## Partager un lien de réception L’écran du lien génère une URL Heth avec votre identifiant, la devise et éventuellement un montant. Le payeur vérifie et autorise le virement. Partager le lien ne débite personne. Ce lien diffère d’une ressource commerciale gérée via API. Ne supposez pas qu’un lien créé localement possède registre serveur, expiration ou annulation. ## Autres fournisseurs QR Utilisez les méthodes activées pour votre compte. Un logo ou la reconnaissance d’un format QR ne prouvent pas la disponibilité de sa route de paiement. Contactez le support ; ne changez pas destinataire ou réseau pour forcer un paiement. ## fr: Sécurité et utilisation hors ligne Source: https://docs.heth.me/markdown/fr/user/security.md --- title: "Sécurité et utilisation hors ligne" last_update: date: 2026-10-21 --- # Sécurité et utilisation hors ligne ## Récupération et signature Gardez phrases et clés privées dans le portefeuille propriétaire. PIN et biométrie protègent l’accès sur l’appareil actuel, sans remplacer une sauvegarde. Ne partagez jamais seed, clé privée ou secret de paiement réutilisable avec support, commerçant ou IA. Présentez un QR à usage unique seulement au commerçant prévu. Si le mode B demande explicitement de lire un code au caissier, vérifiez d’abord ce paiement et son montant. Avant signature, vérifiez origine de la demande, destinataire, montant, devise et réseau. Connecter un compte, changer de réseau ou ouvrir une demande de signature ne termine pas un paiement. Vérifiez aussi l’écran d’un portefeuille matériel. ## Face ID / Touch ID et clés d’accès Dans **Paramètres → Face ID / Touch ID**, activez le déverrouillage biométrique si cette option est disponible, puis confirmez la demande du système. Heth utilise un identifiant WebAuthn (passkey) pour le déverrouillage local. La disponibilité dépend de l’appareil et du navigateur ; utilisez votre code PIN si la biométrie est indisponible ou annulée. Cela déverrouille Heth sur l’appareil actuel. Ce mécanisme ne remplace pas la phrase de récupération, ne restaure pas le compte sur un autre appareil et ne confirme ni une connexion IA ni un paiement. Conservez votre sauvegarde de récupération avant de changer d’appareil ou de réinstaller Heth. ## Limites hors ligne Soldes et historique en cache peuvent être périmés. Certains codes de payeur sont générés localement pour un commerçant connecté. Virements, soldes actuels et résultats confirmés nécessitent une connexion. Après reconnexion, actualisez l’historique avant toute répétition. ## Frais et assistance Vérifiez les frais de l’opération réelle. Le gas peut s’ajouter aux frais de service. Ne déduisez pas frais ou délai d’un autre type de transfert. Contactez le [support Heth](https://t.me/hethmesupport_bot) avec l’identifiant et le problème, sans secrets. Consultez la [confidentialité](https://app.heth.me/settings/legal/privacy-policy) et les [conditions](https://app.heth.me/settings/legal/terms-of-service) dans Heth. [Problèmes de paiement et statut](troubleshooting.md). ## fr: Effectuer un virement ou un retrait Source: https://docs.heth.me/markdown/fr/user/transfers.md --- title: "Effectuer un virement ou un retrait" last_update: date: 2026-10-20 --- # Effectuer un virement ou un retrait Choisissez d’abord la source : solde du portefeuille ou compte crypto. Sélectionnez ensuite destinataire, actif et réseau. Vérifiez montant, coordonnées et frais avant l’autorisation. ## Types de virement | Virement | Action | | --- | --- | | Portefeuille → portefeuille | Saisir l’identifiant ou résoudre un @username actif, puis vérifier | | Portefeuille → compte crypto | Indiquer adresse externe et réseau ; vérifier retrait et frais | | Compte crypto → portefeuille | Choisir source et portefeuille de destination ; signer la transaction préparée | | Compte crypto → compte crypto | Vérifier le destinataire externe et signer avec le portefeuille propriétaire | Virement interne et retrait blockchain diffèrent par traitement et frais. Un transfert blockchain peut nécessiter la monnaie native pour le gas. L’achat de gas est distinct : vérifiez source de financement et compte destinataire. ## Portefeuilles externes et matériels Pour une adresse watch-only, utilisez le portefeuille qui la contrôle. Le compte connecté et le réseau doivent correspondre à la source. La signature dépend du réseau, du navigateur et de l’appareil. Un lien externe peut ne pas renvoyer de hash à Heth : ouvrir un portefeuille ne confirme pas le paiement. ## Résultat incertain Vérifiez l’opération d’origine dans l’historique. Ne répétez pas un virement uniquement à cause d’un délai dépassé ou d’une déconnexion. Conservez l’identifiant et contactez le support si le statut reste incertain. Une opération en attente n’est pas un paiement terminé. [Problèmes de paiement et statut](troubleshooting.md). ## fr: Problèmes de paiement et statut des opérations Source: https://docs.heth.me/markdown/fr/user/troubleshooting.md --- title: "Problèmes de paiement et statut des opérations" description: "Retrouver un paiement Heth, vérifier une opération en attente et résoudre les problèmes de réseau, de solde ou de confirmation QR." last_update: date: 2026-10-20 --- # Problèmes de paiement et statut des opérations ## Délai dépassé : faut-il renvoyer ? 1. Rétablissez la connexion et ouvrez l’historique dans le même compte et le même environnement. 2. Retrouvez l’opération d’origine par son identifiant, son heure, son montant et son destinataire. Ouvrez ses détails s’ils sont disponibles. 3. Vérifiez son statut actuel. Si elle reste en attente ou introuvable, contactez le support avant tout nouvel envoi. L’absence de résultat ne prouve pas qu’aucun fonds n’a été débité. 4. Conservez l’identifiant d’origine. Pour une intégration API, [consultez le statut](../transactions/get_transaction.md) avec le même `txid` ; ne créez pas un nouvel identifiant pour contourner le délai dépassé. | Statut | Action | | --- | --- | | `created`, `pending`, `processing` | Traitement inachevé. Actualiser l’opération d’origine ; ne pas compter le paiement comme reçu | | `auth_required` | Ouvrir Heth et effectuer la confirmation demandée pour cette opération | | `charged` | Opération réglée. Vérifier montant, destinataire et frais dans les détails | | `rejected`, `failed` | Lire l’erreur d’origine et en résoudre la cause avant une nouvelle opération | | Statut absent ou inconnu | Résultat non confirmé : demander une clarification sans conclure à un succès ou à un échec | Un remboursement ou une contre-passation constitue un résultat distinct. Vérifiez l’opération d’origine et le crédit effectif du solde. Fermer Heth n’annule pas un transfert blockchain. ## Solde ou coordonnées de réception incorrects - Vérifiez le compte, l’actif, le réseau et l’environnement. Un Wallet interne et un Crypto Account sont des destinations différentes. - Actualisez après reconnexion : l’affichage hors ligne peut contenir des données anciennes. - Pour un dépôt externe, comparez l’adresse et le réseau du portefeuille émetteur avec les coordonnées Heth. Un transfert sur un autre réseau n’est pas automatiquement crédité à ce compte. - Si un compte froid supplémentaire manque sur un autre appareil, reconnectez son portefeuille d’origine. Voir [comptes et sauvegarde](wallets.md). ## QR ou confirmation du montant indisponible Ouvrez un nouveau QR du payeur dans Heth. Si un code est demandé, suivez les [instructions de paiement](payments.md), vérifiez le montant et utilisez le code actuel. Un QR n’est pas un reçu. Le commerçant doit être connecté. Si Heth indique que la confirmation n’est pas configurée, terminez sa configuration en ligne. ## Contacter le support Transmettez au [support Heth](https://t.me/hethmesupport_bot) l’identifiant, l’heure approximative avec fuseau horaire, l’actif/réseau, le montant et l’erreur visible. Masquez les données personnelles sans rapport sur les captures. N’envoyez jamais de phrase de récupération, clé privée, clé API, QR du payeur, code de carte cadeau ou secret de paiement réutilisable. ## fr: Démarrer et comprendre les portefeuilles Source: https://docs.heth.me/markdown/fr/user/wallets.md --- title: "Démarrer et comprendre les portefeuilles" last_update: date: 2026-10-20 --- # Démarrer et comprendre les portefeuilles Ouvrez [Heth.me](https://app.heth.me). Créez une phrase de récupération ou restaurez votre compte, puis suivez les étapes pour définir un PIN et, si disponible, le déverrouillage biométrique. Sauvegardez la phrase séparément avant de recevoir des fonds. Voir la [sécurité](security.md). ## Compte crypto et portefeuille | Objet | Signification | Autorisation | | --- | --- | --- | | Compte crypto (cold) | Adresse blockchain créée ou connectée dans l’application | Le propriétaire signe localement, avec un portefeuille externe ou matériel compatible | | Portefeuille (hot) | Solde du compte pour les paiements et virements internes | Le service traite l’opération autorisée | | Compte watch-only | Adresse ajoutée sans clé privée pour consultation | La consultation n’autorise pas la dépense ; le portefeuille propriétaire doit signer | Les comptes cold supplémentaires et leurs noms peuvent être conservés sur l’appareil. Une connexion sur un autre appareil ne restaure pas nécessairement tous les comptes ajoutés. Sauvegardez chaque compte dans son portefeuille d’origine. ## Recevoir des fonds 1. Ouvrez le compte crypto ou portefeuille voulu. 2. Vérifiez actif et réseau : USDT sur Ethereum et USDT sur TRON nécessitent des coordonnées différentes. 3. Utilisez les coordonnées ou le QR affichés. Une adresse blockchain ne remplace pas un identifiant de portefeuille interne. 4. Vérifiez l’arrivée dans l’historique. Un solde en attente n’est pas un solde disponible. Lors d’un achat sur une plateforme externe, vérifiez le réseau de retrait. La page des services d’échange fournit des liens externes ; chaque fournisseur détermine disponibilité et conditions. ## Actifs disponibles Utilisez les actifs affichés pour votre compte. Le registre global peut contenir des actifs non activés dans votre interface ou pour une opération.