# 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 the currency and network. 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-23 --- # 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. If Heth is open, an **AI connection request** notice appears at the top of the app. Choose **Review connection request**, or open the push. You can also find the request under **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. ### In Claude Code In a terminal, add Heth and start connecting: ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code registers the connection automatically and opens a browser window. Enter the one-time code from Heth there, then review and approve the permissions in the Heth app using the steps above. Keep the terminal open until connection finishes. You do not need a client identifier, client secret or wallet API key. After connection, ask Claude: “Show my wallet balances using Heth”. It can use only the permissions you approved. You can manage or revoke this connection in **Settings → AI connections** in Heth. ## Wallet balances Ask: “Show my wallet balances using Heth”. Wallet names match the app: `USDT ERC20`, `USDT TRC20`, `USDT Base`, `cNGN Base`. Each amount includes its token unit; `RUB_T`, `UZS_T` and `ZOLT` remain distinct token names. Wallet database identifiers are not displayed. The assistant receives an exact balance in token units, retaining all fractional digits and formatting guidance. For example, `1.000001 USDT` must not be shown as `1 USDT`, and a small nonzero amount must not become zero. Decimal and grouping separators follow your language. If precision is unavailable, the assistant shows a dash and explains why instead of inventing an amount. Different currencies and networks are not added together. Wallets stored only on your device are not included. ## 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. Your [payment limits](../user/payments.md#payment-limits) apply to AI-prepared internal-to-internal transfers (`hot_hot`). Heth checks the current limits and reference rates before execution. Blockchain transfers and network fees are outside these limits. An AI permission or a valid amount code cannot override the maximum. Change these settings in Heth. Display amounts with the asset and network, and label any converted equivalent as approximate; never compare raw minor-unit numbers from different assets. ## 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 | | 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 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 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. 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 parameters | 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. 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 and network 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` | Token/network pair enabled for the account. 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, 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. 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 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. Your [payment limits](payments.md#payment-limits) also apply to the total value of the gift cards you issue. A valid confirmation code does not override the maximum. ## 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-23 --- # 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. ## Payment limits {#payment-limits} Open **Settings → Amount Confirmation → Payment limits**. Limits have their own currency; the default is USDT. These limits apply only within Heth: payments using your payer QR or an amount-confirmation code, gift card issuance with that code, and internal transfers initiated through AI. They do not apply to blockchain transfers or ordinary transfers that you initiate manually. Network fees are excluded from these limits. - **Without a code, up to**: payments up to and including this value do not need an additional amount-confirmation code. Set it to zero to require confirmation for every payment. - **Maximum per payment**: payments above this value are declined, even with a valid confirmation code. Leave it empty if you do not want an upper limit. Before each of these payments, Heth evaluates the amount debited from your account, including platform fees debited from that account, in the limit currency. Fiat tokens use the rate of their original currency: RUB_T uses RUB, UZS_T uses UZS, and cNGN uses NGN. Token decimals are accounted for separately. USDT is valued at 1 USD for this reference calculation. This check does not exchange your assets. Approximate equivalents help you read the limits in another currency. Changing the display currency does not change the saved limit or payment amount. The settings show the rate date when available. If a current rate is unavailable, Heth cannot authorize a payment against a hard maximum; try again later. An amount-confirmation code allows a payment up to the confirmed numeric amount: for a bill of **9987**, you may confirm **10000**, and **9987** is charged. The code does not override your payment limits. AI-assisted transfers still require approval in Heth regardless of the code-free threshold. Reference fiat rates come from central-bank feeds and, for uncovered currencies, [ExchangeRate-API](https://www.exchangerate-api.com). ## 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. 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 and network. 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-23 --- # Подключить ИИ-помощника 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». Доступные инструменты зависят от подтверждённых разрешений. ### В Claude Code Добавьте Heth и начните подключение в терминале: ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code автоматически зарегистрирует подключение и откроет окно браузера. Введите там одноразовый код из Heth, затем проверьте и подтвердите разрешения в приложении Heth по шагам выше. Оставьте терминал открытым до завершения подключения. Идентификатор клиента, секрет клиента и API-ключ кошелька не нужны. После подключения попросите Claude: «Покажи балансы моих кошельков через Heth». Доступ ограничен одобренными разрешениями. Управлять подключением и отозвать его можно в **Настройки → Подключения ИИ** в Heth. ## Балансы кошельков Попросите: «Покажи балансы моих кошельков через Heth». Названия совпадают с приложением: `USDT ERC20`, `USDT TRC20`, `USDT Base`, `cNGN Base`. Рядом с каждой суммой указывается единица токена; `RUB_T`, `UZS_T` и `ZOLT` сохраняют свои обозначения. Внутренние номера кошельков не отображаются. Ассистент получает точный баланс в единицах токена и правила оформления. Например, `1,000001 USDT` нельзя показывать как `1 USDT`, а малый ненулевой остаток — как ноль. Десятичный разделитель и группировка разрядов соответствуют языку ответа. Если точность суммы неизвестна, ассистент показывает прочерк и объясняет причину, а не придумывает значение. Разные валюты и сети не суммируются. Кошельки, которые хранятся только на вашем устройстве, в этот список не входят. ## Разрешения и инструменты Можно подтвердить только запрошенные разрешения, которые доступны вашему аккаунту сейчас. Инструмент виден только при наличии нужного разрешения. Инструменты охватывают данные аккаунта, переводы, обычные бизнес-изменения, запросы подписки и 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. До подтверждения владельцем ничего не меняется. Возобновление разрешает списания по расписанию в пределах существующего платёжного разрешения. Отмена прекращает будущие списания и не возвращает уже оплаченные суммы. Новые условия списаний требуют нового согласия плательщика. Ваши [лимиты платежей](../user/payments.md#payment-limits) действуют для подготовленных ИИ переводов между внутренними счетами Heth (`hot_hot`). Перед исполнением Heth проверяет текущие лимиты и действующие справочные курсы. Блокчейн-переводы и сетевые комиссии в эти лимиты не входят. Разрешение ИИ или правильный код суммы не отменяет максимум. Меняйте эти настройки в 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; номинал определяет сервер. Отправленный запрос ещё не подтверждает зачисление. Ваши [лимиты платежей](payments.md#payment-limits) применяются и к общей стоимости выпускаемых подарочных карт. Правильный код подтверждения не отменяет максимум. ## Газ Покупка газа — отдельная операция с доступным источником оплаты. Проверьте счёт получения, сумму и сеть. Оплата с 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-23 --- # Оплата и приём платежей ## Оплатить через Heth Откройте экран оплаты и выберите доступный способ. QR плательщика может разрешать списание: показывайте его только выбранному продавцу. Если приложение запрашивает подтверждение суммы, проверьте продавца и сумму. Не передавайте продавцу или ИИ фразу восстановления и платёжный секрет. Приложение может показывать кэшированные данные или формировать некоторые коды плательщика без связи. Для обработки платежа продавцу нужен интернет; обычные переводы не исполняются офлайн. См. [границы офлайн-режима](security.md). ## Подтверждение суммы платежа Следуйте способу подтверждения, который Heth показывает для этого платежа: 1. Откройте свой QR плательщика и покажите только выбранному продавцу. 2. Проверьте запрошенную сумму и получателя до подтверждения. 3. Если Heth предлагает сформировать код, после показа QR вернитесь на экран подтверждения суммы, укажите сумму платежа и сформируйте текущий код. 4. Назовите этот код кассиру только для выбранного платежа. Это не фраза восстановления, PIN или постоянный платёжный секрет — их нужно хранить в тайне. 5. Если QR или код истёк, откройте свежий и следуйте текущей подсказке. Если подтверждение не настроено, завершите настройку в Heth при подключении к интернету. 6. Проверьте статус исходной операции. Показанный QR, сформированный код или запрос кассира сами по себе не доказывают оплату. ## Лимиты платежей {#payment-limits} Откройте **Настройки → Подтверждение суммы → Лимиты платежей**. У лимитов есть своя валюта; по умолчанию — USDT. Эти лимиты действуют только внутри Heth: для оплаты QR-кодом плательщика или кодом подтверждения суммы, выпуска подарочных карт с таким кодом и внутренних переводов через ИИ. На блокчейн-переводы и обычные переводы, которые вы отправляете вручную, они не распространяются. Сетевые комиссии в эти лимиты не входят. - **Без кода, до**: до этой суммы включительно дополнительный код подтверждения суммы не нужен. Ноль означает подтверждение каждого платежа. - **Максимум за один платёж**: выше этой суммы платёж отклоняется даже с правильным кодом. Оставьте поле пустым, если верхний предел не нужен. Перед каждым таким платежом Heth оценивает списание с вашего счёта, включая комиссии платформы, списываемые с этого счёта, в валюте лимитов. Фиатные токены оцениваются по исходной валюте: RUB_T — по RUB, UZS_T — по UZS, cNGN — по NGN. Разрядность токена учитывается отдельно. Для этого справочного расчёта 1 USDT принимается равным 1 USD. Проверка не обменивает ваши активы. Приблизительные эквиваленты помогают читать лимиты в другой валюте. Смена валюты отображения не меняет сохранённый лимит и сумму платежа. В настройках показывается дата курса, если она известна. Если действующий курс недоступен, Heth не может разрешить платёж с проверкой жёсткого максимума; повторите попытку позже. Код подтверждает платёж до указанной числовой суммы: для счёта на **9987** можно подтвердить **10000**, при этом списывается **9987**. Код не отменяет лимиты платежей. Перевод через ИИ требует подтверждения в Heth независимо от порога без дополнительного кода. Справочные фиатные курсы поступают из выгрузок центробанков, а для недостающих валют — из [ExchangeRate-API](https://www.exchangerate-api.com). ## Принять платёж 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-23 --- # 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. Bei geöffneter Heth-App erscheint oben ein Hinweis auf die KI-Verbindungsanfrage. Öffnen Sie darüber die Anfrage zur Prüfung oder öffnen Sie die Push-Nachricht. Sie finden die Anfrage auch 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. ### In Claude Code Fügen Sie Heth im Terminal hinzu und starten Sie die Verbindung: ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code registriert die Verbindung automatisch und öffnet ein Browserfenster. Geben Sie dort den Einmalcode aus Heth ein und prüfen und bestätigen Sie anschließend die Berechtigungen in der Heth-App wie oben beschrieben. Lassen Sie das Terminal bis zum Abschluss geöffnet. Client-ID, Client-Secret und Wallet-API-Schlüssel sind nicht erforderlich. Bitten Sie Claude danach: „Zeige meine Wallet-Guthaben über Heth“. Der Zugriff ist auf die bestätigten Berechtigungen begrenzt. Unter **Einstellungen → KI-Verbindungen** in Heth können Sie die Verbindung verwalten oder widerrufen. ## Wallet-Guthaben Fragen Sie: „Zeige meine Wallet-Guthaben mit Heth“. Die Namen entsprechen der App: `USDT ERC20`, `USDT TRC20`, `USDT Base`, `cNGN Base`. Jeder Betrag enthält die Token-Einheit; `RUB_T`, `UZS_T` und `ZOLT` behalten ihre eigenen Bezeichnungen. Interne Wallet-Nummern werden nicht angezeigt. Der Assistent erhält einen exakten Betrag in Token-Einheiten unter Beibehaltung aller Nachkommastellen und Hinweise zur Darstellung. Zum Beispiel darf `1,000001 USDT` nicht als `1 USDT` erscheinen; ein kleiner Betrag ungleich null darf nicht zu null gerundet werden. Dezimal- und Gruppierungszeichen entsprechen Ihrer Sprache. Ist die Genauigkeit unbekannt, zeigt der Assistent einen Gedankenstrich und erklärt den Grund, statt einen Betrag zu erfinden. Verschiedene Währungen und Netzwerke werden nicht addiert. Nur auf Ihrem Gerät gespeicherte Wallets sind nicht enthalten. ## 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. Ihre [Zahlungslimits](../user/payments.md#payment-limits) gelten für von Assistenten vorbereitete Überweisungen zwischen internen Heth-Konten (`hot_hot`). Vor der Ausführung prüft Heth die aktuellen Limits und Referenzkurse. Blockchain-Überweisungen und Netzwerkgebühren fallen nicht unter diese Limits. KI-Berechtigungen und gültige Betragscodes heben die Obergrenze nicht auf. Ändern Sie diese Einstellungen in Heth. Beträge mit Token und Netzwerk anzeigen; umgerechnete Gegenwerte als ungefähr kennzeichnen. Rohbeträge verschiedener Token in kleinsten Einheiten nicht direkt vergleichen. ## 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 | | 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 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 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. 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-Parameter | 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 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 und Netzwerk 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` | Für das Konto aktiviertes Token/Netzwerk-Paar. 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, 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. 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. 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. Ihre [Zahlungslimits](payments.md#payment-limits) gelten auch für den Gesamtwert der ausgegebenen Geschenkkarten. Ein gültiger Bestätigungscode hebt die Obergrenze nicht auf. ## 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-23 --- # 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. ## Zahlungslimits {#payment-limits} Öffnen Sie **Einstellungen → Betragsbestätigung → Zahlungslimits**. Limits haben eine eigene Währung; standardmäßig USDT. Diese Limits gelten nur innerhalb von Heth: für Zahlungen mit Ihrem Zahler-QR oder einem Betragsbestätigungscode, die Ausgabe von Geschenkkarten mit diesem Code und über KI veranlasste interne Überweisungen. Blockchain-Überweisungen und gewöhnliche manuell ausgelöste Überweisungen sind davon ausgenommen. Netzwerkgebühren zählen nicht zu diesen Limits. - **Ohne Code bis**: Bis einschließlich dieses Betrags ist kein zusätzlicher Code zur Betragsbestätigung nötig. Null verlangt eine Bestätigung für jede Zahlung. - **Maximum pro Zahlung**: Höhere Zahlungen werden auch mit gültigem Code abgelehnt. Lassen Sie das Feld leer, wenn Sie keine Obergrenze wünschen. Vor jeder dieser Zahlungen bewertet Heth die Belastung Ihres Kontos einschließlich der von diesem Konto bezahlten Plattformgebühren in der Limitwährung. Fiat-Token verwenden den Kurs ihrer Ursprungswährung: RUB_T entspricht dabei RUB, UZS_T UZS und cNGN NGN. Die Dezimalstellen des Tokens werden gesondert berücksichtigt. Für diese Referenzbewertung gilt 1 USDT = 1 USD. Dabei werden Ihre Vermögenswerte nicht umgetauscht. Ungefähre Gegenwerte erleichtern die Anzeige in einer anderen Währung. Die Anzeigewährung ändert weder das gespeicherte Limit noch den Zahlungsbetrag. Das Kursdatum erscheint, sofern bekannt. Ohne gültigen Kurs kann Heth eine Zahlung mit harter Obergrenze nicht freigeben; versuchen Sie es später erneut. Ein Code bestätigt eine Zahlung bis zum angegebenen Zahlenbetrag: Bei einer Rechnung über **9987** können Sie **10000** bestätigen; belastet werden **9987**. Der Code hebt Zahlungslimits nicht auf. KI-gestützte Überweisungen erfordern unabhängig vom codefreien Schwellenwert eine Freigabe in Heth. Fiat-Referenzkurse stammen aus Zentralbankdaten und für dort fehlende Währungen von [ExchangeRate-API](https://www.exchangerate-api.com). ## 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 ö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 und Netzwerk 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-23 --- # 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. Si Heth est ouvert, un avis **Demande de connexion d’un assistant** apparaît en haut de l’application. Choisissez **Vérifier la demande de connexion**, ou ouvrez la notification. La demande est aussi accessible dans **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. ### Dans Claude Code Ajoutez Heth et lancez la connexion dans le terminal : ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code enregistre automatiquement la connexion et ouvre une fenêtre du navigateur. Saisissez-y le code à usage unique de Heth, puis vérifiez et confirmez les autorisations dans l’application Heth en suivant les étapes ci-dessus. Gardez le terminal ouvert jusqu’à la fin de la connexion. Aucun identifiant client, secret client ni clé API du portefeuille n’est nécessaire. Demandez ensuite à Claude : « Affiche les soldes de mes portefeuilles avec Heth ». L’accès reste limité aux autorisations approuvées. Dans Heth, ouvrez **Paramètres → Connexions IA** pour gérer ou révoquer la connexion. ## Soldes des portefeuilles Demandez : « Affiche les soldes de mes portefeuilles avec Heth ». Les noms correspondent à l’application : `USDT ERC20`, `USDT TRC20`, `USDT Base`, `cNGN Base`. Chaque montant inclut l’unité du jeton ; `RUB_T`, `UZS_T` et `ZOLT` conservent leurs propres désignations. Les identifiants internes des portefeuilles ne sont pas affichés. L’assistant reçoit un solde exact en unités de jeton et des consignes de présentation. Par exemple, `1,000001 USDT` ne doit pas devenir `1 USDT`, et un faible montant non nul ne doit pas être arrondi à zéro. Les séparateurs décimaux et de milliers suivent votre langue. Si la précision est inconnue, l’assistant affiche un tiret et en explique la raison au lieu d’inventer un montant. Les devises et réseaux différents ne sont pas additionnés. Les portefeuilles enregistrés uniquement sur votre appareil ne sont pas inclus. ## 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. Vos [limites de paiement](../user/payments.md#payment-limits) s’appliquent aux transferts préparés par une IA entre comptes internes Heth (`hot_hot`). Avant l’exécution, Heth vérifie les limites et taux de référence actuels. Les transferts blockchain et les frais réseau sont exclus de ces limites. Une permission IA ou un code valide ne supprime pas le plafond. Modifiez ces paramètres dans Heth. Affichez les montants avec l’actif et le réseau et indiquez que les équivalents convertis sont approximatifs ; ne comparez pas directement les unités minimales d’actifs différents. ## 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 autorisé | | 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 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 | | 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. 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 | ## Paramètres de routage | 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. 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 et réseau 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 pour le compte. 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, 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. 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 les 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. Vos [limites de paiement](payments.md#payment-limits) s’appliquent aussi à la valeur totale des cartes-cadeaux émises. Un code valide ne supprime pas le plafond. ## 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-23 --- # 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. ## Limites de paiement {#payment-limits} Ouvrez **Paramètres → Confirmation du montant → Limites de paiement**. Les limites ont leur propre devise : USDT par défaut. Ces limites s’appliquent uniquement au sein de Heth : paiements avec votre QR de payeur ou un code de confirmation du montant, émission de cartes cadeaux avec ce code et transferts internes initiés par l’IA. Elles ne concernent ni les transferts blockchain ni les virements ordinaires déclenchés manuellement. Les frais réseau sont exclus de ces limites. - **Sans code, jusqu’à** : aucun code supplémentaire n’est requis jusqu’à ce montant inclus. Zéro exige une confirmation pour chaque paiement. - **Maximum par paiement** : les paiements supérieurs sont refusés, même avec un code valide. Laissez le champ vide pour ne pas fixer de plafond. Avant chacun de ces paiements, Heth évalue le débit de votre compte, y compris les frais de plateforme imputés à ce compte, dans la devise des limites. Les tokens fiat utilisent le taux de leur devise d’origine : RUB_T utilise RUB, UZS_T utilise UZS et cNGN utilise NGN. Les décimales du token sont prises en compte séparément. Pour cette évaluation de référence, 1 USDT vaut 1 USD. Ce contrôle n’échange pas vos actifs. Les équivalents approximatifs facilitent la lecture dans une autre devise. Changer la devise d’affichage ne modifie ni la limite enregistrée ni le montant payé. La date du taux apparaît lorsqu’elle est connue. Sans taux valide, Heth ne peut pas autoriser un paiement soumis à un plafond strict ; réessayez plus tard. Un code confirme un paiement jusqu’au montant numérique indiqué : pour une facture de **9987**, vous pouvez confirmer **10000** ; le débit reste **9987**. Le code n’annule pas vos limites. Les transferts avec une IA exigent toujours une approbation dans Heth, quel que soit le seuil sans code supplémentaire. Les taux fiat de référence proviennent des banques centrales et, pour les devises absentes, d’[ExchangeRate-API](https://www.exchangerate-api.com). ## 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. 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 et le réseau. 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. ## es: Conecta un asistente AI Source: https://docs.heth.me/markdown/es/ai/mcp.md --- title: "Conecta un asistente AI" last_update: date: 2026-10-23 --- # Conecta un asistente AI Heth MCP le brinda a un asistente acceso limitado a su propia cuenta, incluidas las funciones comerciales disponibles. No puede otorgar acceso de administración de la plataforma. Abrir una pantalla de conexión no otorga ningún permiso. ## Conectar un asistente 1. En la aplicación Heth donde su billetera ya está abierta, vaya a **Configuración → Conexiones AI** y elija **Crear código de conexión**. El código único pertenece a esa cuenta y caduca después de cinco minutos. 2. En la configuración de conexión de su cliente AI, agregue `https://mcp.heth.me/mcp` y elija OAuth. Comience a conectarse. 3. En la ventana de conexión, ingrese solo el código de Heth. No inicia sesión en su billetera en este navegador. El código envía una solicitud a la cuenta exacta que lo creó; no concede ningún acceso. 4. Si Heth está abierto, aparece un aviso de **solicitud de conexión AI** en la parte superior de la aplicación. Elija **Revisar solicitud de conexión** o abra el push. También puede encontrar la solicitud en **Configuración → Conexiones AI → Solicitudes de conexión**. Compare el **código de verificación de solicitud** con el de la ventana de conexión y verifique la cuenta, el identificador del cliente y la dirección del servicio. El nombre de la aplicación por sí solo no verifica la identidad. 5. En Heth, desmarque los permisos que no desea compartir y elija **Aprobar el acceso al AI seleccionado**, o elija **Denegar el acceso al AI**. Abrir el push por sí solo no aprueba nada. 6. Regrese al cliente AI. Su ventana de conexión finaliza automáticamente después de su decisión en Heth. Su sesión de billetera y sus claves de firma permanecen en Heth. Un código de conexión usado o caducado no se puede reutilizar. Crea un nuevo código en Heth; crear uno reemplaza el código anterior no utilizado. Si toda la solicitud de conexión caduca, reinicie desde el cliente AI. ### En ChatGPT Abra **Complementos → Agregar → Agregar servidor MCP personalizado**, ingrese un nombre como Heth.me y la dirección del servidor anterior, y mantenga **OAuth** seleccionado. ChatGPT descubre la configuración de conexión automáticamente; no se necesita clave de billetera API, secreto de cliente ni frase de recuperación. Cree el complemento personal, elija **Connect Heth.me** y luego siga los pasos anteriores para codificar y enviar. Puede seleccionar permisos predeterminados en **Configuración avanzada de OAuth**; La elección final del permiso de la cuenta se confirma en la aplicación Heth. Después de la conexión, seleccione Heth.me en el chat e intente "Mostrar los saldos de mi billetera usando Heth". Las herramientas disponibles dependen de los permisos que haya aprobado. ### En Código Claude En una terminal, agrega Heth y comienza a conectar: ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code registra la conexión automáticamente y abre una ventana del navegador. Ingrese el código de un solo uso de Heth allí, luego revise y apruebe los permisos en la aplicación Heth siguiendo los pasos anteriores. Mantenga el terminal abierto hasta que finalice la conexión. No necesita un identificador de cliente, un secreto de cliente ni una clave API de billetera. Después de la conexión, pregúntele a Claude: "Mostrar los saldos de mi billetera usando Heth". Solo puede usar los permisos que usted aprobó. Puede administrar o revocar esta conexión en **Configuración → Conexiones AI** en Heth. ## Saldos de billetera Preguntar: "Mostrar los saldos de mi billetera usando Heth". Los nombres de las billeteras coinciden con la aplicación: `USDT ERC20`, `USDT TRC20`, `USDT Base`, `cNGN Base`. Cada monto incluye su unidad simbólica; `RUB_T`, `UZS_T` y `ZOLT` siguen siendo nombres de tokens distintos. Los identificadores de la base de datos de Wallet no se muestran. El asistente recibe un saldo exacto en unidades de token, conservando todos los decimales y orientación sobre el formato. Por ejemplo, `1.000001 USDT` no debe mostrarse como `1 USDT` y una pequeña cantidad distinta de cero no debe convertirse en cero. Los separadores decimales y de agrupación siguen su idioma. Si no hay precisión disponible, el asistente muestra un guión y explica por qué en lugar de inventar una cantidad. Las diferentes monedas y redes no se suman. Las billeteras almacenadas únicamente en su dispositivo no están incluidas. ## Permisos y herramientas Solo se pueden aprobar los permisos solicitados por el cliente y actualmente disponibles en su cuenta. Una herramienta es visible sólo con el permiso requerido. Las herramientas cubren datos de cuentas, transferencias, cambios comerciales ordinarios, solicitudes de suscripción y OBS. | Permiso | Herramientas y finalidad | | --- | --- | | `heth:wallets:read` | `get_wallet_balances`: saldos de billetera propia | | `heth:transactions:read` | `list_transactions`, `get_transaction`: historial propio y estado de transacción original | | `heth:business:read` | `list_products`, `list_business_payment_links`, `list_business_subscriptions`: productos propios, enlaces gestionados y suscripciones comerciales; `get_business_subscription`, `list_business_subscription_requests` leen un acuerdo o solicitudes salientes | | `heth:payments:prepare` | `prepare_transfer`, `get_transfer_request`: prepare una transferencia para su aprobación en Heth y lea el resultado original | | `heth:business:manage` | `create_business_product`, `update_business_product`, `delete_business_product`; `create_business_payment_link`, `update_business_payment_link`, `delete_business_payment_link`: cambios ordinarios confirmados en el cliente AI | | `heth:business:manage` | `request_business_subscription`: solicitar la aprobación de un cliente en Heth; `prepare_business_subscription_change`: pausa, reanudación o cancelación de revisión en Heth | | `heth:obs:read` | `get_obs_widget`, `list_obs_events`: configuraciones y eventos entrantes | | `heth:obs:configure` | `prepare_obs_connection`, `update_obs_widget`: Enlace de revisión de Heth o campos de apariencia solo con confirmación en el cliente AI | `prepare_obs_connection` no crea acceso y no devuelve ningún token OBS. La moneda/red, las cuentas receptoras, las claves y los permisos de acceso no se pueden cambiar mediante una herramienta de apariencia. Consulte la [guía de configuración y personalización OBS](../user/obs.md), que incluye el proyecto de código abierto y las instrucciones para los asistentes de codificación. ## Cuanto dura el acceso Tu permiso de conexión dura **hasta que lo revocas**. Las credenciales técnicas caducan por separado: los tokens de acceso MCP duran minutos 15; Los tokens de actualización rotan y caducan después de días 30 sin renovación. Una credencial técnica vencida puede requerir que usted se conecte nuevamente incluso si el registro de consentimiento permanece activo. Cada solicitud verifica la conexión actual y los permisos de la cuenta. Heth utiliza una credencial API restringida separada válida durante como máximo segundos 60 para atender solicitudes MCP; la sesión completa de la billetera no se comparte con MCP. Revocar el consentimiento o retirar los permisos de la cuenta bloquea las solicitudes posteriores, incluidas las solicitudes con tokens no vencidos. Los datos ya devueltos al cliente no se pueden recuperar. ## Revocar o volver a conectar En Heth, abra **Configuración → Conexiones AI**, verifique el identificador del cliente, la dirección del servicio, los permisos y el estado. Elija **Revocar acceso a AI** y confirme en Heth. La revocación no cancela los pagos efectuados ni los mandatos de débito de suscripción; adminístrelos por separado en [configuración de suscripción](../user/features.md). Si se le solicita volver a conectarse, inicie una nueva autorización en su cliente AI. La revocación, las credenciales caducadas, los permisos retirados o la reutilización detectada de un token de actualización pueden finalizar el acceso. No pegue frases de recuperación, claves de billetera o credenciales de sesión del navegador en un asistente para reparar la conexión. Un servicio no disponible es un error, no una cuenta vacía o una aprobación exitosa. ## Pagos y otros cambios Heth requiere **confirmación separada en Heth para cada operación monetaria**. Un permiso de conexión no autoriza el gasto automático. Las ediciones ordinarias de productos y enlaces de pago requieren confirmación en el cliente AI. Los cambios en los derechos de acceso, los destinatarios de los pagos o la autorización de débitos futuros requieren la confirmación de Heth. La apariencia de OBS sigue la política de confirmación del cliente. Una anotación de herramienta por sí sola no prueba que un cliente haya obtenido la aprobación. También puede utilizar la [aplicación Heth](https://app.heth.me) o la integración compatible API](../business/quick-start.md). ## Traslado con asistente 1. Indíquele al asistente el tipo de transferencia, destinatario, moneda, red y monto. Interno a interno (`hot_hot`), interno a blockchain (`hot_cold`), blockchain a su cuenta interna (`cold_hot`) y blockchain a blockchain (`cold_cold`) son operaciones distintas. Utilice `self` como destinatario de `cold_hot`; acredita su propia cuenta Heth. 2. `prepare_transfer` guarda los términos y devuelve un enlace de revisión de Heth. No genera ningún pago. Las cantidades y `max_debit` utilizan cadenas enteras exactas en las unidades menores del token. `max_debit` limita el débito del token, incluidas las tarifas de la plataforma. Para una fuente de blockchain, `max_network_fee` limita el cargo de gas de la red de la transacción en wei (ETH/Base) o sun (TRON). Base puede cobrar adicionalmente una tarifa de datos L1. 3. Abra Heth y verifique la cuenta, solicitando límites de cliente, destinatario, fuente, monto, red y tarifas. Elija **Confirmar y enviar Heth** solo cuando todos los términos sean correctos. Abrir el enlace no aprueba ni envía nada. Las solicitudes caducan después de los minutos 15. 4. Heth firma la instrucción mostrada y utiliza su flujo de transferencia normal. Las transacciones de Blockchain se firman en su dispositivo o en un dispositivo de firma conectado. Abra Heth donde se puede firmar la cuenta de origen; Las claves privadas nunca van al asistente. 5. El asistente lee `get_transfer_request` para verificar la transacción original. Aprobado o tramitado no es lo mismo que pagado. Después de un tiempo de espera, lea el resultado original; reutilice el mismo `request_id` y términos idénticos si se debe volver a intentar una preparación. No cree una segunda transferencia para resolver un resultado incierto. La revocación bloquea el inicio de una nueva transferencia. Una transacción ya aceptada para su ejecución aún puede completarse; Revocar una conexión AI no cancela una transferencia blockchain aceptada. ## Productos, enlaces y suscripciones El asistente muestra cambios ordinarios de productos o enlaces administrados para su confirmación en el cliente AI. Los importes del precio y del enlace son cadenas de números enteros en unidades menores; las cantidades de productos son números enteros positivos. Un `request_id` estable hace que los reintentos sean idempotentes. Estas operaciones no pueden editar la ruta de pago, los destinatarios de los pagos, las claves ni los derechos de acceso. Eliminar un enlace o producto no revierte un pago anterior. `request_business_subscription` crea una solicitud para que el pagador la revise en Heth. No otorga permiso para débitos futuros y no genera ningún cargo por sí solo. El pagador revisa el monto, la frecuencia y el primer cargo antes de registrarse en Heth. Utilice `list_business_subscription_requests` para comprobar solicitudes y `get_business_subscription` o `list_business_subscriptions` para acuerdos existentes. Para pausar, reanudar o cancelar un acuerdo, `prepare_business_subscription_change` muestra una pantalla de revisión de Heth. Nada cambia hasta que el propietario lo confirme allí. La reanudación permite los cargos programados según el permiso de pago existente. La cancelación detiene los cargos futuros y no reembolsa los pagos completados. Cambiar los términos de facturación acordados requiere la aprobación de un nuevo pagador. Tus [límites de pago](../user/payments.md#payment-limits) se aplican a las transferencias internas preparadas por IA (`hot_hot`). Heth comprueba límites y tipos de referencia antes de ejecutar. Las transferencias en blockchain y las comisiones de red quedan fuera. Un permiso de IA o un código válido no anulan el máximo; modifica los ajustes en Heth. Muestra el activo y la red junto al importe y marca las equivalencias como aproximadas. No compares directamente unidades menores de activos diferentes. ## es: Claves de autenticación y API Source: https://docs.heth.me/markdown/es/business/authentication.md --- title: "Claves de autenticación y API" last_update: date: 2026-10-20 --- # Claves de autenticación y API ## Emitir y revocar una clave 1. Inicie sesión en [Heth](https://app.heth.me) y abra **Negocios**. 2. Abra la pantalla de integración usando **Conectar**. 3. En **integración API**, use **+** para emitir una clave. 4. Guarde la clave como un secreto en su integración del lado del servidor. 5. Para revocar una clave, elimine su entrada en esa pantalla. Actualiza la integración al reemplazar una clave. Nunca utilices una clave impresa en una captura de pantalla o en un ejemplo de documentación. La documentación utiliza marcadores de posición en lugar de credenciales utilizables. ## Solicitar encabezados | Encabezado | Uso | | --- | --- | | `x-api-key` | Requerido para la autenticación de clave API | | `Content-Type: application/json` | Requerido al enviar JSON | Para `https://app.heth.me`, la puerta de enlace Heth proporciona el contexto de la organización. Esta regla se aplica a ese host: no asuma que se aplica a una plataforma diferente API URL. Una clave API está vinculada a su propia cuenta y permisos. ## Las claves y las sesiones de usuario son diferentes La integración de transacciones acepta una clave API. Las funciones de billetera interactiva pueden requerir en su lugar la sesión de portador del usuario que ha iniciado sesión; una clave no otorga automáticamente acceso a billeteras, perfiles, nombres de usuario o todas las funciones comerciales. Las sesiones de suscripción de clientes son un tipo de autorización independiente. Nunca sustituya un tipo de token por otro ni copie una semilla en una configuración de integración. Consulte [capacidades](capabilities.md) y [errores](errors.md). Una integración debe solicitar solo el acceso necesario para su tarea. ## es: Capacidades y disponibilidad comerciales Source: https://docs.heth.me/markdown/es/business/capabilities.md --- title: "Capacidades y disponibilidad comerciales" last_update: date: 2026-10-20 --- # Capacidades y disponibilidad comerciales Utilice las capacidades habilitadas para la cuenta iniciada. Un punto final API existente en la plataforma no significa que esté habilitado para su cuenta, red o ruta de pago. | Capacidad | Límite de integración | | --- | --- | | Pagos y desembolsos | Transacción API, ruta configurada, instrumento permitido | | Enlaces de recepción Heth | Un receptor URL generado en la aplicación; compartir no genera un cargo | | Enlaces de pago gestionados y productos | Recursos comerciales separados; requiere acceso a la cuenta habilitada | | Suscripciones comerciales | Acuerdos facturados a sus clientes; requieren métodos de pago admitidos y autorización del cliente | | Permisos de suscripción propios del pagador | Autorización separada del cliente y aprobación/revocación explícita | | Reembolso o cancelación | Solo si lo respalda la transacción y el método de pago originales; una transferencia blockchain no es genéricamente reversible | | Carteras, @nombres de usuario, tarjetas de regalo, webhooks | Las funciones de la cuenta pueden requerir la sesión del usuario y confirmación adicional | | Donaciones | Flujo plataforma/autor con destinatario propio, mínimo, tarifa y vencimiento | El registro público de tokens devuelve una configuración, no un derecho a pagar con cada activo enumerado. Haga coincidir el activo con la red y la configuración efectiva de la cuenta. Por ejemplo, USDT/ETH y USDT/TRX no se pueden intercambiar. ## Límites de la documentación La [referencia de transacción](../transactions/overview.md) cubre los formatos de solicitud para los flujos documentados. No obtenga credenciales de operador ni cambie terminales/rutas para resolver una solicitud rechazada. Comuníquese con el soporte con el identificador de la transacción cuando una ruta de cuenta no esté disponible. La [guía de conexión AI](../ai/mcp.md) explica los permisos y la confirmación de las funciones disponibles para su cuenta. ## es: Errores, comprobaciones de estado y reintentos Source: https://docs.heth.me/markdown/es/business/errors.md --- title: "Errores, comprobaciones de estado y reintentos" last_update: date: 2026-10-20 --- # Errores, comprobaciones de estado y reintentos Inspeccione siempre tanto la respuesta HTTP como la transacción `status`. Un 200 o 201 puede contener una transacción rechazada o pendiente. | Resultado HTTP | Acción de integración | | --- | --- | | 400 / 422 | Verifique los campos proporcionados, tipos, escala de monto y destinatario. No volver a enviar errores de validación sin cambios en un bucle | | 401 | Verifica la credencial, su validez y el host API | | 403 | La cuenta o clave autenticada carece de permiso; no cambiar de cuenta automáticamente | | 404 | Verifique el identificador y el contexto de la cuenta. Esto no prueba que otra cuenta no tenga ese recurso | | 409 | Inspeccione el conflicto y recupere la operación original antes de crear cualquier otra cosa | | 429 | Respete `Retry-After` cuando esté presente y vuelva a intentar las lecturas con retroceso acotado | | Timeout / 5xx | El resultado puede ser desconocido. Busque la operación original de `id` o `txid` antes de volver a enviar | Las formas de respuesta de error pueden diferir según el punto final. Prefiera un código de error documentado y legible por máquina, cuando esté disponible; `error_description` es texto legible por humanos y no un código estable. Elimine u oculte las credenciales y los datos de instrumentos de pago en los registros. ## Resultados de la transacción - `charged`: la transacción se completó exitosamente. - `rejected` o `failed`: inspeccionar el motivo y el funcionamiento original; no reporte éxito. - `refunded` o `reversed`: los fondos tienen un resultado diferente al de un pago recién liquidado. - Estado pendiente/acción requerida/desconocido: muestra ese estado y la acción requerida del usuario. Nunca infieras el éxito únicamente a partir de un estado no reconocido o de una marca de tiempo. Utilice [transacción GET](../transactions/get_transaction.md) para verificar una operación. Mantenga el mismo `txid` para reintentos de la misma instrucción comercial. Las fallas en la entrega del webhook y una falla en el procesamiento de pagos son eventos diferentes. ## es: Iniciar una integración API Source: https://docs.heth.me/markdown/es/business/quick-start.md --- title: "Iniciar una integración API" last_update: date: 2026-10-20 --- # Iniciar una integración API Utilice una clave API emitida para su propia cuenta Heth. Primero lea [autenticación](authentication.md), [cantidades y estados](../field_conventions.md) y [capacidades comerciales disponibles](capabilities.md). ## Verificar acceso sin mover fondos Configure `HETH_API_KEY` en el almacenamiento secreto de su integración. No lo ponga en control de código fuente, en un paquete de navegador, en una conversación URL o AI. Esta solicitud lee las transacciones de la cuenta sin mover dinero. ```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' ``` Una matriz `data` vacía es un resultado válido. Para un 401 o 403, verifique la autenticación y los permisos de la cuenta. ## Primer pago 1. Verifique qué rutas de pago están habilitadas para su cuenta y obtenga los detalles del destinatario o instrumento de pago. 2. Elija el [ejemplo de transacción](../transactions/overview.md)] apropiado. Reemplace cada marcador de posición con detalles verificados para su propia operación. 3. Usa una pequeña cantidad. Para USDT de seis decimales, `"1000000"` significa 1 USDT. 4. Generar y guardar un `txid` único para la operación comercial antes de enviarlo. 5. Envíe una vez, guarde el `id` devuelto y luego [lea su estado](../transactions/get_transaction.md). 6. Si la solicitud caduca, busque el `txid` original o vuelva a intentar la solicitud idéntica con el mismo identificador. No cree un identificador de reemplazo. Enviar una solicitud de pago puede mover fondos reales. Revise el destinatario, el monto, la moneda, la red y las tarifas antes de enviar. Una clave API autoriza únicamente las operaciones disponibles para su cuenta. ## es: Productos, enlaces administrados y suscripciones Source: https://docs.heth.me/markdown/es/business/resources.md --- title: "Productos, enlaces administrados y suscripciones" last_update: date: 2026-10-20 --- # Productos, enlaces administrados y suscripciones Estos son recursos comerciales propiedad de la cuenta. Se requiere acceso de portador de clave API o socio y las capacidades habilitadas correspondientes. Una clave no activa una ruta de pago. Consulte [autenticación](authentication.md). Para lecturas y eliminaciones, env es un filtro de consulta. Para creación y actualizaciones de productos/enlaces, envíe env en el cuerpo JSON. La propiedad del socio proviene de la credencial; no envíe otro socio_id. Los campos de precio de recursos pueden tener tipos enteros específicos del punto final: el monto de la transacción API sigue siendo una cadena entera exacta. ## Productos ```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 ``` La creación de un producto define su encabezado, texto, precio, cantidad y moneda. Un producto no es un pago. Las respuestas de lista utilizan datos/total; Los detalles del producto y las respuestas de creación utilizan datos. El precio mostrado es 1 USDT en decimales=6. ```json { "env": "prod", "header": "Example item", "text": "Example item", "price": 1000000, "qty": "1", "currency": "USDT" } ``` ## Enlaces de pago administrados ```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 ``` Los enlaces son recursos de servidor separados con configuraciones de montos, configuración de pagos y productos opcionales. Utilice el recurso devuelto URL/información del formulario, no un URL inventado. Un enlace de recepción Heth generado en la aplicación es un objeto diferente. Eliminar un enlace no reembolsa un pago ya realizado. ## Suscripciones de comerciantes ```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 ``` Se crea una suscripción a partir de un pago inicial exitoso perteneciente a la cuenta. POST /recurrents utiliza id_pago y un objeto recurrente; El intervalo acepta diario, semanal, mensual o anual, y el período especifica el número de intervalos. El medio ambiente se hereda del pago inicial. El pagador deberá autorizar el método de pago y las condiciones de débito recurrente. Crear una suscripción no es prueba de que exista un permiso de débito utilizable. Las acciones del ciclo de vida utilizan `POST /recurrents/{id}/pause`, /resume y /cancel. Leer el estado devuelto; cancelar cargos futuros no reembolsa los anteriores. Un pagador Heth administra sus propios mandatos de suscripción criptográfica con su sesión de billetera en Configuración → Mandatos de suscripción, donde la función está habilitada. Esto es independiente de la gestión de suscripciones comerciales. ## es: Integración de webhook Source: https://docs.heth.me/markdown/es/business/webhooks.md --- title: "Integración de webhook" last_update: date: 2026-10-20 --- # Integración de webhook Un webhook informa un evento de cuenta al receptor URL. Es una notificación; verifique el estado de la transacción autorizada a través de [transacción GET](../transactions/get_transaction.md). ## Configurar el receptor En la configuración del webhook de Heth, configure un URL que usted controle, configure el secreto de integración y habilite la entrega. Cambiar el URL cambia quién recibe los eventos de la cuenta. Proteja ese punto final y evite redirecciones a destinatarios que no sean de confianza. La configuración requiere la sesión de la cuenta del usuario; una clave API utilizada para transacciones no es automáticamente suficiente. ## Procesar notificaciones de forma segura 1. Valide la firma del webhook de la cuenta y vuelva a realizar las comprobaciones que se describen a continuación. 2. Registre el identificador de evento/transacción con los campos confidenciales redactados. 3. Hacer que el manejo sea idempotente: la entrega duplicada o retrasada no debe generar otro pago. 4. Recupera la transacción con tu propia credencial y concilia su estado. 5. Devuelve la respuesta del receptor requerida por el contrato de entrega configurado. No trate una notificación push del navegador como un webhook o una garantía de entrega. Esta descripción general no promete pedidos, intervalos de reintento o un formato de autenticación común para cada integración configurada. Obtenga el contrato de entrega real antes de habilitar la automatización de la producción. ## Formato de entrega del webhook de la cuenta Este formato se aplica a los webhooks de cuentas configurados en la configuración de Heth. Otras integraciones de devolución de llamada pueden utilizar un contrato diferente. Cuando se configura un secreto de webhook de cuenta que no está vacío, la solicitud incluye x-webhook-signature (hexadecimal HMAC-SHA256), x-webhook-timestamp (segundos de Unix) y x-webhook-event-id. Verifique el HMAC con la marca de tiempo + "." + los bytes exactos del cuerpo HTTP sin procesar utilizando el secreto configurado; no analice ni vuelva a serializar JSON antes de la verificación. Verifique que la marca de tiempo del cuerpo firmado coincida con el encabezado de la marca de tiempo, rechace una diferencia de reloj superior a los minutos 5, compare firmas en tiempo constante y realice la deduplicación mediante event_id. Un reintento conserva event_id pero recibe una marca de tiempo/firma nueva. Sin un secreto configurado, los encabezados de firma pueden faltar; configure un secreto antes de confiar en la entrega automatizada. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` El sobre tiene event_id, marca de tiempo, tipo y datos. Para eventos de transacciones de cuenta, los datos incluyen tx_id, txid, tipo, estado, monto, moneda y tipo de evento. La cantidad puede ser un número entero JSON: utilice un analizador sin pérdidas. Una donación puede agregar un objeto de donación. Reconocer un evento verificado con HTTP 2xx después de grabarlo; Los valores repetidos de event_id verificados no deben desencadenar la acción comercial dos veces. Confirme la transacción a través de GET incluso después de una notificación válida. ## es: Glosario y convenciones de campo Source: https://docs.heth.me/markdown/es/field_conventions.md --- title: "Glosario y convenciones de campo" last_update: date: 2026-10-20 --- # Glosario y convenciones de campo Definiciones canónicas utilizadas en la documentación API. ## Encabezados de solicitud | Encabezado | Requerido | Definición | | ------ | -------- | ---------- | | x-api-key | Sí | Clave API emitida en la aplicación (sección "Negocios"). La organización se resuelve desde el host de solicitud | | Content-Type | Sí (POST) | `application/json` para crear solicitudes | ## Monto y moneda | Término | Definición | | ---- | ---------- | | amount | Cadena de un número entero en unidades menores (por ejemplo, centavos, fracción simbólica más pequeña) | | amount_with_fee | Importe más tasa aplicada (unidades menores) | | currency | Código de moneda/token similar a ISO (por ejemplo, USDT) | | currency_dest | Moneda de destino para la conversión (FX). Opcional; por defecto es `currency` | ## Identificadores | Término | Definición | | ---- | ---------- | | id | Sistema interno UUID de transacción | | txid | Cadena proporcionada por el cliente que identifica una operación comercial; UUID es una opción conveniente, no un formato obligatorio | ## Enrutamiento | Término | Definición | | ---- | ---------- | | route | Alias ​​de ruta de procesamiento configurado para la clave API | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | ## Estado del ciclo de vida | Estado | Significado | | ------ | ------- | | created | Aceptado, pendiente de procesamiento | | new | Estado inicial antes de que comience el procesamiento | | authorizing | Autorización en curso | | pre_authorized_3ds | En espera de autenticación 3DS | | action_required | En espera de una acción adicional (3DS / autorización extra) | | charging | En curso (autorización/financiación) | | payment_suspended | Transacción entrante suspendida temporalmente | | payout_suspended | Transacción saliente suspendida temporalmente | | charged | Completado con éxito (terminal) | | reversed | Cargo revertido (terminal) | | refunded | Reembolsado (terminal) | | rejected | Fallo irrecuperable (terminal) | | failed | Fallido (terminal) | Los estados de los terminales son `charged`, `reversed`, `refunded`, `rejected`, `failed`. El camino feliz más común es `created → charging → charged`. ## Campos de tiempo | Campo | Definición | | ----- | ---------- | | started | Marca de tiempo ISO cuando comenzó el procesamiento | | finished | Marca de tiempo ISO cuando se completó el procesamiento; determinar el resultado del estado | ## Objetos de almacenamiento de dinero | Campo | Definición | | ----- | ---------- | | network | Red blockchain (ETH, TRX, etc.) | | type | Tipo de instrumento (bank_card, p2p_proxy, etc.) | | wallet_id | Identificador interno de billetera (destino de pago/pago) | | cardnumber | Tarjeta virtual PAN (enmascarada en algunas respuestas) | | cvv | Código de seguridad de la tarjeta virtual (nunca inicie sesión en texto plano) | | exp_month / exp_year | Valores de caducidad de la tarjeta (cadena, relleno con ceros) | | cardholder | Nombre del titular de la tarjeta (ASCII o UTF-8) | ## Campos de error | Campo | Definición | | ----- | ---------- | | error_description | Motivo del fallo legible por humanos (texto no estable) | ## Orientación sobre idempotencia Utilice un `txid` único (idempotente) por operación comercial y consérvelo antes de enviarlo. El valor es una cadena; La generación de UUID es conveniente pero no se requiere la sintaxis de UUID. Vuelva a intentar la misma instrucción con el mismo identificador en la misma cuenta. No lo reutilices para un destinatario o monto diferente. Recuperar la operación original después de un tiempo de espera; un nuevo intento no debe convertirse silenciosamente en un nuevo pago. ## Estrategia de encuesta Lecturas de encuesta con retroceso acotado, por ejemplo 1s → 2s → 4s → 8s, con un presupuesto de interacción de 30s. Deténgase en un estado final conocido o cuando expire el presupuesto. Cuando se agote el tiempo, informe un resultado pendiente/desconocido y conserve el `id`/`txid` original. Los estados desconocidos no son un éxito. Consulte [errores y reintentos](business/errors.md). ## Webhooks (informativo) Los webhooks indican cambios de estado pero no tienen autoridad. Confirme siempre mediante la transacción GET. ## Escala de importes Las cantidades son cadenas de números enteros en unidades menores, no valores de punto flotante. Obtenga decimales para la moneda, la red de `GET https://app.heth.me/api/v1/contracts?env=prod`. USDT/ETH y USDT/TRX utilizan actualmente decimales 6: 1 USDT = `"1000000"`, 0.25 USDT = `"250000"`. ETH tiene decimales 18; Esto no se aplica a todos los tokens de Ethereum. Una báscula desconocida debe detener la conversión de cantidades. Consulte el esquema [API](/openapi.json). ## es: Usa Heth.me: billeteras, transferencias y pagos Source: https://docs.heth.me/markdown/es/intro.md --- slug: "/" sidebar_position: 1 title: "Carteras, transferencias y pago API" sidebar_label: "Empezar" description: "Configure una billetera Heth.me, transfiera USDT, pague con QR y acepte pagos. Guías de usuario, instrucciones de integración empresarial y referencia de API." last_update: date: 2026-10-20 --- # Usa Heth.me: billeteras, transferencias y pagos Aprenda cómo configurar una cuenta Heth.me, recibir y transferir fondos, pagar compras y conectar la aceptación de pagos. Las guías de usuario explican la aplicación; la referencia API explica las solicitudes de integración. ## Comienza a usar tu billetera - [Crear o restaurar una cuenta](user/wallets.md) y comprender las cuentas criptográficas y los saldos de billetera. - [Reciba, transfiera o retire fondos](user/transfers.md), elija una red y un método de firma. - [Pague o acepte un pago mediante QR](user/payments.md) y comparta un enlace de recepción. - [Usa @nombres de usuario, tarjetas de regalo y donaciones](user/features.md), y configura notificaciones. - [Protege el acceso a la cuenta](user/security.md) y comprende los límites sin conexión. Las transferencias USDT en Ethereum y TRON utilizan diferentes detalles de recepción. Antes de confirmar, verifique el activo, la red, el destinatario y el monto. ## Conecta pagos para tu negocio Comience con una [solicitud de lectura que no mueve dinero](business/quick-start.md), luego elija la integración que necesita: - [Autenticación y claves API](business/authentication.md). - [Pagos, desembolsos y estado de transacciones](transactions/overview.md). - [Productos, enlaces de pago y suscripciones](business/resources.md). - [Webhooks: firmas y manejo de eventos](business/webhooks.md). - [Formatos de importe e identificador](field_conventions.md), [errores y reintentos](business/errors.md). Las funciones comerciales dependen de [acceso a la cuenta](business/capabilities.md). El éxito de HTTP no confirma el pago: verifique el estado de la transacción original. ## Conecte AI a Heth.me [Conecte su asistente AI a través de Heth MCP](ai/mcp.md) para usar su propia cuenta y las funciones comerciales disponibles. Tú eliges sus permisos y confirmas cada operación monetaria en Heth. La guía explica la conexión, transferencias, cambios comerciales, OBS y revocación. Los desarrolladores de integración AI pueden utilizar el [subconjunto documentado API](/openapi.json), el [índice de documentación](/llms.txt) y las [guías de texto completo](/llms-full.txt). Estos describen interfaces y reglas; Obtenga saldos actuales, permisos y resultados de operación del API. ## Aplicación y soporte [Abrir Heth.me](https://app.heth.me) · [Contactar con soporte](https://t.me/hethmesupport_bot) ## es: Suscripciones y pago automático Source: https://docs.heth.me/markdown/es/subscriptions.md --- title: "Suscripciones y pago automático" --- # Suscripciones y pago automático Una tienda puede pedirle a un usuario de Heth.me que apruebe pagos recurrentes. El pagador revisa y firma las condiciones con su HethWallet ordinaria desbloqueada. No se necesita una cuenta de correo electrónico separada ni iniciar sesión en el Portal del Cliente. Los pagos cargan el **saldo de la cuenta Heth** en la moneda y red acordadas. ## Para el pagador 1. Abra **Configuración → Suscripciones y pago automático**. Las nuevas solicitudes aparecen por separado de las suscripciones existentes. 2. Abra una solicitud y verifique la tienda, el monto por pago, la moneda/red y el período de facturación. Un enlace de confirmación abre la misma pantalla. Una billetera bloqueada solicita su PIN habitual y vuelve a la solicitud. 3. Elija **Habilitar suscripción** o **Rechazar**. Abrir un enlace o recibir una notificación nunca aprueba una suscripción. 4. Después de la aprobación, se programa el primer pago. La lista muestra el monto, período y próxima fecha de pago; al volver a intentar un pago fallido, muestra la hora del próximo reintento. 5. Revocar la suscripción para detener futuros cargos. La revocación no reembolsa los pagos completados. La aprobación registra el consentimiento y programa un pago; no significa que el pago se haya realizado correctamente. Verifique el estado de la transacción. El saldo debe ser suficiente cuando se ejecuta un pago. ## Cómo se anuncian las nuevas solicitudes Para un pagador reconocido, el servidor envía una solicitud de suscripción a los dispositivos registrados, con un enlace a `/subscriptions/confirm/?env=`. También se guarda una entrada en la campana de notificación, incluso cuando ningún dispositivo puede recibir la notificación. Las solicitudes pendientes permanecen disponibles en **Configuración → Suscripciones y pago automático**. Las PWA instaladas utilizan web push. Heth.me para iOS y Android, a partir de la versión 1.0.0 (compilación 5), utiliza notificaciones del sistema. Habilite las notificaciones en la billetera y permítalas en la configuración de su dispositivo. Al tocar una solicitud de suscripción, se abre su pantalla de confirmación; una billetera bloqueada primero solicita la PIN habitual o la clave de acceso disponible. Recibir o abrir una notificación no aprueba la suscripción. Si no llega una notificación, abre la lista de solicitudes pendientes o el enlace de confirmación de la tienda. ## Para la tienda En HethWallet, abra **Negocios → Suscripciones y pago automático**. Ingrese la dirección de la billetera del pagador, `@username` o el número de tarjeta Heth, el nombre de la suscripción, el monto por pago, la moneda/red y el período. Envíe la solicitud y luego copie su enlace de confirmación. Puede enumerar sus solicitudes y cancelar una solicitud mientras aún está pendiente. El operador debe habilitar las suscripciones Heth para la organización y configurar una ruta de pago funcional. Crear una solicitud no autoriza un débito. ## Crear una solicitud a través del API Utilice la clave API de la tienda o su sesión portadora de socio ordinario. En `app.heth.me`, la organización se resuelve desde el host. Una clave de solo lectura no puede crear ni cancelar solicitudes. ```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" }' ``` | Campo | Descripción | Tipo | Ejemplo | | --- | --- | --- | --- | | `request_id` | Único idempotente UUID. Reutilícelo con términos idénticos cuando vuelva a intentar la misma solicitud. | String | `b56b2c66-4ae5-4cb9-92ea-7a3297b72b55` | | `payer` | Dirección de billetera, nombre de usuario o número de tarjeta Heth. | String | `@alice` | | `description` | Nombre de la suscripción, caracteres 1–250 sin saltos de línea. | String | `Monthly membership` | | `amount` | Entero positivo en unidades menores simbólicas. Para 6- decimal USDT, `1000000` significa 1 USDT. | String | `1000000` | | `currency`, `network` | Par de token/red habilitado para el cuenta. Redes: `ETH`, `TRX`, `BASE`. | String | `USDT`, `ETH` | | `interval` | `daily`, `weekly`, `monthly` o `yearly`. | String | `monthly` | | `period` | Número de intervalos, 1–365; predeterminado 1. | Number | `1` | | `env` | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | String | `prod` | HTTP `201` devuelve la solicitud directamente, incluyendo `id`, `status`, `amount_decimals`, `confirm_url`, `expires_at`, `subscription_id` y `next_charge_at`. Las solicitudes caducan después de siete días. Una creación exitosa no revela si el pagador suministrado existe; sólo el destinatario real puede leer y aprobar la solicitud. ## Operaciones API Todas las rutas siguientes comienzan con `/api/v1`. Las operaciones de la tienda requieren la clave API de la tienda o la sesión de portador del socio. | Método y camino | Propósito | | --- | --- | | `POST /heth/subscription-requests` | Crea una solicitud. | | `GET /heth/subscription-requests?env=prod&limit=50` | Enumere las solicitudes de la tienda en `data` y `total`. | | `POST /heth/subscription-requests/:id/cancel` | Cancelar una solicitud pendiente; cuerpo `{"env":"prod"}`. | Para la primera página, omita `page`. Utilice `page=1` para la página siguiente y luego increméntelo; `limit` controla el tamaño de la página. Las operaciones de billetera requieren la sesión ordinaria de portador de billetera del pagador. La clave API de una tienda no puede aprobarse para el pagador. | Método y camino | Propósito | | --- | --- | | `GET /heth/subscriptions?env=prod&limit=50` | Suscripciones propias en `data`/`total`, solicitudes pendientes en `requests`/`requests_total`. | | `GET /heth/subscription-requests/:id?env=prod` | Lea la solicitud dirigida y la firma canónica `message`. | | `POST /heth/subscription-requests/:id/confirm` | Aprobar con `{"signature":"","env":"prod"}` después de revisar las condiciones exactas. | | `POST /heth/subscription-requests/:id/reject` | Rechazar; cuerpo `{"env":"prod"}`. | | `POST /heth/subscriptions/:id/revoke-mandate` | Detener cargos futuros; cuerpo `{"env":"prod"}`. | La firma vincula la tienda, el pagador, la organización, la descripción, el monto y su escala, la moneda/red, el intervalo y el período, la regla del primer pago, el nonce y el vencimiento. Cambiar las condiciones requiere una nueva solicitud y un nuevo consentimiento. Reintentar la aprobación o un pago programado no puede debitar el mismo período dos veces. Las marcas de tiempo API sin un sufijo de zona horaria son UTC; la aplicación muestra la hora local del dispositivo. ## Estados y errores Los estados de solicitud son `pending`, `signed`, `rejected` y `expired`. Una solicitud aprobada tiene un `subscription_id`. Realice un seguimiento de la finalización del pago real a través de la transacción API y los webhooks configurados. `401` significa autenticación faltante/no válida; `403` significa que las suscripciones están deshabilitadas o que la clave API es de solo lectura. Una solicitud inaccesible devuelve `404`. `422` indica términos no válidos, un UUID reutilizado con diferentes condiciones, una firma no válida o una solicitud caducada/cerrada. Una tienda no puede cambiar las condiciones firmadas de una suscripción activa sin el consentimiento del nuevo pagador. ## es: Pago Agregado (Cobro del Comerciante por Número de Tarjeta) Source: https://docs.heth.me/markdown/es/transactions/aggregator_payment.md --- title: "Pago Agregado (Cobro del Comerciante por Número de Tarjeta)" last_update: date: 2026-10-20 --- # Pago Agregado (Cobro del Comerciante por Número de Tarjeta) Ejemplo: `"1000000"` es 1 USDT cuando decimales=6. Reemplace todos los marcadores de posición con detalles verificados del destinatario y del instrumento. Enviar esta solicitud puede mover fondos reales. Revisar y autorizar explícitamente la operación antes de enviarla. Consulte [Inicio rápido](../business/quick-start.md). Este tipo de transacción permite que un agregador de servicios de pago acepte pagos de clientes en nombre de un comerciante integrado. Los fondos se debitan del Pagador y se distribuyen entre el Comerciante (neto de la tarifa del Agregador) y el Agregador (parte de la tarifa) automáticamente. ## Flujo de Negocios 1. El comerciante firma un acuerdo/se incorpora con el Agregador. 2. El agregador le indica al comerciante que cree (o proporcione) una billetera en el sistema heth.me y devuelve el `wallet_id`. 3. Usando su propia clave API, el Agregador crea una transacción de pago especificando los detalles de la billetera del Comerciante en `money_storage_merchant` y los detalles de la tarjeta del Pagador en `money_storage`. 4. Tras el procesamiento exitoso, los saldos del Pagador, Comerciante y Agregador se actualizan en un solo paso. 5. El estado de la transacción se puede sondear utilizando el método de recuperación de transacciones estándar (autorizado con la misma clave API). ## Solicitud de ejemplo ```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" } }' ``` ## Referencia de campo | Campo | Descripción | Tipo | Ejemplo | | ----- | ----------- | :--- | ------- | | amount | Monto de la transacción (cadena de un número entero en unidades menores) | String | 1000000 | | currency | Moneda de transacción (predeterminada USDT) | String | USDT | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | String | prod | | type | Tipo de transacción (pago) | String | payment | | route | Ruta de procesamiento (debe coincidir con la asignación configurada) | String | hot_hot_ETH | | money_storage_merchant | Descriptor de billetera del comerciante (beneficiario) | Object | | | > wallet_id | Identificador de billetera comercial | String | YOUR_WALLET_ID | | > network | Red blockchain (TRX o ETH) | String | ETH | | > type | Tipo de interacción de billetera (por ejemplo, p2p_proxy) | String | p2p_proxy | | > currency | Moneda de liquidación del comerciante (predeterminado USDT) | String | USDT | | money_storage | Descriptor del instrumento de financiación del pagador | Object | | | > network | Red blockchain (TRX o ETH) | String | ETH | | > type | Tipo de instrumento (tarjeta_bancaria) | String | bank_card | | > currency | Moneda del pagador (predeterminado USDT) | String | USDT | | > cardnumber | Número de tarjeta virtual | String | YOUR_CARD_NUMBER | | > cvv | Tarjeta virtual CVV | String | YOUR_CVV | | > exp_month | Mes de caducidad de la tarjeta | String | 08 | | > exp_year | Año de caducidad de la tarjeta | String | 2026 | | > cardholder | Nombre del titular de la tarjeta | String | John Doe | | description | Descripción legible por humanos | String | Payment | | txid | Identificador de transacción idempotente (cadena) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## Notas * La lógica de tarifas del Agregador se aplica automáticamente según la configuración de la clave API. * Asegúrese de que `route` coincida con una ruta de procesamiento habilitada para la clave API proporcionada. * Utilice valores `txid` idempotentes para evitar envíos duplicados accidentales. * Recuperar el estado de la transacción a través del punto final de transacción estándar GET (sondeo hasta que se alcanza un estado de terminal). ## es: Obtener estado de transacción Source: https://docs.heth.me/markdown/es/transactions/get_transaction.md --- title: "Obtener estado de transacción" last_update: date: 2026-10-20 --- # Obtener estado de transacción Recupere el estado más reciente de una transacción específica mediante su `id` interno usando su clave API. ## Solicitud ``` GET /api/v1/transactions/{transaction_id}?env=prod Headers: x-api-key: ``` `{transaction_id}` es el `id` (UUID) interno de la transacción, pasado como segmento de ruta. ## Campos de respuesta | Campo | Descripción | | ----- | ----------- | | amount | Importe en unidades menores | | amount_with_fee | Importe incluida la tarifa (unidades menores) | | amount_dest | Importe de destino de la conversión (unidades menores), si procede | | currency | Código de moneda (por ejemplo, USDT) | | currency_dest | Moneda de destino para la conversión, si corresponde | | description | Descripción original proporcionada | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | | error_description | Detalles del error si se rechaza el estado | | finished | Finalizar marca de tiempo (ISO) si terminal | | id | Identificador de transacción interna (UUID) | | route | Ruta de procesamiento utilizada | | started | Marca de tiempo de inicio (ISO) | | status | Estado actual (consulte Estado del ciclo de vida en Convenciones de campo; por ejemplo, creado, cobrando, cobrado, reembolsado, rechazado, fallido) | | txid | Identificador externo proporcionado por el cliente | | type | Tipo de transacción (pago o desembolso) | | widget_url | Enlace del widget (si el widget fluye) | | simple_auth_redirect_url | 3DS / autenticación adicional URL cuando corresponda | ## Ejemplo ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## Notas de uso * Encuesta con retroceso exponencial (por ejemplo, 1, 2, 4, 8) hasta un estado terminal. * Determinar el resultado de `status`; un `finished` ausente o presente por sí solo no es prueba del resultado. * `txid` debe ser idempotente por operación comercial. ## Recuperar mediante identificador de operación externa ```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' ``` ## es: Listar transacciones Source: https://docs.heth.me/markdown/es/transactions/list_transactions.md --- title: "Listar transacciones" last_update: date: 2026-10-20 --- # Listar transacciones Lea las transacciones de su cuenta. La respuesta es un objeto con `data` y `cursor`, no una matriz simple. Utilice un período acotado. Consulte el [Inicio rápido](../business/quick-start.md), [autenticación](../business/authentication.md) y [manejo de errores](../business/errors.md). ```http GET /api/v1/transactions?env=prod&order_by=started&limit=30 x-api-key: YOUR_API_KEY ``` ## Filtros | Filtro | Significado | | --- | --- | | `started_from / updated_from` | Inicio del rango de tiempo (ISO 8601) | | `started_to / updated_to` | Fin del rango de tiempo (ISO 8601) | | `type` | Filtrar por tipo | | `status` | Filtrar por estado | | `txid` | Cadena de operación externa exacta | | `order_by` | iniciado o actualizado | | `limit` | Tamaño de página: 1–500, predeterminado 100 | | `env` | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | | `cursor` | Marca de tiempo devuelta como valor_cursor | ```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" } } ``` ## Página siguiente Pase el `cursor.cursor_value` devuelto como la cadena de consulta `cursor`, no todo el objeto del cursor. Mantenga el mismos filtros y order_by. Para order_by=updated, cursor_field se puede actualizar_at. Deténgase cuando los datos estén vacíos o no se devuelva ningún cursor que avance. Concilie por ID de transacción cuando los registros cambien durante el recorrido. ```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' ``` ## es: Transacción API Source: https://docs.heth.me/markdown/es/transactions/overview.md --- title: "Transacción API" last_update: date: 2026-10-20 --- # Transacción API Elija el flujo para la ruta de su cuenta habilitada. Estos son instrumentos virtuales Heth, no una promesa general de aceptar o pagar con ninguna tarjeta bancaria externa. Consulte el [Inicio rápido](../business/quick-start.md), [autenticación](../business/authentication.md) y [manejo de errores](../business/errors.md). ## Crear - [Pago con tarjeta virtual](pcn.md) - [Pago a tarjeta virtual](wcn.md) - [Pago a una billetera ID](wid.md) - [Pago agregado](aggregator_payment.md) ## Leer - [Obtener una transacción](get_transaction.md) - [Listar transacciones](list_transactions.md) ## Referencia - [Importes, identificadores y estados](../field_conventions.md) ## es: Pago por Número de Tarjeta Source: https://docs.heth.me/markdown/es/transactions/pcn.md --- title: "Pago por Número de Tarjeta" last_update: date: 2026-10-20 --- # Pago por Número de Tarjeta Ejemplo: `"1000000"` es 1 USDT cuando decimales=6. Reemplace todos los marcadores de posición con detalles verificados del destinatario y del instrumento. Enviar esta solicitud puede mover fondos reales. Revisar y autorizar explícitamente la operación antes de enviarla. Consulte [Inicio rápido](../business/quick-start.md). Iniciar un pago utilizando un instrumento de tarjeta virtual. ## Ejemplo de solicitud ```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" } }' ``` | Campo | Descripción | Tipo | Ejemplo | | ----- | ----- | :--- | ----- | | amount | Monto de la transacción (cadena de un número entero en unidades menores) | String | 1000000 | | currency | Moneda de transacción (predeterminada USDT) | String | USDT | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | String | prod | | type | Tipo de transacción (en este caso pago) | String | payment | | route | Ruta de transacción (debe coincidir con el mapeo de ruta) | String | hot\_hot\_ETH | | money_storage | Descriptor de instrumento de tarjeta | Object | | | \>network | Red blockchain (TRX o ETH) | String | ETH | | \>type | Tipo de instrumento (tarjeta_bancaria) | String | bank_card | | \>currency | Moneda del instrumento (predeterminado USDT) | String | USDT | | \>cardnumber | Número de tarjeta virtual | String | YOUR_CARD_NUMBER | | \>cvv | Tarjeta virtual CVV | String | YOUR_CVV | | \>exp_month | Mes de vencimiento | String | 10 | | \>exp_year | Año de vencimiento | String | 2026 | | \>cardholder | Nombre del titular de la tarjeta | String | John Doe | | description | Descripción de la transacción | String | Payment | | txid | Identificador de transacción idempotente (cadena) | String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## es: Pago con billetera ID Source: https://docs.heth.me/markdown/es/transactions/pid.md --- title: "Pago con billetera ID" last_update: date: 2026-10-20 --- # Pago con billetera ID Esta página describe el mismo flujo de pago de billetera-ID que la referencia canónica. Utilice la solicitud y las definiciones de campo allí. [Pago mediante billetera ID](wid.md) ## es: Pago agregador con tarjeta virtual Source: https://docs.heth.me/markdown/es/transactions/rcn.md --- title: "Pago agregador con tarjeta virtual" last_update: date: 2026-10-20 --- # Pago agregador con tarjeta virtual Esta página describe el mismo flujo de recopilación de comerciantes que la referencia del agregador canónico. Utilice esa solicitud y sus definiciones. [Pago agregador mediante tarjeta virtual](aggregator_payment.md) ## es: Retiro por Número de Tarjeta Source: https://docs.heth.me/markdown/es/transactions/wcn.md --- title: "Retiro por Número de Tarjeta" last_update: date: 2026-10-20 --- # Retiro por Número de Tarjeta Ejemplo: `"1000000"` es 1 USDT cuando decimales=6. Reemplace todos los marcadores de posición con detalles verificados del destinatario y del instrumento. Enviar esta solicitud puede mover fondos reales. Revisar y autorizar explícitamente la operación antes de enviarla. Consulte [Inicio rápido](../business/quick-start.md). Iniciar un pago (fondos enviados a un número de tarjeta). ## Ejemplo de solicitud ```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" } }' ``` | Campo | Descripción | Tipo | Ejemplo | | ----- | ----- | :--- | ----- | | amount | Monto de la transacción (cadena de un número entero en unidades menores) | String | 1000000 | | currency | Moneda de transacción (predeterminada USDT) | String | USDT | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | String | prod | | route | Ruta de transacción (debe coincidir con el mapeo de ruta) | String | hot\_hot\_ETH | | type | Tipo de transacción (en este caso pago) | String | payout | | money\_storage | Objeto de datos del destinatario | Object | | | \>network | Red blockchain (TRX o ETH) | String | ETH | | \>type | Tipo de instrumento (banco\_tarjeta) | String | bank\_card | | \>currency | Moneda del destinatario (predeterminado USDT) | String | USDT | | \>cardnumber | Número de tarjeta del destinatario | String | YOUR_CARD_NUMBER | | description | Descripción de la transacción | String | Withdrawal | | txid | Identificador de transacción idempotente (cadena) | String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## es: Retiro por ID Source: https://docs.heth.me/markdown/es/transactions/wid.md --- title: "Retiro por ID" last_update: date: 2026-10-20 --- # Retiro por ID Ejemplo: `"1000000"` es 1 USDT cuando decimales=6. Reemplace todos los marcadores de posición con detalles verificados del destinatario y del instrumento. Enviar esta solicitud puede mover fondos reales. Revisar y autorizar explícitamente la operación antes de enviarla. Consulte [Inicio rápido](../business/quick-start.md). Pago a un identificador de billetera. ## Ejemplo de solicitud ```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" } }' ``` | Campo | Descripción | Tipo | Ejemplo | | ----- | ----- | :--- | ----- | | amount | Monto de la transacción (cadena de un número entero en unidades menores) | String | 1000000 | | currency | Moneda de transacción (predeterminada USDT) | String | USDT | | env | `prod` (predeterminado). Conserve este valor al abrir y confirmar la solicitud. | String | prod | | route | Ruta de transacción (debe coincidir con el mapeo de ruta) | String | hot\_hot\_ETH | | type | Tipo de transacción (en este caso pago) | String | payout | | money\_storage | Objeto de datos del destinatario | Object | | | \>wallet\_id | Identificador de billetera del destinatario | String | YOUR_WALLET_ID | | \>network | Red blockchain (TRX o ETH) | String | ETH | | \>type | Tipo de transacción para billeteras (en este caso p2p\_proxy) | String | p2p\_proxy | | \>currency | Moneda del destinatario (predeterminado USDT) | String | USDT | | description | Descripción de la transacción | String | Withdrawal | | txid | Identificador de transacción idempotente (cadena) | String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## es: Funciones adicionales de la cuenta Source: https://docs.heth.me/markdown/es/user/features.md --- title: "Funciones adicionales de la cuenta" last_update: date: 2026-10-21 --- # Funciones adicionales de la cuenta Las funciones que se muestran en su cuenta dependen de su configuración. Las siguientes explicaciones no significan que todas las funciones estén habilitadas para todos los usuarios. ## @nombresdeusuario En la configuración del nombre de usuario, verifique la disponibilidad y el precio de registro mostrado. Seleccione la billetera de fondos elegible y siga las instrucciones de pago. Una reserva impaga no es un nombre receptor activo. Verifique los términos de vencimiento y renovación antes de pagar; es posible que un nombre caducado o suspendido no se resuelva. Se puede rechazar la liberación de un nombre mientras se esté realizando el pago. ## Tarjetas de regalo En la pantalla de la tarjeta de regalo, puede ver sus problemas, preparar un problema admitido o canjear un código. La emisión de una tarjeta la financia desde su propia billetera elegible y requiere confirmación. Guarde el código revelado de forma segura: la posesión del código puede permitir el canje. Para canjear, ingrese el código en Heth; el servidor determina su denominación. Una solicitud enviada por sí sola no es una confirmación de crédito. ## Gasolina La pantalla de compra de gas prepara una operación separada utilizando la fuente de financiamiento respaldada. Consulta la cuenta de destino, importe y red. Una fuente de financiación fría puede requerir una firma. El gas para una transferencia de blockchain está separado de la cantidad del token transferido. ## Donaciones Abra la página de donación del autor y verifique la plataforma, el autor, el activo, la red, el mínimo y la tarifa. Elija una Heth Wallet disponible o una cuenta externa y revísela antes de autorizar. Las transferencias externas pueden caducar; Verifique los detalles actuales antes de enviar. La página de resultados muestra el estado de la donación original. ## Notificaciones y webhooks 1. Abra **Configuración → Notificaciones**, active las notificaciones y apruebe el mensaje del sistema o del navegador. En la aplicación móvil, Heth utiliza notificaciones del sistema; la versión del navegador utiliza el servicio de notificación del navegador cuando sea compatible. 2. Si se le negó el permiso, permita las notificaciones de Heth en la configuración de su dispositivo o navegador, vuelva a abrir Heth e inténtelo nuevamente. La entrega también depende de la conectividad y las restricciones del dispositivo. 3. Para detener las notificaciones en este dispositivo, apague el mismo interruptor. Esto no cancela pagos, suscripciones o conexiones AI. Al abrir una notificación de pago, accederá a Heth. Desbloquee la cuenta y revise cualquier acción solicitada allí; tocar una notificación no firma ni aprueba un pago. Verifique el resultado final en el historial de transacciones. En la configuración del webhook, puede configurar un URL receptor y un secreto para una integración externa. Este URL recibe eventos de cuenta; Utilice un punto final que usted controle. Consulte [integración de webhook](../business/webhooks.md). ## Suscripciones, hardware y multifirma Administre solicitudes de suscripción y permisos de pagos futuros en Heth. La [guía de suscripción y pago automático](../subscriptions.md) explica la aprobación del pagador, las solicitudes de los comerciantes, las fechas de pago y la revocación. Vincular una tarjeta de pago o autorizar futuros débitos requiere su consentimiento explícito. Para cuentas de hardware o multifirma, verifique que su dispositivo y método de firma admitan la red seleccionada antes de enviar fondos. En **Configuración → Mandatos de suscripción**, las cuentas con esta función pueden ver sus propios permisos de suscripción criptográfica y límites por cargo. Elija un permiso, seleccione **Revocar mandato** y confirme en Heth para detener futuros cargos. La revocación no reembolsa los pagos completados. ## Widget de donación de OBS Studio Agregue el widget Heth como fuente del navegador OBS Studio para mostrar un QR receptor, temas visuales y alertas de pagos entrantes. Conéctelo a través de **Configuración → OBS Studio** en Heth. Mantenga la conexión privada URL fuera de escenas públicas y conversaciones de AI. Un asistente que utilice MCP puede leer el feed de eventos restringido y cambiar la configuración de apariencia admitida; Los permisos de acceso están confirmados en Heth. [Guía de configuración OBS](./obs.md). Tus [límites de pago](payments.md#payment-limits) también se aplican al valor total de las tarjetas regalo emitidas. Un código válido no anula el máximo. ## es: OBS Studio: recepción de QR y alertas de pago Source: https://docs.heth.me/markdown/es/user/obs.md --- title: "OBS Studio: recepción de QR y alertas de pago" last_update: date: 2026-10-21 --- # OBS Studio: recepción de QR y alertas de pago El widget Heth es una **fuente del navegador** en OBS Studio. Muestra su QR recibido y alertas de transferencias Heth entrantes y completadas. No instala un complemento OBS nativo y no controla escenas, grabaciones o transmisiones. Una transferencia entrante no es automáticamente una donación del autor/plataforma. ![Vista previa del widget actualizado en inglés. Evento de muestra; la vista previa QR no inicia un pago.](/img/obs-preview-en.png) Vista previa del widget actualizado en inglés. Evento de muestra; la vista previa QR no inicia un pago. ## Conecta el widget 1. Abra Heth e inicie sesión en la cuenta que recibirá donaciones. 2. Abra **Configuración → OBS Studio**. El destinatario es su cuenta Heth iniciada. 3. Seleccione un par de moneda/red disponible. Opcionalmente, ingrese una cantidad sugerida, título, tema e idioma. Una cantidad vacía permite al pagador elegirla. 4. Guarda la apariencia. Elija **Aprobar y crear conexión OBS** para crear un acceso restringido e independiente para el widget. 5. Copia la conexión URL. En OBS, agregue una fuente **Navegador** y pegue el archivo URL. Comience con un tamaño de fuente de **900 × 500** píxeles; cambie el tamaño o recorte para adaptarse a su escena. 6. Verifique el destinatario, la moneda y la red escaneando el QR con su teléfono. Revise la pantalla de pago antes de confirmar cualquier pago. El QR por sí solo no mueve dinero. El fondo es transparente. Mantenga el QR despejado y lo suficientemente grande para escanear. Verifique el resultado en la escena real, incluso con la resolución que reciben los espectadores. El widget admite ruso e inglés independientemente del idioma de su interfaz Heth. ## Acceso y privacidad La conexión utiliza una clave API separada restringida a OBS. Heth crea la clave y la coloca en la conexión URL, por lo que no es necesario copiar una clave desde la configuración empresarial. La configuración de webhook existente es independiente: los webhooks envían eventos a su servidor, mientras que la fuente del navegador OBS lee directamente el feed restringido del widget. No es necesario ejecutar un receptor de webhook para el widget estándar. Una clave OBS pertenece a su cuenta y puede leer su feed de widgets. Los permisos MCP se otorgan por separado; revocar una conexión OBS y revocar una conexión AI son acciones independientes. La conexión URL contiene un token de acceso privado OBS en su fragmento, después de `#`. Trate todo el URL como privado: no lo incluya en la descripción de su transmisión, capturas de pantalla, exportaciones de escenas públicas o en un chat de AI. El QR que se muestra a los espectadores contiene detalles de pago, no este token. El acceso OBS puede leer el identificador de recepción, la configuración de apariencia y un feed de pagos entrantes restringido. No puede leer su saldo ni su historial de transacciones completo, enviar dinero ni editar configuraciones. En **Configuración → OBS Studio**, revoca una conexión antigua si su URL estuvo expuesto o dejaste de usarlo. Cree una nueva conexión en Heth cuando sea necesario. ## Cómo funcionan las alertas Las alertas representan transferencias entrantes con estado `charged`. Se excluyen las operaciones pendientes, fallidas y salientes. El monto utiliza el monto del destinatario y su precisión almacenada; no se redondea a una ficha completa. Si la precisión no está disponible, el widget no inventa una cantidad. Una nueva conexión comienza con nuevos eventos. Una fuente de navegador en ejecución puede reanudarse desde su cursor guardado después de una breve interrupción; su ventana de reproducción está limitada a horas 24. Recargar o recrear una fuente no es una forma de exportar el historial de la cuenta. Verifique los detalles de recepción y operación final en [historial de transacciones](./payments.md), independientemente de una alerta en vivo. ## Cambia el widget con un asistente AI Un asistente conectado usando el [control remoto MCP servicio](../ai/mcp.md) con los permisos adecuados puede leer la configuración del widget, ver el feed de eventos restringido y proponer una conexión. Puede cambiar la configuración de apariencia normal con confirmación en el AI cliente. El widget ya conectado actualiza automáticamente la apariencia guardada, normalmente dentro de 30 artículos de segunda clase. Crear o revocar el acceso y cambiar una cuenta receptora requiere confirmación en Heth. El asistente proporciona un enlace a la pantalla de configuración de Heth; no recibe la conexión privada OBS URL. Solicitudes de ejemplo: "Usar un título en inglés y un tema mínimo para mi widget OBS" o "Mostrar eventos entrantes recientes para mi widget". MCP no le da al asistente el control de OBS Studio. ## Su propio diseño y personalización asistida por AI {#custom-layout} La configuración estándar de Heth no necesita acceso al código fuente. Para un diseño arbitrario, bifurque el widget público [Heth OBS](https://github.com/Heth-me/obs-widget), con licencia MIT. Comience con su [guía AI](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md), mapa de archivos e instrucciones de alojamiento. El repositorio incluye instrucciones de compilación y alojamiento. Un asistente de codificación con acceso a su copia puede cambiar el diseño, CSS, fuentes, colores y presentación de notificaciones, luego verificar una vista previa sintética y compilar. No necesita su conexión OBS en vivo URL ni sus credenciales de pago. Se debe alojar una compilación personalizada: un repositorio público por sí solo no envía alertas de pagos entrantes. Heth MCP puede leer eventos y cambiar la configuración de apariencia de Heth admitida. No edita un repositorio, no compila una compilación personalizada ni le da acceso a un asistente a su cuenta de hosting. Para diseños arbitrarios de HTML/CSS, personalice el proyecto de código abierto. Puede seguir usando el widget estándar alojado en Heth sin crear nada. ## Solución de problemas **Heth muestra un 404 en lugar del widget:** actualice Heth, verifique la fuente del navegador URL y vuelva a abrir la fuente. Si el error persiste, comuníquese con el soporte. No cree nuevas claves para corregir un error de carga de página. - **No hay entrada de configuración de OBS:** actualice Heth y verifique el acceso a su cuenta con soporte. No pegue una clave de cuenta general API en un widget URL. - **Aparece QR, no hay alerta:** verifique que la transferencia se haya completado y sea entrante a esta cuenta. La fuente del navegador debe permanecer activa y en línea. - **Acceso deshabilitado:** reconectarse en Heth; volver a intentar un URL revocado no restaurará el permiso. - **Activo o red incorrectos:** corrija la configuración en Heth, espere a que se actualice el widget y escanee el QR nuevamente antes de aceptar pagos. - **El antiguo URL usa `api_key=`:** vuelva a conectarse a través de Configuración → OBS Studio. Mantenga privado el antiguo URL y revoque una clave de cuenta obsoleta. ## es: Pagar y recibir pagos Source: https://docs.heth.me/markdown/es/user/payments.md --- title: "Pagar y recibir pagos" last_update: date: 2026-10-23 --- # Pagar y recibir pagos ## Límites de pago {#payment-limits} Abre `Settings → Amount Confirmation → Payment limits`. Los límites tienen su propia moneda; la predeterminada es USDT. Se aplican solo dentro de Heth: pagos con tu QR de pagador o código de confirmación de importe, emisión de tarjetas regalo con ese código y transferencias internas iniciadas mediante IA. No se aplican a transferencias en blockchain ni a transferencias ordinarias que inicies manualmente. Las comisiones de red quedan excluidas. - **Without a code, up to**: hasta este valor inclusive no hace falta un código adicional. Pon cero para exigir confirmación en cada pago. - **Maximum per payment**: los pagos superiores se rechazan incluso con un código válido. Déjalo vacío si no quieres un límite máximo. Antes de cada uno de estos pagos, Heth evalúa el importe debitado de tu cuenta, incluidas las comisiones de plataforma debitadas de esa cuenta, en la moneda del límite. Los tokens fiduciarios usan la moneda de origen: RUB_T usa RUB, UZS_T usa UZS y cNGN usa NGN. Los decimales del token se tratan por separado. USDT se valora en 1 USD para este cálculo de referencia. La comprobación no cambia tus activos. Las equivalencias aproximadas ayudan a interpretar los límites en otra moneda. Cambiar la moneda de visualización no cambia el límite guardado ni el importe del pago. Cuando está disponible, se muestra la fecha del tipo de cambio. Si no hay un tipo actual, Heth no puede autorizar un pago sujeto a un máximo estricto; inténtalo más tarde. El código de confirmación permite pagar hasta el importe numérico confirmado: para una factura de **9987**, puedes confirmar **10000** y se debitan **9987**. El código no anula los límites. Las transferencias asistidas por IA siguen requiriendo aprobación en Heth, independientemente del umbral sin código. Los tipos de referencia provienen de bancos centrales y, para monedas no cubiertas, de [ExchangeRate-API](https://www.exchangerate-api.com). ## Paga con Heth Abra la pantalla de pago y siga el método de pago disponible. Un pagador QR puede autorizar un pago: compártelo solo con el comerciante previsto. Cuando la aplicación solicite confirmación del monto, verifique el comerciante y el monto antes de confirmar. Nunca envíe su frase de recuperación o secreto de pago a un comerciante o asistente de AI. La aplicación puede mostrar información almacenada en caché o generar ciertos códigos de pago sin conexión. El comerciante aún necesita conectividad para procesar el pago; Las transferencias ordinarias no se ejecutan sin conexión. Consulte [límites sin conexión](security.md). ## Confirmar el monto del pago Siga el método de confirmación que Heth muestra para este pago: 1. Abra su pagador QR y muéstrelo solo al comerciante previsto. 2. Verifique el monto solicitado y el destinatario antes de aprobar. 3. Si Heth le pide que genere un código, regrese a la pantalla de confirmación de monto después de mostrar su QR, ingrese el monto del pago y genere el código actual. 4. Lea ese código al cajero solo para este pago. Es diferente de una frase de recuperación, PIN o secreto de pago reutilizable, que debes mantener en privado. 5. Si el QR o el código caduca, abra uno nuevo y siga las instrucciones actuales. Si la confirmación no está configurada, complete la configuración en Heth mientras está en línea. 6. Verifique el estado de la transacción original. Un QR mostrado, un código generado o una solicitud de cajero no prueban por sí solos el pago. ## Aceptar un pago Heth 1. Abrir **Negocios**. 2. Ingrese el monto y seleccione un activo/red disponible. 3. Escanee el Heth QR del pagador y envíe la solicitud. 4. Si se requiere la aprobación del pagador, espérela. 5. Trate el pago como recibido solo cuando su estado sea `charged`. Un rechazo, un resultado pendiente y un tiempo de espera son resultados diferentes. Conserve el identificador de operación original al comprobar el resultado. ## Comparte un enlace de recepción La pantalla de enlace de pago genera un Heth que recibe URL con su identificador de destinatario, la moneda seleccionada y, opcionalmente, un monto. El pagador revisa y autoriza la transferencia. Compartir el enlace no le cobra a nadie. Este URL de recepción difiere de un enlace de pago comercial administrado creado a través de un API. No asuma que un enlace de recepción generado localmente tiene una función de lista, vencimiento o cancelación del lado del servidor. ## Otros proveedores de QR Utilice únicamente los métodos realmente habilitados para su cuenta. Un logotipo de proveedor QR o un escáner que reconozca un formato no es prueba de que la ruta de pago correspondiente esté disponible. Póngase en contacto con el soporte si no se puede utilizar un método; no sustituya a otro destinatario o red para forzar el pago. ## es: Seguridad de la cuenta y uso sin conexión Source: https://docs.heth.me/markdown/es/user/security.md --- title: "Seguridad de la cuenta y uso sin conexión" last_update: date: 2026-10-21 --- # Seguridad de la cuenta y uso sin conexión ## Recuperación y firma Guarde las frases de recuperación y las claves privadas en la billetera que las posee. Un PIN o desbloqueo biométrico protege el acceso en el dispositivo actual; no reemplaza una copia de seguridad de recuperación. Nunca comparta una semilla, una clave privada o un secreto de pago reutilizable con el soporte, un comerciante o un asistente de AI. Muestre un pago único QR solo al comerciante previsto. Si el Modo B le pide explícitamente que lea un código de confirmación al cajero, hágalo solo después de verificar ese pago y su monto. Verifica el origen, destinatario, monto, moneda y red antes de firmar. Volver a conectar una cuenta, cambiar una red o abrir una billetera no completa un pago por sí solo. Para una billetera de hardware, verifique también los detalles en el dispositivo. ## Cara ID / Toque ID y claves de acceso En **Configuración → Cara ID / Toque ID**, habilite el desbloqueo biométrico si esta opción está disponible, luego confirme el mensaje del sistema. Heth utiliza una credencial WebAuthn (clave de acceso) para el desbloqueo local. La disponibilidad depende del dispositivo y del navegador; use su PIN cuando el desbloqueo biométrico no esté disponible o esté cancelado. Esto desbloquea Heth en el dispositivo actual. No reemplaza su frase de recuperación, no recupera una cuenta en otro dispositivo ni autoriza una conexión o pago AI. Mantenga su copia de seguridad de recuperación antes de cambiar de dispositivo o reinstalar Heth. ## Límites sin conexión Los saldos y el historial almacenados en caché se pueden ver sin conexión, pero es posible que estén desactualizados. Algunos códigos de pago se pueden generar localmente para un comerciante que está en línea. Enviar transferencias, cargar saldos actuales y recibir un resultado de procesamiento confirmado requiere conectividad. Después de volver a conectarse, actualice el historial antes de repetir cualquier operación. ## Tarifas y soporte Consulta las tarifas y el monto mostrado para la operación real. Una tarifa de gas blockchain puede ser independiente de la tarifa de servicio. No infieras una tarifa o un tiempo de finalización garantizado de otro tipo de transferencia. Utilice [Heth support](https://t.me/hethmesupport_bot) y comparta el identificador de la transacción y la descripción del problema. No envíe secretos de cuenta. Lea la [Política de Privacidad](https://app.heth.me/settings/legal/privacy-policy) y los [Términos de Servicio](https://app.heth.me/settings/legal/terms-of-service) en Heth. [Problemas y estado de pago](troubleshooting.md). ## es: Transferir y retirar fondos Source: https://docs.heth.me/markdown/es/user/transfers.md --- title: "Transferir y retirar fondos" last_update: date: 2026-10-20 --- # Transferir y retirar fondos Elija primero la fuente: un saldo interno de Wallet o una cuenta criptográfica. Luego seleccione el destinatario, el activo y la red. Consulta el importe, destinatario y tasas en la revisión final antes de autorizar la operación. ## Tipos de transferencia | Traslado | Acción del usuario | | --- | --- | | Cartera → Cartera | Ingrese el identificador del destinatario o resuelva un @username activo, luego revise la transferencia | | Monedero → Cuenta criptográfica | Ingrese la dirección externa y su red; revisar el retiro y las tarifas | | Cuenta criptográfica → Monedero | Seleccione la cuenta de origen y la Cartera de destino; firmar la transacción blockchain preparada | | Cuenta criptográfica → Cuenta criptográfica | Verifique el destinatario externo y firme usando la billetera del propietario | Una transferencia interna y un retiro en blockchain tienen diferentes requisitos de procesamiento y tarifas. Las transferencias blockchain pueden necesitar un equilibrio de gas nativo. La compra de gas es una operación separada; verificar la cuenta de origen y de destino. ## Carteras externas y de hardware Para direcciones de solo observación, use la billetera externa conectada a esa dirección. La cuenta y la red conectadas deben coincidir con la fuente. Los métodos de firma admitidos dependen de la red, el navegador y el dispositivo. Es posible que una transferencia abierta a través de un enlace de billetera no devuelva un hash de transacción a Heth: abrir otra billetera no es prueba de pago. ## Si el resultado no está claro Abra el historial de transacciones e inspeccione la operación original. No repita la transferencia únicamente porque la pantalla se agotó o la red se desconectó. Guarde su identificador y comuníquese con el soporte si el estado no está claro. Una operación pendiente no debe describirse como un pago completado. [Problemas y estado de pago](troubleshooting.md). ## es: Problemas de pago y estado de la transacción Source: https://docs.heth.me/markdown/es/user/troubleshooting.md --- title: "Problemas de pago y estado de la transacción" description: "Encuentre un pago Heth original, comprenda un resultado pendiente y resuelva problemas de red, saldo o confirmación QR." last_update: date: 2026-10-20 --- # Problemas de pago y estado de la transacción ## Se agotó el tiempo de espera de la pantalla: ¿debo enviar nuevamente? 1. Restaure la conexión y abra el historial de transacciones en la misma cuenta. 2. Encuentra la operación original por su identificador, hora, importe y destinatario. Abra sus detalles si están disponibles. 3. Verifique el estado actual. Si la operación queda pendiente o no se puede encontrar, contacta con soporte antes de volver a enviar. Un resultado faltante no es prueba de que no se movió dinero. 4. Conservar el identificador original para seguimiento. Para integraciones API, utilice [búsqueda de estado](../transactions/get_transaction.md) y el mismo `txid` original; no cree un identificador de reemplazo para evitar un tiempo de espera. | Estado | Qué hacer | | --- | --- | | `created`, `pending`, `processing` | El procesamiento no está completo. Actualizar la operación original; no lo cuentes como recibido | | `auth_required` | Abra Heth y siga la aprobación solicitada para esta operación | | `charged` | La operación se ha zanjado. Consulta su importe, destinatario y tarifa en los detalles | | `rejected`, `failed` | Lea el error original y resuelva su causa antes de intentar una nueva operación | | No status or an unfamiliar status | Mantener el resultado sin confirmar y solicitar aclaración; no infieras el éxito o el fracaso | Un reembolso o reversión es un resultado separado. Confírmelo a partir de la operación original y del saldo acreditado real. Una transferencia de blockchain no se puede cancelar simplemente cerrando Heth. ## El saldo o los detalles de recepción parecen incorrectos - Verifique la cuenta, el activo, la red. Una billetera interna y una cuenta criptográfica son destinos diferentes. - Actualizar después de volver a conectarse. Una pantalla sin conexión puede contener información almacenada en caché. - Para un depósito externo, compare el destino y la red en la billetera de envío con los detalles de recepción de Heth. Una transacción en otra red no acredita esta cuenta automáticamente. - Si falta una cuenta fría adicional en otro dispositivo, vuelva a conectar su billetera original. Consulte [cuentas y respaldo](wallets.md). ## El pagador QR o confirmación de monto no funciona Abra un nuevo pagador QR en Heth. Si la aplicación solicita un código de confirmación, siga las [instrucciones de pago](payments.md), verifique el monto y use el código actual. Un QR no es un recibo. El comerciante necesita conectividad para procesar la solicitud. Si la aplicación dice que la confirmación no está configurada, complete su configuración en Heth mientras está en línea. ## Contactar con soporte Envíe el identificador de la transacción, la hora aproximada con la zona horaria, el activo/red, el monto y el error visible a [Heth support](https://t.me/hethmesupport_bot). Oculte información personal no relacionada en capturas de pantalla. Nunca incluya una frase de recuperación, clave privada, clave API, pagador QR, código de tarjeta de regalo o secreto de pago reutilizable. ## es: Comience y comprenda sus billeteras Source: https://docs.heth.me/markdown/es/user/wallets.md --- title: "Comience y comprenda sus billeteras" last_update: date: 2026-10-20 --- # Comience y comprenda sus billeteras Abra [Heth.me](https://app.heth.me). Cree una frase de recuperación o restaure su cuenta existente, luego siga los pasos de la aplicación para configurar un PIN y, cuando sea compatible, el desbloqueo biométrico. Mantenga su frase de recuperación por separado antes de recibir fondos. Consulte [seguridad de la cuenta](security.md). ## Cuenta criptográfica y billetera | Artículo | Lo que significa | Cómo se autoriza una transferencia | | --- | --- | --- | | Cuenta criptográfica (fría) | Una dirección blockchain, generada o conectada en la aplicación | El propietario firma con una billetera de hardware local, externa o compatible | | Cartera (caliente) | Un saldo de cuenta utilizado para pagos y transferencias internas | El servicio procesa la operación autorizada | | Cuenta de sólo observación | Una dirección agregada para ver sin su clave privada | La visualización no da permiso para gastar; utilizar el firmante conectado | Las cuentas frías y sus etiquetas se pueden almacenar en su dispositivo. Iniciar sesión en otro lugar no necesariamente restaura todas las cuentas adicionales que haya conectado en otro dispositivo. Haga una copia de seguridad de cada cuenta a través de su billetera original. ## Recibir fondos 1. Abra la cuenta criptográfica o billetera requerida. 2. Verifique el activo y la red. USDT en Ethereum y USDT en TRON son destinos de transferencia diferentes. 3. Utilice los detalles de recepción o QR que se muestran para esa cuenta. No sustituya una dirección de blockchain por un identificador de billetera interna. 4. Confirmar la operación entrante en el historial. Un saldo pendiente no es lo mismo que fondos disponibles. Para compras a través de una casa de cambio externa, consulta su red de destino antes de retirar. La página de intercambio proporciona enlaces a servicios externos; La disponibilidad y los términos dependen de ese proveedor. ## Activos disponibles Utilice los activos que se muestran para su cuenta. El registro de tokens global puede incluir activos que no están habilitados en su interfaz o para una operación particular. ## ar: توصيل مساعد AI Source: https://docs.heth.me/markdown/ar/ai/mcp.md --- title: "توصيل مساعد AI" last_update: date: 2026-10-23 --- # توصيل مساعد AI يمنح Heth MCP للمساعد وصولاً محدودًا إلى حسابك الخاص، بما في ذلك وظائف الأعمال المتاحة. لا يمكن منح حق الوصول إلى إدارة النظام الأساسي. فتح شاشة الاتصال لا يمنح أي إذن. ## توصيل مساعد 1. في تطبيق Heth حيث تكون محفظتك مفتوحة بالفعل، انتقل إلى **الإعدادات → اتصالات AI** واختر **إنشاء رمز اتصال**. ينتمي الرمز المستخدم لمرة واحدة إلى هذا الحساب وينتهي بعد خمس دقائق. 2. في إعدادات اتصال عميل AI، أضف `https://mcp.heth.me/mcp` واختر OAuth. ابدأ بالاتصال. 3. في نافذة الاتصال أدخل الرمز من هيث فقط. لم تقم بتسجيل الدخول إلى محفظتك في هذا المتصفح. يرسل الرمز طلبًا إلى الحساب المحدد الذي قام بإنشائه؛ لا يمنح أي وصول. 4. إذا كان Heth مفتوحًا، فسيظهر إشعار **AI لطلب اتصال** في الجزء العلوي من التطبيق. اختر **مراجعة طلب الاتصال**، أو افتح الدفع. يمكنك أيضًا العثور على الطلب ضمن **الإعدادات → اتصالات AI → طلبات الاتصال**. قارن **رمز التحقق من الطلب** بالرمز الموجود في نافذة الاتصال، وتحقق من الحساب ومعرف العميل وعنوان الخدمة. اسم التطبيق وحده لا يتحقق من الهوية. 5. في Heth، قم بإلغاء تحديد الأذونات التي لا تريد مشاركتها واختر **الموافقة على الوصول المحدد إلى AI**، أو اختر **رفض الوصول إلى AI**. فتح الدفع وحده لا يوافق على شيء. 6. العودة إلى عميل AI. تنتهي نافذة الاتصال الخاصة به تلقائيًا بعد قرارك في Heth. تبقى جلسة محفظتك ومفاتيح التوقيع في هيث. لا يمكن إعادة استخدام رمز الاتصال المستخدم أو المنتهي الصلاحية. إنشاء رمز جديد في هيث؛ يؤدي إنشاء واحد إلى استبدال الكود السابق غير المستخدم. إذا انتهت صلاحية طلب الاتصال بالكامل، قم بإعادة التشغيل من عميل AI. ### في ChatGPT افتح **المكونات الإضافية → إضافة → إضافة خادم MCP مخصص**، أدخل اسمًا مثل Heth.me وعنوان الخادم أعلاه، وحافظ على تحديد **OAuth**. يكتشف ChatGPT إعدادات الاتصال تلقائيًا؛ ليست هناك حاجة إلى مفتاح API للمحفظة أو سر العميل أو عبارة الاسترداد. قم بإنشاء المكون الإضافي الشخصي، واختر **Connect Heth.me**، ثم اتبع خطوات الكود والدفع أعلاه. يمكنك تحديد الأذونات الافتراضية ضمن **إعدادات OAuth المتقدمة**؛ تم تأكيد اختيار إذن الحساب النهائي في تطبيق Heth. بعد الاتصال، اختر Heth.me في الدردشة وحاول "إظهار أرصدة محفظتي باستخدام Heth". تعتمد الأدوات المتاحة على الأذونات التي وافقت عليها. ### في كلود كود في المحطة، أضف Heth وابدأ الاتصال: ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` يقوم كلود كود بتسجيل الاتصال تلقائيا ويفتح نافذة المتصفح. أدخل الرمز الذي يُستخدم لمرة واحدة من Heth هناك، ثم قم بمراجعة الأذونات والموافقة عليها في تطبيق Heth باستخدام الخطوات المذكورة أعلاه. أبقِ الجهاز مفتوحًا حتى انتهاء الاتصال. لا تحتاج إلى معرف العميل أو سر العميل أو مفتاح المحفظة API. بعد الاتصال اسأل كلود: “أظهر أرصدة محفظتي باستخدام هيث”. يمكنه استخدام الأذونات التي وافقت عليها فقط. يمكنك إدارة هذا الاتصال أو إبطاله في **الإعدادات → اتصالات AI** في Heth. ## أرصدة المحفظة إسأل: "إظهار رصيد محفظتي باستخدام هيث". أسماء المحفظة تتطابق مع التطبيق: `USDT ERC20`، `USDT TRC20`، `USDT Base`، `cNGN Base`. يتضمن كل مبلغ وحدة الرمز المميز الخاصة به؛ تظل `RUB_T` و`UZS_T` و`ZOLT` أسماء مميزة مميزة. لا يتم عرض معرفات قاعدة بيانات المحفظة. يتلقى المساعد رصيدًا دقيقًا بوحدات الرمز مع الاحتفاظ بجميع المنازل العشرية وإرشادات التنسيق. على سبيل المثال، يجب ألا يتم عرض `1.000001 USDT` كـ `1 USDT`، ويجب ألا يصبح المبلغ الصغير غير الصفري صفرًا. الفواصل العشرية والتجميعية تتبع لغتك. إذا لم تكن الدقة متوفرة، يعرض المساعد شرطة ويشرح السبب بدلاً من اختراع مبلغ. لا يتم إضافة العملات والشبكات المختلفة معًا. لا يتم تضمين المحافظ المخزنة على جهازك فقط. ## الأذونات والأدوات يمكن الموافقة فقط على الأذونات التي يطلبها العميل والمتاحة حاليًا لحسابك. لا تكون الأداة مرئية إلا بالإذن المطلوب. تغطي الأدوات بيانات الحساب والتحويلات وتغييرات الأعمال العادية وطلبات الاشتراك و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:business:manage` | `create_business_product`، `update_business_product`، `delete_business_product`؛ `create_business_payment_link`، `update_business_payment_link`، `delete_business_payment_link`: التغييرات العادية المؤكدة في عميل AI | | `heth:business:manage` | `request_business_subscription`: طلب موافقة العميل في هيث؛ `prepare_business_subscription_change`: مراجعة الإيقاف المؤقت أو الاستئناف أو الإلغاء في Heth | | `heth:obs:read` | `get_obs_widget`، `list_obs_events`: الإعدادات والأحداث الواردة | | `heth:obs:configure` | `prepare_obs_connection`، `update_obs_widget`: رابط مراجعة Heth، أو حقول المظهر فقط مع التأكيد في عميل AI | `prepare_obs_connection` لا ينشئ أي وصول ولا يُرجع أي رمز OBS. لا يمكن تغيير العملة/الشبكة وحسابات الاستلام والمفاتيح وأذونات الوصول بواسطة أداة المظهر. راجع [دليل الإعداد والتخصيص OBS](../user/obs.md)، بما في ذلك المشروع مفتوح المصدر والتعليمات الخاصة بمساعدي البرمجة. ## كم يستمر الوصول يستمر إذن الاتصال الخاص بك **حتى تقوم بإلغائه**. تنتهي صلاحية بيانات الاعتماد الفنية بشكل منفصل: رموز الوصول MCP آخر دقائق 15؛ يتم تدوير رموز التحديث وتنتهي صلاحيتها بعد أيام 30 دون تجديد. قد تتطلب منك بيانات الاعتماد الفنية منتهية الصلاحية الاتصال مرة أخرى حتى إذا ظل سجل الموافقة نشطًا. كل طلب يتحقق من الاتصال الحالي وأذونات الحساب. يستخدم Heth بيانات اعتماد API مقيدة منفصلة صالحة لمدة 60 على الأكثر من الثواني لخدمة طلبات MCP؛ لا تتم مشاركة جلسة المحفظة الكاملة مع MCP. يؤدي إلغاء الموافقة أو سحب أذونات الحساب إلى حظر الطلبات اللاحقة، بما في ذلك الطلبات ذات الرموز المميزة غير منتهية الصلاحية. لا يمكن استدعاء البيانات التي تم إرجاعها بالفعل إلى العميل. ## إلغاء أو إعادة الاتصال في Heth، افتح **الإعدادات → اتصالات AI**، وتحقق من معرف العميل وعنوان الخدمة والأذونات والحالة. اختر **إلغاء الوصول إلى AI** وقم بالتأكيد في Heth. لا يؤدي الإلغاء إلى إلغاء الدفعات المكتملة أو تفويضات الخصم من الاشتراك؛ قم بإدارة هذه العناصر بشكل منفصل في [إعدادات الاشتراك ](../user/features.md). إذا طُلب منك إعادة الاتصال، فابدأ بتفويض جديد في عميل AI الخاص بك. يمكن أن يؤدي الإلغاء أو بيانات الاعتماد منتهية الصلاحية أو الأذونات المسحوبة أو إعادة الاستخدام المكتشفة لرمز التحديث إلى إنهاء الوصول. لا تقم بلصق عبارات الاسترداد أو مفاتيح المحفظة أو بيانات اعتماد جلسة المتصفح في مساعد لإصلاح الاتصال. الخدمة غير المتوفرة هي خطأ، وليست حسابًا فارغًا أو موافقة ناجحة. ## المدفوعات والتغييرات الأخرى يتطلب Heth **تأكيدًا منفصلاً في Heth لكل عملية نقدية**. إذن الاتصال لا يسمح بالإنفاق التلقائي. تتطلب تعديلات المنتج العادي ورابط الدفع تأكيدًا لدى عميل AI. تتطلب التغييرات في حقوق الوصول أو مستلمي العوائد أو تفويض الخصم المستقبلي تأكيد Heth. يتبع مظهر OBS سياسة تأكيد العميل. لا يثبت التعليق التوضيحي للأداة وحده حصول العميل على الموافقة. يمكنك أيضًا استخدام [تطبيق هيث](https://app.heth.me) أو التكامل المدعوم [API](../business/quick-start.md). ## تحويل مع مساعد 1. أخبر المساعد بنوع التحويل والمستلم والعملة والشبكة والمبلغ. تعد العمليات من الداخل إلى الداخلي (`hot_hot`)، ومن الداخل إلى سلسلة الكتل (`hot_cold`)، ومن blockchain إلى حسابك الداخلي (`cold_hot`)، ومن blockchain إلى blockchain (`cold_cold`) عمليات متميزة. استخدم `self` كمستلم لـ `cold_hot`؛ فإنه يقيد حساب Heth الخاص بك. 2. `prepare_transfer` يحفظ الشروط ويعيد رابط مراجعة Heth. لا يخلق أي دفع. تستخدم المبالغ و`max_debit` سلاسل صحيحة تمامًا في الوحدات الثانوية للرمز المميز. يضع `max_debit` حدًا أقصى للخصم من الرمز المميز بما في ذلك رسوم المنصة. بالنسبة لمصدر blockchain، يقوم `max_network_fee` بوضع حد أقصى لرسوم غاز الشبكة الخاصة بالمعاملة بالوي (ETH/Base) أو الشمس (TRON). قد تفرض Base أيضًا رسوم بيانات L1. 3. افتح Heth وتحقق من الحساب وطلب العميل والمستلم والمصدر والمبلغ والشبكة وحدود الرسوم. اختر **تأكيد وإرسال Heth** فقط عندما تكون جميع الشروط صحيحة. فتح الرابط لا يوافق أو يرسل أي شيء. تنتهي صلاحية الطلبات بعد دقائق 15. 4. يقوم Heth بالتوقيع على التعليمات المعروضة ويستخدم تدفق النقل الطبيعي الخاص به. يتم توقيع معاملات Blockchain على جهازك أو على جهاز توقيع متصل. افتح Heth حيث يمكن توقيع الحساب المصدر؛ المفاتيح الخاصة لا تذهب أبدًا إلى المساعد. 5. المساعد يقرأ `get_transfer_request` للتحقق من المعاملة الأصلية. الموافقة أو المعالجة ليست هي نفسها المدفوعة. بعد انتهاء المهلة، اقرأ النتيجة الأصلية؛ أعد استخدام نفس `request_id` والمصطلحات المتطابقة إذا كان يجب إعادة محاولة التحضير. لا تقم بإنشاء عملية نقل ثانية لحل نتيجة غير مؤكدة. الإلغاء يمنع التحويل الجديد من البدء. لا يزال من الممكن إكمال المعاملة التي تم قبولها للتنفيذ بالفعل؛ لا يؤدي إلغاء اتصال AI إلى إلغاء عملية نقل blockchain مقبولة. ## المنتجات والروابط والاشتراكات يعرض المساعد المنتج العادي أو تغييرات الارتباط المُدار للتأكيد في عميل AI. تعتبر مبالغ السعر والارتباط سلاسل صحيحة في وحدات ثانوية؛ كميات المنتج هي أعداد صحيحة موجبة. `request_id` المستقر يجعل إعادة المحاولة لمنع تكرار الأثرة. لا يمكن لهذه العمليات تعديل توجيه الدفع أو مستلمي العوائد أو المفاتيح أو حقوق الوصول. لا يؤدي حذف رابط أو منتج إلى إلغاء دفعة سابقة. `request_business_subscription` يقوم بإنشاء طلب للدافع للمراجعة في هيث. فهو لا يمنح أي إذن بالخصم المستقبلي ولا يفرض أي رسوم في حد ذاته. يقوم الدافع بمراجعة المبلغ والتكرار والتكلفة الأولى قبل تسجيل الدخول في Heth. استخدم `list_business_subscription_requests` للتحقق من الطلبات، و`get_business_subscription` أو `list_business_subscriptions` للاتفاقيات الحالية. لإيقاف اتفاقية مؤقتًا أو استئنافها أو إلغائها، تقوم `prepare_business_subscription_change` بإرجاع شاشة مراجعة Heth. لا شيء يتغير حتى يؤكد المالك هناك. يسمح استئناف الرسوم المجدولة بموجب إذن الدفع الحالي. يؤدي الإلغاء إلى إيقاف الرسوم المستقبلية ولا يسترد الدفعات المكتملة. يتطلب تغيير شروط الفوترة المتفق عليها موافقة دافع جديد. تنطبق [حدود الدفع](../user/payments.md#payment-limits) على التحويلات الداخلية التي يجهّزها الذكاء الاصطناعي (`hot_hot`). يتحقق Heth من الحدود والأسعار المرجعية قبل التنفيذ. تحويلات البلوكشين ورسوم الشبكة خارج هذه الحدود. لا تتجاوز صلاحية الذكاء الاصطناعي أو رمز صالح الحد الأقصى؛ غيّر الإعدادات في Heth. اعرض الأصل والشبكة مع المبلغ ووضّح أن القيم المحوّلة تقريبية. لا تقارن مباشرة أعداد الوحدات الصغرى لأصول مختلفة. ## ar: المصادقة ومفاتيح API Source: https://docs.heth.me/markdown/ar/business/authentication.md --- title: "المصادقة ومفاتيح API" last_update: date: 2026-10-20 --- # المصادقة ومفاتيح API ## إصدار وإلغاء مفتاح 1. قم بتسجيل الدخول إلى [Heth](https://app.heth.me) وافتح **الأعمال**. 2. افتح شاشة التكامل باستخدام **الاتصال**. 3. في **تكامل API**، استخدم ****** لإصدار مفتاح. 4. قم بتخزين المفتاح باعتباره سرًا في التكامل من جانب الخادم الخاص بك. 5. لإلغاء مفتاح، قم بإزالة إدخاله على تلك الشاشة. قم بتحديث التكامل عند استبدال المفتاح. لا تستخدم أبدًا المفتاح المطبوع في لقطة الشاشة أو مثال التوثيق. تستخدم الوثائق العناصر النائبة بدلاً من بيانات الاعتماد القابلة للاستخدام. ## طلب الرؤوس | رأس | استخدم | | --- | --- | | `x-api-key` | مطلوب لمصادقة مفتاح API | | `Content-Type: application/json` | مطلوب عند تقديم JSON | بالنسبة إلى `https://app.heth.me`، توفر بوابة Heth سياق المؤسسة. تنطبق هذه القاعدة على ذلك المضيف: لا تفترض أنه ينطبق على منصة مختلفة API URL. يرتبط مفتاح API بحسابه وأذوناته الخاصة. ## المفاتيح وجلسات المستخدم مختلفة تكامل المعاملات يقبل مفتاح API. يمكن أن تتطلب وظائف المحفظة التفاعلية جلسة حامل المستخدم الذي قام بتسجيل الدخول بدلاً من ذلك؛ لا يمنح المفتاح الوصول تلقائيًا إلى المحافظ أو الملف الشخصي أو أسماء المستخدمين أو كل ميزات العمل. تعد جلسات اشتراك العميل نوعًا منفصلاً من التفويض. لا تقم مطلقًا باستبدال نوع رمز مميز بآخر أو نسخ بذرة في تكوين التكامل. راجع [القدرات](capabilities.md) و[الأخطاء](errors.md). يجب أن يطلب التكامل فقط الوصول المطلوب لمهمته. ## ar: إمكانيات الأعمال وتوافرها Source: https://docs.heth.me/markdown/ar/business/capabilities.md --- title: "إمكانيات الأعمال وتوافرها" last_update: date: 2026-10-20 --- # إمكانيات الأعمال وتوافرها استخدم الإمكانيات الممكّنة للحساب الذي تم تسجيل الدخول إليه. لا تعني نقطة النهاية API الموجودة في النظام الأساسي أنها ممكنة لحسابك أو شبكتك أو طريق الدفع. | القدرة | حدود التكامل | | --- | --- | | المدفوعات والمدفوعات | المعاملة API، المسار الذي تم تكوينه، والأداة المسموح بها | | هيث تلقي الروابط | استقبال URL تم إنشاؤه في التطبيق؛ المشاركة لا تخلق تهمة | | روابط ومنتجات الدفع المُدارة | موارد تجارية منفصلة؛ تتطلب الوصول إلى الحساب الممكّن | | اشتراكات التاجر | الاتفاقيات التي تم إرسال فواتيرها إلى عملائك؛ تتطلب طرق دفع مدعومة وتفويض العميل | | أذونات الاشتراك الخاصة بالدافع | ترخيص العميل المنفصل والموافقة/الإلغاء الصريح | | استرداد أو إلغاء | فقط إذا كانت مدعومة بالمعاملة الأصلية وطريقة الدفع؛ لا يمكن عكس عملية نقل blockchain بشكل عام | | المحافظ، @أسماء المستخدمين، وبطاقات الهدايا، وخطافات الويب | قد تتطلب وظائف الحساب جلسة المستخدم وتأكيدًا إضافيًا | | تبرعات | تدفق النظام الأساسي/المؤلف مع المستلم الخاص به والحد الأدنى والرسوم وانتهاء الصلاحية | يُرجع سجل الرمز المميز العام التكوين، وليس الحق في الدفع بكل أصل مدرج. قم بمطابقة الأصل بالشبكة والتكوين الفعال للحساب. على سبيل المثال، لا يمكن تبديل USDT/ETH وUSDT/TRX. ## حدود التوثيق يغطي [مرجع المعاملة ](../transactions/overview.md) تنسيقات الطلب للتدفقات الموثقة. لا تحصل على بيانات اعتماد المشغل أو تغير المحطات/التوجيه لحل طلب مرفوض. اتصل بالدعم باستخدام معرف المعاملة عندما يكون مسار الحساب غير متاح. يشرح [دليل الاتصال AI](../ai/mcp.md) الأذونات والتأكيد للوظائف المتاحة لحسابك. ## ar: الأخطاء والتحقق من الحالة وإعادة المحاولة Source: https://docs.heth.me/markdown/ar/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` عندما يكون موجودًا وأعد محاولة القراءة مع التراجع المحدود | | Timeout / 5xx | قد تكون النتيجة غير معروفة. ابحث عن العملية الأصلية بواسطة `id` أو `txid` قبل إعادة الإرسال | يمكن أن تختلف أشكال الاستجابة للخطأ حسب نقطة النهاية. تفضل رمز خطأ موثق يمكن قراءته آليًا حيثما كان ذلك متاحًا؛ `error_description` هو نص يمكن قراءته بواسطة الإنسان وليس رمزًا ثابتًا. احذف بيانات الاعتماد وبيانات وسيلة الدفع من السجلات أو احجبها. ## نتائج المعاملات - `charged`: تمت المعاملة بنجاح. - `rejected` أو `failed`: فحص السبب والعملية الأصلية؛ لا تبلغ عن النجاح. - `refunded` أو `reversed`: الأموال لها نتيجة مختلفة عن الدفعة التي تمت تسويتها حديثًا. - الحالة معلقة/مطلوب إجراء/غير معروفة: أظهر تلك الحالة وإجراء المستخدم المطلوب. لا تستنتج أبدًا النجاح من حالة غير معترف بها أو من الطابع الزمني وحده. استخدم [معاملة GET](../transactions/get_transaction.md) للتحقق من العملية. احتفظ بنفس `txid` لإعادة محاولة نفس تعليمات العمل. يعد فشل تسليم Webhook وفشل معالجة الدفع حدثين مختلفين. ## ar: ابدأ عملية التكامل API Source: https://docs.heth.me/markdown/ar/business/quick-start.md --- title: "ابدأ عملية التكامل API" last_update: date: 2026-10-20 --- # ابدأ عملية التكامل API استخدم مفتاح API الصادر لحساب Heth الخاص بك. اقرأ أولاً [authentication](authentication.md) و[المبالغ والحالات](../field_conventions.md) و[إمكانات الأعمال المتاحة](capabilities.md). ## التحقق من الوصول دون تحويل الأموال قم بتعيين `HETH_API_KEY` في المخزن السري للتكامل الخاص بك. لا تضعه في التحكم بالمصادر أو حزمة المتصفح أو URL أو محادثة AI. يقرأ هذا الطلب معاملات الحساب دون تحويل الأموال. ```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 فقط بالعمليات المتاحة لحسابه. ## ar: المنتجات والروابط المدارة والاشتراكات Source: https://docs.heth.me/markdown/ar/business/resources.md --- title: "المنتجات والروابط المدارة والاشتراكات" last_update: date: 2026-10-20 --- # المنتجات والروابط المدارة والاشتراكات هذه هي موارد الأعمال المملوكة للحساب. يلزم الوصول إلى مفتاح API أو وصول حامل الشريك والإمكانيات الممكّنة المقابلة. المفتاح لا يعمل على طريق الدفع. راجع [المصادقة](authentication.md). للقراءة والحذف، env هو مرشح الاستعلام. لإنشاء المنتج/الرابط وتحديثاته، أرسل env في نص JSON. ملكية الشريك تأتي من بيانات الاعتماد؛ لا ترسل شريكًا آخر. يمكن أن تحتوي حقول سعر المورد على أنواع أعداد صحيحة خاصة بنقطة النهاية: يظل مبلغ المعاملة 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 ``` إنشاء منتج يحدد رأسه ونصه وسعره وكميته وعملته. المنتج ليس دفعة. تستخدم استجابات القائمة البيانات/الإجمالي؛ تفاصيل المنتج واستجابات الإنشاء تستخدم البيانات. السعر المعروض هو 1 USDT بالكسور العشرية=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/معلومات النموذج، وليس 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 معرف الدفع والكائن المتكرر؛ الفاصل الزمني يقبل يوميًا أو أسبوعيًا أو شهريًا أو سنويًا، مع تحديد الفترة لعدد الفواصل الزمنية. يجب على الدافع تفويض طريقة الدفع وشروط الخصم المتكررة. لا يعد إنشاء الاشتراك دليلاً على وجود إذن خصم قابل للاستخدام. تستخدم إجراءات دورة الحياة `POST /recurrents/{id}/pause` و/استئناف و/إلغاء. قراءة الحالة التي تم إرجاعها؛ إلغاء الرسوم المستقبلية لا يؤدي إلى استرداد الرسوم السابقة. يدير دافع Heth تفويضات اشتراك العملات المشفرة الخاصة به من خلال جلسة المحفظة الخاصة به في الإعدادات → تفويضات الاشتراك، حيث يتم تمكين الميزة. وهذا منفصل عن إدارة اشتراكات التاجر. ## ar: تكامل Webhook Source: https://docs.heth.me/markdown/ar/business/webhooks.md --- title: "تكامل Webhook" last_update: date: 2026-10-20 --- # تكامل Webhook يقوم خطاف الويب بإبلاغ حدث الحساب إلى جهاز الاستقبال URL الخاص بك. إنه إشعار؛ تحقق من حالة المعاملة الرسمية من خلال [GETمعاملة](../transactions/get_transaction.md). ## ضبط الرسيفر في إعدادات Heth webhook، قم بتعيين URL الذي تتحكم فيه، وقم بتكوين سر التكامل وتمكين التسليم. يؤدي تغيير URL إلى تغيير من يتلقى أحداث الحساب. قم بحماية نقطة النهاية هذه وتجنب عمليات إعادة التوجيه إلى مستلمين غير موثوق بهم. يتطلب التكوين جلسة حساب المستخدم؛ مفتاح API المستخدم للمعاملات لا يكفي تلقائيًا. ## معالجة الإشعارات بأمان 1. التحقق من صحة توقيع webhook للحساب وإعادة عمليات التحقق الموضحة أدناه. 2. سجل معرف الحدث/المعاملة مع حذف الحقول الحساسة. 3. اجعل التعامل لمنع تكرار الأثر: يجب ألا يؤدي التسليم المكرر أو المتأخر إلى إنشاء دفعة أخرى. 4. استرجاع المعاملة ببيانتك الخاصة وتسوية حالتها. 5. إعادة رد المستلم المطلوب بموجب عقد التسليم المكوّن. لا تعامل إشعار المتصفح كخطاف ويب أو ضمان للتسليم. لا تعد هذه النظرة العامة بالترتيب أو فترات إعادة المحاولة أو تنسيق المصادقة المشترك لكل عملية تكامل تم تكوينها. الحصول على عقد التسليم الفعلي قبل تمكين أتمتة الإنتاج. ## تنسيق تسليم webhook الحساب ينطبق هذا التنسيق على خطافات الويب للحساب التي تم تكوينها في إعدادات Heth. قد تستخدم عمليات تكامل رد الاتصال الأخرى عقدًا مختلفًا. عند تكوين سر خطاف ويب للحساب غير فارغ، يتضمن الطلب توقيع x-webhook (ست عشري HMAC-SHA256) وx-webhook-timestamp (ثواني Unix) ومعرف حدث x-webhook. تحقق من HMAC عبر الطابع الزمني + "." + بايتات نص HTTP الأولية الدقيقة باستخدام السر الذي تم تكوينه؛ لا تقم بتحليل وإعادة تسلسل JSON قبل التحقق. تحقق من تطابق الطابع الزمني للنص الموقع مع رأس الطابع الزمني، ورفض فرق الساعة الذي يزيد عن دقائق 5، ومقارنة التوقيعات في الوقت الثابت، وإلغاء التكرار بواسطة events_id. تحتفظ إعادة المحاولة بمعرف الحدث ولكنها تتلقى طابعًا زمنيًا/توقيعًا جديدًا. بدون سر تم تكوينه، يمكن أن تكون رؤوس التوقيع غائبة؛ قم بتكوين سر قبل الوثوق بالتسليم الآلي. ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` يحتوي المظروف على معرف الحدث والطابع الزمني والنوع والبيانات. بالنسبة لأحداث معاملات الحساب، تتضمن البيانات tx_id وtxid والنوع والحالة والمبلغ والعملة وevent_type. يمكن أن يكون المبلغ عددًا صحيحًا JSON: استخدم محللًا بدون فقدان البيانات. قد يضيف التبرع كائنًا للتبرع. قم بالاعتراف بالحدث الذي تم التحقق منه باستخدام HTTP 2xx بعد تسجيله؛ يجب ألا تؤدي قيم Event_id المتكررة التي تم التحقق منها إلى تشغيل إجراء الأعمال مرتين. قم بتأكيد المعاملة من خلال GET حتى بعد تلقي إشعار صالح. ## ar: المصطلحات والمصطلحات الميدانية Source: https://docs.heth.me/markdown/ar/field_conventions.md --- title: "المصطلحات والمصطلحات الميدانية" last_update: date: 2026-10-20 --- # المصطلحات والمصطلحات الميدانية التعريفات الأساسية المستخدمة عبر وثائق API. ## طلب الرؤوس | رأس | مطلوب | التعريف | | ------ | -------- | ---------- | | x-api-key | نعم | مفتاح API الصادر في التطبيق (قسم "الأعمال"). يتم حل المنظمة من مضيف الطلب | | Content-Type | نعم (POST) | `application/json` لإنشاء الطلبات | ## المبلغ والعملة | مصطلح | التعريف | | ---- | ---------- | | amount | سلسلة من عدد صحيح بوحدات ثانوية (على سبيل المثال، سنت، أصغر جزء رمزي) | | amount_with_fee | المبلغ بالإضافة إلى الرسوم المطبقة (الوحدات الثانوية) | | currency | رمز العملة / الرمز المميز المشابه لـ ISO (على سبيل المثال، 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`. المسار السعيد الأكثر شيوعًا هو `created → charging → charged`. ## حقول الوقت | المجال | التعريف | | ----- | ---------- | | started | الطابع الزمني ISO عند بدء المعالجة | | finished | الطابع الزمني ISO عند اكتمال المعالجة؛ تحديد النتيجة من الحالة | ## كائنات تخزين الأموال | المجال | التعريف | | ----- | ---------- | | network | شبكة Blockchain (ETH، TRX، إلخ) | | type | نوع الأداة (bank_card، p2p_proxy، إلخ) | | wallet_id | معرف المحفظة الداخلية (هدف الدفع/الدفع) | | cardnumber | البطاقة الافتراضية PAN (ملثمة في بعض الردود) | | cvv | رمز أمان البطاقة الافتراضية (لا تقم مطلقًا بتسجيل الدخول بنص عادي) | | exp_month / exp_year | قيم انتهاء البطاقة (سلسلة، صفر مبطن) | | cardholder | اسم حامل البطاقة (ASCII أو UTF-8) | ## حقول الخطأ | المجال | التعريف | | ----- | ---------- | | error_description | سبب فشل يمكن قراءته بواسطة الإنسان (نص غير مستقر) | ## إرشادات العجز الجنسي استخدم `txid` فريدًا (لمنع تكرار الأثر) لكل عملية تجارية واستمر في ذلك قبل الإرسال. القيمة عبارة عن سلسلة؛ يعد إنشاء UUID مناسبًا ولكن بناء جملة UUID غير مطلوب. أعد محاولة نفس التعليمات بنفس المعرف في نفس الحساب. لا تعيد استخدامه لمستلم أو مبلغ مختلف. استعادة العملية الأصلية بعد انتهاء المهلة؛ يجب ألا تصبح إعادة المحاولة دفعة جديدة بصمت. ## استراتيجية الاقتراع تتم قراءة الاستطلاع مع التراجع المحدود، على سبيل المثال 1s → 2s → 4s → 8s، مع ميزانية تفاعل تبلغ 30 ثانية. توقف عند حالة نهائية معروفة أو عند انتهاء الميزانية. عند انتهاء المهلة، قم بالإبلاغ عن نتيجة معلقة/غير معروفة واحتفظ بـ `id`/`txid` الأصلي. الحالات غير المعروفة ليست ناجحة. راجع [الأخطاء وإعادة المحاولة](business/errors.md). ## خطافات الويب (إعلامية) تشير خطافات الويب إلى تغيير الحالة ولكنها ليست موثوقة. قم دائمًا بالتأكيد عبر معاملة GET. ## مقياس المبالغ الكميات هي سلاسل من الأعداد الصحيحة بوحدات صغيرة، وليست قيم الفاصلة العائمة. احصل على الكسور العشرية للعملة والشبكة من `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). ## ar: استخدم Heth.me: المحافظ والتحويلات والمدفوعات Source: https://docs.heth.me/markdown/ar/intro.md --- slug: "/" sidebar_position: 1 title: "المحافظ والتحويلات والدفع API" 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). - [خطافات الويب: التوقيعات والتعامل مع الأحداث](business/webhooks.md). - [تنسيقات المبلغ والمعرفات](field_conventions.md)، [الأخطاء وإعادة المحاولة](business/errors.md). مميزات الأعمال تعتمد على [الوصول إلى الحساب](business/capabilities.md). نجاح HTTP لا يؤكد الدفع: تحقق من حالة المعاملة الأصلية. ## قم بتوصيل AI بـ Heth.me [قم بتوصيل مساعد AI الخاص بك من خلال Heth MCP](ai/mcp.md) لاستخدام حسابك الخاص ووظائف الأعمال المتاحة. اخترت أذوناتها وتأكيد كل عملية نقدية في هيث. يشرح الدليل الاتصال والتحويلات وتغييرات الأعمال وOBS والإلغاء. يمكن لمطوري التكامل AI استخدام [مجموعة API الفرعية الموثقة ](/openapi.json) و[فهرس الوثائق ](/llms.txt) و]أدلة النص الكامل ](/llms-full.txt). تصف هذه الواجهات والقواعد؛ احصل على الأرصدة والأذونات ونتائج التشغيل الحالية من API. ## التطبيق والدعم [افتح Heth.me](https://app.heth.me) · [اتصل بالدعم](https://t.me/hethmesupport_bot) ## ar: الاشتراكات والدفع التلقائي Source: https://docs.heth.me/markdown/ar/subscriptions.md --- title: "الاشتراكات والدفع التلقائي" --- # الاشتراكات والدفع التلقائي يمكن للمتجر أن يطلب من مستخدم Heth.me الموافقة على الدفعات المتكررة. يقوم الدافع بمراجعة الشروط وتوقيعها باستخدام HethWallet العادية غير المؤمنة. ليست هناك حاجة إلى حساب بريد إلكتروني منفصل أو تسجيل الدخول إلى بوابة العملاء. يتم خصم الدفعات من **رصيد حساب Heth** بالعملة والشبكة المتفق عليهما. ## للدافع 1. افتح **الإعدادات → الاشتراكات والدفع التلقائي**. تظهر الطلبات الجديدة بشكل منفصل عن الاشتراكات الموجودة. 2. افتح طلبًا وتحقق من المتجر ومبلغ الدفعة والعملة/الشبكة وفترة الفاتورة. يفتح رابط التأكيد نفس الشاشة. تطلب المحفظة المقفلة PIN المعتاد وتعود إلى الطلب. 3. اختر **تفعيل الاشتراك** أو **رفض**. لا يؤدي فتح رابط أو تلقي إشعار إلى الموافقة على الاشتراك مطلقًا. 4. بعد الموافقة يتم تحديد موعد الدفعة الأولى. تظهر القائمة المبلغ والمدة وتاريخ الدفع التالي. أثناء إعادة محاولة الدفع الفاشلة، فإنه يظهر وقت إعادة المحاولة التالي. 5. قم بإلغاء الاشتراك لإيقاف الرسوم المستقبلية. لا يؤدي الإلغاء إلى استرداد الدفعات المكتملة. الموافقة تسجل الموافقة وتحدد موعد الدفع؛ وهذا لا يعني أن الدفع قد نجح. التحقق من حالة المعاملة. يجب أن يكون الرصيد كافيا عند تنفيذ الدفع. ## كيفية الإعلان عن الطلبات الجديدة بالنسبة للدافع المعترف به، يرسل الخادم دفعة لطلب الاشتراك إلى الأجهزة المسجلة، مع رابط إلى `/subscriptions/confirm/?env=`. يتم أيضًا حفظ الإدخال في جرس الإشعارات، حتى في حالة عدم تمكن أي جهاز من تلقي الدفع. تظل الطلبات المعلقة متاحة في **الإعدادات → الاشتراكات والدفع التلقائي**. تستخدم تطبيقات PWA المثبتة دفع الويب. يستخدم 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` | عنوان المحفظة أو اسم المستخدم أو رقم بطاقة هيث. | String | `@alice` | | `description` | اسم الاشتراك، أحرف 1–250 بدون فواصل الأسطر. | String | `Monthly membership` | | `amount` | عدد صحيح موجب في الوحدات الثانوية الرمزية. بالنسبة إلى 6-decimal USDT، `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 الخاص بالمتجر أو جلسة حامل الشريك. | الطريقة والمسار | الغرض | | --- | --- | | `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` في حجم الصفحة. تتطلب عمليات المحفظة جلسة حامل المحفظة العادية للدافع. لا يمكن لمفتاح 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"}`. | التوقيع يربط المحل، الدافع، المنظمة، الوصف، المبلغ وحجمه، العملة/الشبكة، الفاصل الزمني والفترة، قاعدة الدفعة الأولى، عدم النفاذ وانتهاء الصلاحية. يتطلب تغيير الشروط طلبًا جديدًا وموافقة جديدة. لا يمكن لإعادة محاولة الموافقة أو الدفع المجدول خصم الفترة نفسها مرتين. الطوابع الزمنية API بدون لاحقة المنطقة الزمنية هي UTC؛ يعرض التطبيق التوقيت المحلي للجهاز. ## الحالات والأخطاء حالات الطلب هي `pending` و`signed` و`rejected` و`expired`. الطلب المعتمد له `subscription_id`. تتبع إتمام الدفع الفعلي من خلال المعاملة API وخطافات الويب التي تم تكوينها. `401` تعني مصادقة مفقودة/غير صالحة؛ يعني `403` أن الاشتراكات معطلة أو أن مفتاح API للقراءة فقط. يقوم الطلب الذي يتعذر الوصول إليه بإرجاع `404`. يشير `422` إلى مصطلحات غير صالحة، أو UUID مُعاد استخدامه بشروط مختلفة، أو توقيع غير صالح، أو طلب منتهي الصلاحية/مغلق. لا يمكن للمتجر تغيير الشروط الموقعة للاشتراك النشط دون موافقة الدافع الجديد. ## ar: الدفعة المجمعة (تحصيل التاجر برقم البطاقة) Source: https://docs.heth.me/markdown/ar/transactions/aggregator_payment.md --- title: "الدفعة المجمعة (تحصيل التاجر برقم البطاقة)" last_update: date: 2026-10-20 --- # الدفعة المجمعة (تحصيل التاجر برقم البطاقة) مثال: `"1000000"` هو 1 USDT عندما تكون الكسور العشرية = 6. استبدل جميع العناصر النائبة بتفاصيل المستلم والأداة التي تم التحقق منها. يمكن أن يؤدي إرسال هذا الطلب إلى نقل أموال حقيقية. مراجعة العملية والتصريح بها صراحة قبل تقديمها. راجع [البدء السريع](../business/quick-start.md). يمكّن نوع المعاملة هذا مجمع خدمة الدفع من قبول مدفوعات العملاء نيابة عن تاجر متكامل. يتم خصم الأموال من الدافع وتوزيعها بين التاجر (صافي رسوم المجمع) والمجمع (جزء الرسوم) تلقائيًا. ## سير الأعمال 1. التاجر يوقع اتفاقية / انضمام مع المجمع. 2. يقوم المجمع بإرشاد التاجر لإنشاء (أو توفير) محفظة في نظام heth.me وإرسال `wallet_id` مرة أخرى. 3. باستخدام مفتاح API الخاص به، يقوم المجمع بإنشاء معاملة دفع تحدد تفاصيل محفظة التاجر في `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": "Payment", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## مرجع ميداني | المجال | الوصف | اكتب | مثال | | ----- | ----------- | :--- | ------- | | amount | مبلغ المعاملة (سلسلة من عدد صحيح في وحدات ثانوية) | String | 1000000 | | currency | عملة المعاملة (الافتراضية USDT) | String | USDT | | env | `prod` (افتراضي). الحفاظ على هذه القيمة عند فتح الطلب وتأكيده. | String | prod | | type | نوع المعاملة (الدفع) | String | payment | | route | مسار المعالجة (يجب أن يتطابق مع التعيين الذي تم تكوينه) | String | hot_hot_ETH | | money_storage_merchant | واصف محفظة التاجر (المدفوع لأمره) | Object | | | > wallet_id | معرف محفظة التاجر | String | YOUR_WALLET_ID | | > network | شبكة البلوكشين (TRX أو ETH) | String | ETH | | > type | نوع تفاعل المحفظة (على سبيل المثال، p2p_proxy) | String | p2p_proxy | | > currency | عملة تسوية التاجر (الافتراضي USDT) | String | USDT | | money_storage | واصف أداة تمويل الدافع | Object | | | > network | شبكة البلوكشين (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 | Payment | | txid | معرف المعاملة Idempotent (سلسلة) | String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## ملاحظات * يتم تطبيق منطق رسوم المجمع تلقائيًا بناءً على تكوين مفتاح API. * تأكد من تطابق `route` مع مسار المعالجة الممكّن لمفتاح API المقدم. * استخدم قيم `txid` غير الفعالة لتجنب عمليات الإرسال المكررة غير المقصودة. * استرداد حالة المعاملة عبر نقطة نهاية المعاملة القياسية GET (الاقتراع حتى الوصول إلى الحالة الطرفية). ## ar: الحصول على حالة المعاملة Source: https://docs.heth.me/markdown/ar/transactions/get_transaction.md --- title: "الحصول على حالة المعاملة" last_update: date: 2026-10-20 --- # الحصول على حالة المعاملة استرجع أحدث حالة لمعاملة معينة عن طريق `id` الداخلي باستخدام مفتاح API الخاص بك. ## طلب ``` GET /api/v1/transactions/{transaction_id}?env=prod Headers: x-api-key: ``` `{transaction_id}` هو `id` الداخلي للمعاملة (UUID)، والذي تم تمريره كمقطع مسار. ## حقول الاستجابة | المجال | الوصف | | ----- | ----------- | | amount | المبلغ بالوحدات الصغيرة | | amount_with_fee | المبلغ شاملاً الرسوم (الوحدات الثانوية) | | amount_dest | المبلغ الوجهة للتحويل (وحدات ثانوية)، إن أمكن | | currency | رمز العملة (على سبيل المثال USDT) | | currency_dest | العملة الوجهة للتحويل، إن أمكن | | description | الوصف الأصلي المقدم | | env | `prod` (افتراضي). الحفاظ على هذه القيمة عند فتح الطلب وتأكيده. | | error_description | تفاصيل الخطأ إذا تم رفض الحالة | | finished | الانتهاء من الطابع الزمني (ISO) إذا كانت المحطة الطرفية | | id | معرف المعاملة الداخلية (UUID) | | route | طريق المعالجة المستخدم | | started | الطابع الزمني للبدء (ISO) | | status | الحالة الحالية (راجع دورة حياة الحالة في الاتفاقيات الميدانية؛ على سبيل المثال، تم الإنشاء، والشحن، والتحصيل، والاسترداد، والرفض، والفشل) | | txid | المعرف الخارجي المقدم من العميل | | type | نوع المعاملة (دفع أو دفع تعويضات) | | widget_url | رابط القطعة (إذا كان تدفق القطعة) | | simple_auth_redirect_url | 3DS / مصادقة إضافية URL عند الاقتضاء | ## مثال ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## ملاحظات الاستخدام * استطلاع مع التراجع الأسي (على سبيل المثال 1s، 2s، 4s، 8s) حتى الحالة النهائية. * تحديد النتيجة من `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' ``` ## ar: قائمة المعاملات Source: https://docs.heth.me/markdown/ar/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` | بدأت أو تم تحديثها | | `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` الذي تم إرجاعه كسلسلة استعلام `cursor`، وليس كائن المؤشر بالكامل. حافظ على نفس المرشحات وorder_by. بالنسبة إلى order_by=updated، يمكن تحديث cursor_field_at. توقف عندما تكون البيانات فارغة أو لا يتم إرجاع المؤشر المتقدم. التسوية بواسطة معرف المعاملة عندما تتغير السجلات أثناء الاجتياز. ```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' ``` ## ar: المعاملة API Source: https://docs.heth.me/markdown/ar/transactions/overview.md --- title: "المعاملة API" last_update: date: 2026-10-20 --- # المعاملة API اختر التدفق لمسار حسابك الممكّن. هذه أدوات هيث افتراضية، وليست وعدًا عامًا بقبول أو دفع أي بطاقة مصرفية خارجية. راجع [البدء السريع](../business/quick-start.md) و[المصادقة](../business/authentication.md) و[معالجة الأخطاء](../business/errors.md). ## إنشاء - [الدفع بالبطاقة الافتراضية](pcn.md) - [الدفع إلى بطاقة افتراضية](wcn.md) - [الدفع للمحفظة ID](wid.md) - [الدفع المجمع](aggregator_payment.md) ## إقرأ - [احصل على معاملة](get_transaction.md) - [قائمة المعاملات](list_transactions.md) ## المرجع - [المقادير والمعرفات والحالات](../field_conventions.md) ## ar: الدفع عن طريق رقم البطاقة Source: https://docs.heth.me/markdown/ar/transactions/pcn.md --- title: "الدفع عن طريق رقم البطاقة" last_update: date: 2026-10-20 --- # الدفع عن طريق رقم البطاقة مثال: `"1000000"` هو 1 USDT عندما تكون الكسور العشرية = 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": "Payment", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` | المجال | الوصف | اكتب | مثال | | ----- | ----- | :--- | ----- | | amount | مبلغ المعاملة (سلسلة من عدد صحيح في وحدات ثانوية) | String | 1000000 | | currency | عملة المعاملة (الافتراضية USDT) | String | USDT | | env | `prod` (افتراضي). الحفاظ على هذه القيمة عند فتح الطلب وتأكيده. | String | prod | | type | نوع المعاملة (في هذه الحالة الدفع) | String | payment | | route | مسار المعاملة (يجب أن يتطابق مع تعيين المسار) | String | hot\_hot\_ETH | | money_storage | واصف أداة البطاقة | Object | | | \>network | شبكة البلوكشين (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 | 10 | | \>exp_year | سنة انتهاء الصلاحية | String | 2026 | | \>cardholder | اسم حامل البطاقة | String | John Doe | | description | وصف الصفقة | String | Payment | | txid | معرف المعاملة Idempotent (سلسلة) | String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## ar: الدفع عن طريق المحفظة ID Source: https://docs.heth.me/markdown/ar/transactions/pid.md --- title: "الدفع عن طريق المحفظة ID" last_update: date: 2026-10-20 --- # الدفع عن طريق المحفظة ID تصف هذه الصفحة نفس تدفق دفع تعويضات المحفظة-ID كمرجع أساسي. استخدم الطلب وتعريفات الحقل هناك. [الدفع عن طريق المحفظة ID](wid.md) ## ar: الدفع المجمع بالبطاقة الافتراضية Source: https://docs.heth.me/markdown/ar/transactions/rcn.md --- title: "الدفع المجمع بالبطاقة الافتراضية" last_update: date: 2026-10-20 --- # الدفع المجمع بالبطاقة الافتراضية تصف هذه الصفحة نفس تدفق مجموعة التجار كمرجع المجمع الأساسي. استخدم هذا الطلب وتعريفاته. [الدفع المجمع عن طريق البطاقة الافتراضية](aggregator_payment.md) ## ar: السحب برقم البطاقة Source: https://docs.heth.me/markdown/ar/transactions/wcn.md --- title: "السحب برقم البطاقة" last_update: date: 2026-10-20 --- # السحب برقم البطاقة مثال: `"1000000"` هو 1 USDT عندما تكون الكسور العشرية = 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": "Withdrawal", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` | المجال | الوصف | اكتب | مثال | | ----- | ----- | :--- | ----- | | amount | مبلغ المعاملة (سلسلة من عدد صحيح في وحدات ثانوية) | String | 1000000 | | currency | عملة المعاملة (الافتراضية USDT) | String | USDT | | env | `prod` (افتراضي). الحفاظ على هذه القيمة عند فتح الطلب وتأكيده. | String | prod | | route | مسار المعاملة (يجب أن يتطابق مع تعيين المسار) | String | hot\_hot\_ETH | | type | نوع المعاملة (في هذه الحالة الدفع) | String | payout | | money\_storage | كائن بيانات المستلم | Object | | | \>network | شبكة البلوكشين (TRX أو ETH) | String | ETH | | \>type | نوع السند (بنك\_بطاقة) | String | bank\_card | | \>currency | عملة المستلم (الافتراضي USDT) | String | USDT | | \>cardnumber | رقم بطاقة المستلم | String | YOUR_CARD_NUMBER | | description | وصف الصفقة | String | Withdrawal | | txid | معرف المعاملة Idempotent (سلسلة) | String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## ar: السحب عن طريق ID Source: https://docs.heth.me/markdown/ar/transactions/wid.md --- title: "السحب عن طريق ID" last_update: date: 2026-10-20 --- # السحب عن طريق ID مثال: `"1000000"` هو 1 USDT عندما تكون الكسور العشرية = 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": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Withdrawal", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` | المجال | الوصف | اكتب | مثال | | ----- | ----- | :--- | ----- | | amount | مبلغ المعاملة (سلسلة من عدد صحيح في وحدات ثانوية) | String | 1000000 | | currency | عملة المعاملة (الافتراضية USDT) | String | USDT | | env | `prod` (افتراضي). الحفاظ على هذه القيمة عند فتح الطلب وتأكيده. | String | prod | | route | مسار المعاملة (يجب أن يتطابق مع تعيين المسار) | String | hot\_hot\_ETH | | type | نوع المعاملة (في هذه الحالة الدفع) | String | payout | | money\_storage | كائن بيانات المستلم | Object | | | \>wallet\_id | معرف محفظة المستلم | String | YOUR_WALLET_ID | | \>network | شبكة البلوكشين (TRX أو ETH) | String | ETH | | \>type | نوع المعاملة للمحافظ (في هذه الحالة p2p\_proxy) | String | p2p\_proxy | | \>currency | عملة المستلم (الافتراضي USDT) | String | USDT | | description | وصف الصفقة | String | Withdrawal | | txid | معرف المعاملة Idempotent (سلسلة) | String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## ar: ميزات الحساب الإضافية Source: https://docs.heth.me/markdown/ar/user/features.md --- title: "ميزات الحساب الإضافية" last_update: date: 2026-10-21 --- # ميزات الحساب الإضافية الميزات التي تظهر في حسابك تعتمد على إعداداته. لا تعني التوضيحات التالية أن كل ميزة ممكنة لكل مستخدم. ## @أسماء المستخدمين في إعدادات اسم المستخدم، تحقق من التوفر وسعر التسجيل المعروض. حدد محفظة التمويل المؤهلة واتبع تعليمات الدفع. الحجز غير المدفوع ليس اسمًا مستلمًا نشطًا. تحقق من شروط انتهاء الصلاحية والتجديد قبل الدفع؛ قد لا يتم حل الاسم منتهي الصلاحية أو المعلق. يمكن رفض الإفراج عن الاسم أثناء عملية الدفع. ## بطاقات الهدايا في شاشة بطاقة الهدايا، يمكنك عرض مشكلاتك أو إعداد إصدار مدعوم أو استرداد رمز. يؤدي إصدار البطاقة إلى تمويلها من محفظتك المؤهلة ويتطلب تأكيدًا. قم بتخزين الرمز الذي تم الكشف عنه بشكل آمن: حيازة الرمز يمكن أن تسمح باسترداده. للاستبدال، أدخل الرمز في Heth؛ يحدد الخادم طائفته. الطلب المقدم وحده لا يعد تأكيدًا للائتمان. ## غاز شاشة شراء الغاز تقوم بتجهيز عملية منفصلة باستخدام مصدر التمويل المدعوم. تحقق من حساب الوجهة والمبلغ والشبكة. يمكن أن يتطلب مصدر التمويل البارد التوقيع. الغاز المخصص لنقل blockchain منفصل عن مبلغ الرمز المميز المنقول. ## تبرعات افتح صفحة تبرع المؤلف وتأكد من المنصة والمؤلف والأصول والشبكة والحد الأدنى والرسوم. اختر محفظة Heth المتاحة أو الحساب الخارجي وراجعها قبل التفويض. يمكن أن تنتهي صلاحية التحويلات الخارجية؛ تحقق من التفاصيل الحالية قبل الإرسال. تعرض صفحة النتائج حالة التبرع الأصلية. ## الإشعارات وخطافات الويب 1. افتح **الإعدادات → الإشعارات**، وقم بتشغيل الإشعارات ووافق على مطالبة النظام أو المتصفح. في تطبيق الهاتف المحمول، يستخدم Heth إشعارات النظام؛ يستخدم إصدار المتصفح خدمة إعلام المتصفح حيثما يكون ذلك مدعومًا. 2. إذا تم رفض الإذن، فاسمح بإشعارات Heth في إعدادات جهازك أو المتصفح، وأعد فتح Heth وحاول مرة أخرى. يعتمد التسليم أيضًا على الاتصال وقيود الجهاز. 3. لإيقاف الإشعارات على هذا الجهاز، قم بإيقاف تشغيل نفس المفتاح. هذا لا يلغي المدفوعات أو الاشتراكات أو اتصالات AI. فتح إشعار الدفع يأخذك إلى هيث. فتح الحساب ومراجعة أي إجراء مطلوب هناك؛ لا يؤدي النقر على إشعار إلى التوقيع على الدفع أو الموافقة عليه. التحقق من النتيجة النهائية في تاريخ المعاملات. في إعدادات خطاف الويب، يمكنك تكوين جهاز استقبال URL وسر للتكامل الخارجي. يتلقى URL أحداث الحساب؛ استخدم نقطة النهاية التي تتحكم فيها. راجع [تكامل خطاف الويب](../business/webhooks.md). ## الاشتراكات والأجهزة والتوقيع المتعدد إدارة طلبات الاشتراك وأذونات الدفع المستقبلية في هيث. يشرح [دليل الاشتراك والدفع التلقائي ](../subscriptions.md) موافقة الدافع وطلبات التجار وتواريخ الدفع والإلغاء. يتطلب ربط بطاقة الدفع أو التفويض بالخصم المستقبلي موافقتك الصريحة. بالنسبة للأجهزة أو حسابات التوقيع المتعدد، تأكد من أن جهازك وطريقة التوقيع يدعمان الشبكة المحددة قبل إرسال الأموال. في **الإعدادات → تفويضات الاشتراك**، يمكن للحسابات التي تتمتع بهذه الميزة عرض أذونات اشتراك العملات المشفرة الخاصة بها وحدود كل رسوم. اختر إذنًا، وحدد **إلغاء التفويض** وأكده في Heth لإيقاف الرسوم المستقبلية. لا يؤدي الإلغاء إلى استرداد الدفعات المكتملة. ## أداة التبرع في استوديو OBS أضف أداة Heth كمصدر متصفح OBS Studio لعرض QR المتلقي والموضوعات المرئية وتنبيهات الدفعات الواردة. قم بتوصيله من خلال **الإعدادات → OBS Studio** في Heth. احتفظ بالاتصال الخاص بـ URL بعيدًا عن المشاهد العامة ومحادثات AI. يمكن للمساعد الذي يستخدم MCP قراءة موجز الأحداث المقيدة وتغيير إعدادات المظهر المدعومة؛ تم تأكيد أذونات الوصول في هيث. [دليل الإعداد OBS](./obs.md). تنطبق [حدود الدفع](payments.md#payment-limits) أيضاً على القيمة الإجمالية لبطاقات الهدايا التي تصدرها. لا يتجاوز رمز صالح الحد الأقصى. ## ar: استوديو OBS: تلقي تنبيهات QR والدفع Source: https://docs.heth.me/markdown/ar/user/obs.md --- title: "استوديو OBS: تلقي تنبيهات QR والدفع" last_update: date: 2026-10-21 --- # استوديو OBS: تلقي تنبيهات QR والدفع أداة Heth هي **مصدر للمتصفح** في OBS Studio. يعرض تلقي QR الخاص بك والتنبيهات لعمليات نقل Heth الواردة والمكتملة. لا يقوم بتثبيت البرنامج المساعد OBS الأصلي ولا يتحكم في المشاهد أو التسجيل أو البث. لا يعد النقل الوارد تبرعًا تلقائيًا للمؤلف/المنصة. ![معاينة القطعة المحدثة باللغة الإنجليزية. حدث نموذجي؛ المعاينة QR لا تبدأ الدفع.](/img/obs-preview-en.png) معاينة القطعة المحدثة باللغة الإنجليزية. حدث نموذجي؛ المعاينة QR لا تبدأ الدفع. ## ربط القطعة 1. افتح Heth وقم بتسجيل الدخول إلى الحساب الذي سيستقبل التبرعات. 2. افتح **الإعدادات → OBS Studio**. المستلم هو حساب Heth الذي قمت بتسجيل الدخول إليه. 3. حدد زوج العملة/الشبكة المتاحة. أدخل بشكل اختياري المبلغ المقترح والتسمية التوضيحية والموضوع واللغة. المبلغ الفارغ يتيح للدافع اختياره. 4. حفظ المظهر. اختر **الموافقة وإنشاء اتصال OBS** لإنشاء وصول منفصل ومقيد للأداة. 5. انسخ الاتصال URL. في OBS، أضف مصدر **Browser** والصق URL. ابدأ بحجم مصدر **900 × 500** بكسل؛ قم بتغيير الحجم أو الاقتصاص ليناسب المشهد الخاص بك. 6. تحقق من المستلم والعملة والشبكة عن طريق مسح QR بهاتفك. قم بمراجعة شاشة الدفع قبل تأكيد أي عملية دفع. QR نفسه لا ينقل الأموال. الخلفية شفافة . احتفظ بـ QR دون عائق وكبير بما يكفي لإجراء المسح الضوئي. تحقق من النتيجة في المشهد الفعلي، بما في ذلك الدقة التي يتلقاها المشاهدون. تدعم الأداة اللغة الروسية والإنجليزية بشكل مستقل عن لغة واجهة Heth الخاصة بك. ## الوصول والخصوصية يستخدم الاتصال مفتاح API منفصلًا مقيدًا بـ OBS. يقوم Heth بإنشاء المفتاح ووضعه في اتصال URL، لذلك لا تحتاج إلى نسخ مفتاح من إعدادات الأعمال. إعدادات خطاف الويب الحالية مستقلة: ترسل خطافات الويب الأحداث إلى الخادم الخاص بك، بينما يقرأ مصدر متصفح OBS موجز الأداة المقيد مباشرةً. لا تحتاج إلى تشغيل جهاز استقبال webhook للأداة القياسية. ينتمي مفتاح OBS إلى حسابك ويمكنه قراءة خلاصة عناصر واجهة المستخدم الخاصة به. يتم منح أذونات MCP بشكل منفصل؛ يعد إلغاء اتصال OBS وإلغاء اتصال AI إجراءين منفصلين. يحتوي الاتصال URL على رمز وصول خاص OBS في جزءه، بعد `#`. تعامل مع URL بأكمله باعتباره خاصًا: لا تضعه في وصف البث أو لقطات الشاشة أو عمليات تصدير المشهد العام أو دردشة AI. يحتوي QR المعروض للمشاهدين على تفاصيل الدفع، وليس هذا الرمز المميز. يمكن للوصول إلى OBS قراءة معرف الاستلام وإعدادات المظهر وخلاصة الدفعات الواردة المقيدة. ولا يمكنه قراءة رصيدك أو سجل المعاملات الكامل أو إرسال الأموال أو تعديل الإعدادات. في **الإعدادات → OBS Studio**، قم بإلغاء الاتصال القديم إذا تم كشف URL الخاص به أو توقفت عن استخدامه. أنشئ اتصالاً جديدًا في هيث عند الحاجة. ## طريقة عمل التنبيهات التنبيهات تمثل الحوالات الواردة بالحالة `charged`. يتم استبعاد العمليات المعلقة والفاشلة والصادرة. يستخدم المبلغ مبلغ المستلم ودقته المخزنة؛ لم يتم تقريبه إلى رمز مميز كامل. إذا كانت الدقة غير متوفرة، فإن القطعة لا تخترع مبلغًا. يبدأ الاتصال الجديد بأحداث جديدة. يمكن لمصدر المتصفح قيد التشغيل استئناف العمل من المؤشر المحفوظ الخاص به بعد انقطاع قصير؛ تقتصر نافذة إعادة التشغيل على ساعات 24. لا تعد إعادة تحميل المصدر أو إعادة إنشائه طريقة لتصدير سجل الحساب. تحقق من تفاصيل الاستلام والعملية النهائية في [سجل المعاملات ](./payments.md)، بشكل مستقل عن التنبيه المباشر. ## تغيير القطعة مع مساعد AI يمكن للمساعد المتصل الذي يستخدم [خدمة MCP عن بعد ](../ai/mcp.md) مع الأذونات المناسبة قراءة إعدادات القطعة وعرض موجز الأحداث المقيدة واقتراح اتصال. يمكنه تغيير إعدادات المظهر العادي مع التأكيد في عميل AI. تقوم الأداة المتصلة بالفعل بتحديث المظهر المحفوظ تلقائيًا، عادةً خلال ثوانٍ 30. إنشاء أو إلغاء الوصول وتغيير حساب الاستقبال يتطلب تأكيدًا في هيث. يوفر المساعد رابطًا لشاشة إعداد Heth؛ ولا يتلقى اتصال OBS الخاص URL. طلبات الأمثلة: "استخدم تعليقًا باللغة الإنجليزية وموضوعًا مصغرًا لعنصر واجهة المستخدم OBS الخاص بي" أو "إظهار الأحداث الواردة الأخيرة لعنصر واجهة المستخدم الخاص بي". MCP لا يمنح المساعد التحكم في OBS Studio نفسه. ## التصميم الخاص بك والتخصيص بمساعدة AI {#custom-layout} لا تحتاج إعدادات Heth القياسية إلى الوصول إلى كود المصدر. للحصول على تخطيط تعسفي، شوكة الجمهور [Heth OBS القطعة](https://github.com/Heth-me/obs-widget)، مرخصة بموجب MIT. ابدأ بدليل [AI](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md)، وخريطة الملفات وتعليمات الاستضافة. يتضمن المستودع تعليمات البناء والاستضافة. يمكن لمساعد الترميز الذي يتمتع بإمكانية الوصول إلى نسختك تغيير التخطيط وCSS والخطوط والألوان وعرض الإشعارات، ثم التحقق من المعاينة الاصطناعية والبناء. لا يحتاج إلى اتصال OBS المباشر URL أو بيانات اعتماد الدفع. يجب استضافة البنية المخصصة: المستودع العام في حد ذاته لا يخدم تنبيهات الدفعات الواردة. يستطيع Heth MCP قراءة الأحداث وتغيير إعدادات مظهر Heth المدعومة. لا يقوم بتحرير مستودع أو تجميع بنية مخصصة أو منح مساعد الوصول إلى حساب الاستضافة الخاص بك. بالنسبة للتخطيطات التعسفية HTML/CSS، قم بتخصيص المشروع مفتوح المصدر. يمكنك الاستمرار في استخدام الأداة القياسية التي تستضيفها Heth دون إنشاء أي شيء. ## استكشاف الأخطاء وإصلاحها **يظهر Heth 404 بدلاً من الأداة:** قم بتحديث Heth، وتحقق من مصدر المتصفح URL وأعد فتح المصدر. إذا استمر الخطأ، فاتصل بالدعم. لا تقم بإنشاء مفاتيح جديدة لإصلاح خطأ تحميل الصفحة. - **لا يوجد إدخال لإعدادات OBS:** قم بتحديث Heth وتحقق من الوصول إلى حسابك مع الدعم. لا تقم بلصق مفتاح API للحساب العام في عنصر واجهة المستخدم URL. - **تظهر QR، لا يوجد تنبيه:** تأكد من اكتمال التحويل ووروده إلى هذا الحساب. يجب أن يظل مصدر المتصفح نشطًا ومتصلًا. - **تم تعطيل الوصول:** إعادة الاتصال في حث؛ لن تؤدي إعادة محاولة URL الملغاة إلى استعادة الإذن. - **أصل أو شبكة خاطئة:** قم بتصحيح الإعدادات في Heth، وانتظر حتى يتم تحديث الأداة وقم بمسح QR مرة أخرى قبل قبول المدفوعات. - **URL القديم يستخدم `api_key=`:** أعد الاتصال من خلال الإعدادات → OBS Studio. حافظ على خصوصية URL القديم وقم بإلغاء مفتاح الحساب القديم. ## ar: الدفع واستلام الدفعات Source: https://docs.heth.me/markdown/ar/user/payments.md --- title: "الدفع واستلام الدفعات" last_update: date: 2026-10-23 --- # الدفع واستلام الدفعات ## حدود الدفع {#payment-limits} افتح `Settings → Amount Confirmation → Payment limits`. للحدود عملتها الخاصة، والعملة الافتراضية هي USDT. تنطبق الحدود داخل Heth فقط: الدفع برمز QR الخاص بالدافع أو برمز تأكيد المبلغ، وإصدار بطاقات الهدايا باستخدام ذلك الرمز، والتحويلات الداخلية التي يبدأها الذكاء الاصطناعي. لا تنطبق على تحويلات البلوكشين أو التحويلات العادية التي تبدأها يدوياً. رسوم الشبكة مستثناة. - **Without a code, up to**: الدفعات حتى هذه القيمة، بما فيها القيمة نفسها، لا تحتاج إلى رمز إضافي. اضبطها على صفر لطلب التأكيد لكل دفعة. - **Maximum per payment**: تُرفض الدفعات التي تتجاوز القيمة ولو كان رمز التأكيد صالحاً. اتركها فارغة إن لم ترغب في حد أقصى. قبل كل دفعة من هذه الدفعات، يقيّم Heth المبلغ المخصوم من حسابك، بما فيه رسوم المنصة المخصومة من الحساب نفسه، بعملة الحد. تستخدم الرموز المرتبطة بالنقد عملتها الأصلية: RUB_T يستخدم RUB، وUZS_T يستخدم UZS، وcNGN يستخدم NGN. تُعالج المنازل العشرية للرمز بشكل منفصل. يُقيَّم USDT بقيمة 1 USD لهذا الحساب المرجعي. لا تُحوّل هذه المراجعة أصولك إلى عملة أخرى. تساعد القيم التقريبية على فهم الحدود بعملة أخرى. تغيير عملة العرض لا يغيّر الحد المحفوظ أو مبلغ الدفع. تعرض الإعدادات تاريخ سعر الصرف عند توفره. إذا لم يتوفر سعر حالي، فلا يستطيع Heth السماح بدفعة خاضعة لحد أقصى ملزم؛ حاول لاحقاً. يسمح رمز تأكيد المبلغ بالدفع حتى القيمة العددية المؤكدة: لفاتورة **9987** يمكنك تأكيد **10000**، ويُخصم **9987**. لا يتجاوز الرمز حدود الدفع. تظل التحويلات بمساعدة الذكاء الاصطناعي بحاجة إلى موافقة داخل Heth مهما كانت عتبة الدفع دون رمز. تأتي أسعار الصرف المرجعية من بيانات البنوك المركزية، وللعملات غير المشمولة من [ExchangeRate-API](https://www.exchangerate-api.com). ## ادفع مع هيث افتح شاشة الدفع واتبع طريقة الدفع المتاحة. يمكن للدافع QR أن يأذن بالدفع: قم بمشاركته فقط مع التاجر المقصود. عندما يطلب التطبيق تأكيد المبلغ، تحقق من التاجر والمبلغ قبل التأكيد. لا ترسل مطلقًا عبارة الاسترداد أو سر الدفع إلى تاجر أو مساعد AI. يمكن للتطبيق إظهار بعض المعلومات المخزنة مؤقتًا أو إنشاء رموز دافع معينة دون اتصال. لا يزال التاجر بحاجة إلى الاتصال لمعالجة الدفع؛ لا يتم تنفيذ عمليات النقل العادية دون اتصال بالإنترنت. راجع [حدود عدم الاتصال بالإنترنت ](security.md). ## تأكيد مبلغ السداد اتبع طريقة التأكيد التي يعرضها هيث لهذه الدفعة: 1. افتح دافعك QR وأظهره فقط للتاجر المقصود. 2. التأكد من المبلغ المطلوب والمستلم قبل الموافقة. 3. إذا طلب منك هيث إنشاء رمز، ارجع إلى شاشة تأكيد المبلغ بعد عرض QR الخاص بك، وأدخل مبلغ الدفع وقم بإنشاء الرمز الحالي. 4. اقرأ هذا الرمز للصراف فقط لهذه الدفعة. وهو يختلف عن عبارة الاسترداد أو PIN أو سر الدفع القابل لإعادة الاستخدام، والذي يجب عليك الحفاظ على خصوصيته. 5. إذا انتهت صلاحية الرمز أو الرمز QR، فافتح رمزًا جديدًا واتبع المطالبة الحالية. إذا لم يتم تكوين التأكيد، فأكمل الإعداد في Heth أثناء الاتصال بالإنترنت. 6. التحقق من حالة المعاملة الأصلية. لا يثبت QR المعروض أو الكود الذي تم إنشاؤه أو طلب أمين الصندوق في حد ذاته الدفع. ## قبول الدفع هيث 1. مفتوح **أعمال**. 2. أدخل المبلغ وحدد الأصول/الشبكة المتاحة. 3. قم بمسح هيث QR الخاص بالدافع وقدم الطلب. 4. إذا كانت موافقة الدافع مطلوبة، فانتظرها. 5. تعامل مع الدفعة على أنها مستلمة فقط عندما تكون حالتها `charged`. التراجع والنتيجة المعلقة والمهلة هي نتائج مختلفة. احتفظ بمعرف العملية الأصلي عند التحقق من النتيجة. ## مشاركة رابط الاستلام تنشئ شاشة رابط الدفع Heth استلام URL مع معرف المستلم الخاص بك والعملة المحددة والمبلغ اختياريًا. يراجع الدافع ويأذن بالتحويل. مشاركة الرابط لا تكلف أحدا. يختلف استلام URL هذا عن رابط دفع الأعمال المُدار الذي تم إنشاؤه من خلال API. لا تفترض أن رابط الاستلام الذي تم إنشاؤه محليًا يحتوي على قائمة من جانب الخادم أو وظيفة انتهاء الصلاحية أو الإلغاء. ## مقدمي خدمات QR الآخرين استخدم فقط الطرق الممكّنة فعليًا لحسابك. لا يعد شعار موفر QR أو الماسح الضوئي الذي يتعرف على التنسيق دليلاً على توفر مسار الدفع المقابل. اتصل بالدعم إذا تعذر استخدام إحدى الطرق؛ لا تستبدل مستلمًا آخر أو شبكة أخرى لفرض الدفع من خلاله. ## ar: أمان الحساب والاستخدام دون اتصال بالإنترنت Source: https://docs.heth.me/markdown/ar/user/security.md --- title: "أمان الحساب والاستخدام دون اتصال بالإنترنت" last_update: date: 2026-10-21 --- # أمان الحساب والاستخدام دون اتصال بالإنترنت ## الإسترجاع والتوقيع احتفظ بعبارات الاسترداد والمفاتيح الخاصة في المحفظة التي تمتلكها. يعمل إلغاء القفل PIN أو القفل البيومتري على حماية الوصول إلى الجهاز الحالي؛ فهو ليس بديلاً للنسخة الاحتياطية للاسترداد. لا تشارك مطلقًا أي مفتاح أولي أو مفتاح خاص أو سر دفع قابل لإعادة الاستخدام مع الدعم أو التاجر أو مساعد AI. أظهر دفعة QR لمرة واحدة فقط للتاجر المقصود. إذا طلب منك الوضع B صراحةً قراءة رمز التأكيد لأمين الصندوق، فلا تفعل ذلك إلا بعد التحقق من تلك الدفعة ومبلغها. تأكد من الأصل والمستلم والمبلغ والعملة والشبكة قبل التوقيع. إن إعادة ربط الحساب أو تغيير الشبكة أو فتح المطالبة بالمحفظة لا يؤدي في حد ذاته إلى إكمال الدفع. للحصول على محفظة الأجهزة، تحقق من التفاصيل الموجودة على الجهاز أيضًا. ## Face ID / Touch ID ومفاتيح المرور في **الإعدادات → Face ID / Touch ID**، قم بتمكين إلغاء القفل البيومتري إذا كان هذا الخيار متاحًا، ثم قم بتأكيد مطالبة النظام. يستخدم Heth بيانات اعتماد WebAuthn (مفتاح المرور) لإلغاء القفل المحلي. يعتمد التوفر على الجهاز والمتصفح؛ استخدم PIN عندما يكون إلغاء القفل البيومتري غير متاح أو مُلغى. يؤدي هذا إلى فتح Heth على الجهاز الحالي. فهو لا يحل محل عبارة الاسترداد الخاصة بك، أو يستعيد حسابًا على جهاز آخر، أو يأذن باتصال أو دفع AI. احتفظ بنسخة احتياطية للاسترداد قبل تغيير الأجهزة أو إعادة تثبيت Heth. ## حدود الأوف لاين يمكن الاطلاع على الأرصدة والسجل المخزن مؤقتًا أثناء عدم الاتصال بالإنترنت، ولكن قد يكون قديمًا. يمكن إنشاء بعض رموز الدافع محليًا للتاجر المتصل بالإنترنت. يتطلب إرسال التحويلات وتحميل الأرصدة الحالية واستلام نتيجة معالجة مؤكدة الاتصال. بعد إعادة الاتصال، قم بتحديث السجل قبل تكرار أي عملية. ## الرسوم والدعم الاطلاع على الرسوم والمبلغ الموضح للتشغيل الفعلي. يمكن فصل رسوم غاز blockchain عن رسوم الخدمة. لا تستنتج رسومًا أو وقت إكمال مضمونًا من نوع نقل آخر. استخدم [Heth support](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). ## ar: تحويل وسحب الأموال Source: https://docs.heth.me/markdown/ar/user/transfers.md --- title: "تحويل وسحب الأموال" last_update: date: 2026-10-20 --- # تحويل وسحب الأموال اختر المصدر أولاً: رصيد المحفظة الداخلي أو حساب التشفير. ثم حدد المستلم والأصل والشبكة. التحقق من المبلغ والمستلم والرسوم عند المراجعة النهائية قبل التصريح بالعملية. ## أنواع التحويلات | نقل | إجراء المستخدم | | --- | --- | | المحفظة → المحفظة | أدخل معرف المستلم أو قم بحل اسم المستخدم النشط، ثم قم بمراجعة النقل | | المحفظة → حساب التشفير | أدخل العنوان الخارجي وشبكته. مراجعة السحب والرسوم | | حساب التشفير → المحفظة | حدد الحساب المصدر والمحفظة الوجهة؛ قم بالتوقيع على معاملة blockchain المعدة | | حساب التشفير → حساب التشفير | تحقق من المستلم الخارجي وقم بالتوقيع باستخدام محفظة المالك | التحويل الداخلي والسحب من blockchain لهما متطلبات معالجة ورسوم مختلفة. قد تحتاج عمليات نقل Blockchain إلى توازن الغاز الأصلي. يعتبر شراء الغاز عملية منفصلة؛ التحقق من المصدر وحساب الوجهة. ## محافظ خارجية وأجهزة بالنسبة لعناوين المراقبة فقط، استخدم المحفظة الخارجية المتصلة بهذا العنوان. يجب أن يتطابق الحساب المتصل والشبكة مع المصدر. تعتمد طرق التوقيع المدعومة على الشبكة والمتصفح والجهاز. قد لا يؤدي التحويل المفتوح من خلال رابط المحفظة إلى إرجاع تجزئة المعاملة إلى Heth: فتح محفظة أخرى ليس دليلاً على الدفع. ## إذا كانت النتيجة غير واضحة افتح سجل المعاملات وفحص العملية الأصلية. لا تكرر عملية النقل فقط بسبب انتهاء مهلة الشاشة أو انقطاع الشبكة. احفظ معرفه واتصل بالدعم إذا ظلت الحالة غير واضحة. لا يجب وصف العملية المعلقة بأنها دفعة مكتملة. [مشاكل الدفع وحالته](troubleshooting.md). ## ar: مشاكل الدفع وحالة المعاملة Source: https://docs.heth.me/markdown/ar/user/troubleshooting.md --- title: "مشاكل الدفع وحالة المعاملة" description: "ابحث عن دفعة Heth الأصلية وافهم النتيجة المعلقة وحل مشاكل الشبكة أو الرصيد أو تأكيد QR." last_update: date: 2026-10-20 --- # مشاكل الدفع وحالة المعاملة ## انتهت مهلة الشاشة: هل يجب أن أرسل مرة أخرى؟ 1. استعادة الاتصال وفتح سجل المعاملات في نفس الحساب. 2. ابحث عن العملية الأصلية من خلال معرفها ووقتها ومبلغها والمستلم. افتح تفاصيلها إذا كانت متوفرة. 3. التحقق من الوضع الحالي. إذا ظلت العملية معلقة أو لا يمكن العثور عليها، فاتصل بالدعم قبل الإرسال مرة أخرى. النتيجة المفقودة ليست دليلاً على عدم نقل أي أموال. 4. احتفظ بالمعرف الأصلي للمتابعة. بالنسبة لعمليات تكامل API، استخدم [status lookup](../transactions/get_transaction.md) ونفس `txid` الأصلي؛ لا تقم بإنشاء معرف بديل لتجاوز المهلة. | الحالة | ماذا تفعل | | --- | --- | | `created`, `pending`, `processing` | المعالجة ليست كاملة. تحديث العملية الأصلية؛ لا تحسبها وردت | | `auth_required` | افتح Heth واتبع الموافقة المطلوبة لهذه العملية | | `charged` | لقد استقرت العملية. تحقق من المبلغ والمستلم والرسوم في التفاصيل | | `rejected`, `failed` | اقرأ الخطأ الأصلي وحل سببه قبل محاولة إجراء عملية جديدة | | No status or an unfamiliar status | إبقاء النتيجة غير مؤكدة وطلب التوضيح؛ لا تستنتج النجاح أو الفشل | استرداد الأموال أو التراجع نتيجة منفصلة. التأكد من ذلك من العملية الأصلية والرصيد الدائن الفعلي. لا يمكن إلغاء نقل blockchain بمجرد إغلاق Heth. ## الرصيد أو تفاصيل الاستلام تبدو خاطئة - التحقق من الحساب والأصول والشبكة. تعد المحفظة الداخلية وحساب التشفير وجهتين مختلفتين. - قم بالتحديث بعد إعادة الاتصال. يمكن أن تحتوي الشاشة غير المتصلة بالإنترنت على معلومات مخزنة مؤقتًا. - للإيداع الخارجي، قارن الوجهة والشبكة في محفظة الإرسال مع تفاصيل الاستلام الخاصة بـ Heth. لا تؤدي المعاملة التي تتم على شبكة أخرى إلى إضافة هذا الحساب تلقائيًا. - للحصول على حساب بارد إضافي مفقود على جهاز آخر، أعد توصيل محفظته الأصلية. راجع [الحسابات والنسخ الاحتياطي](wallets.md). ## الدافع QR أو تأكيد المبلغ لا يعمل فتح دافع جديد QR في هيث. إذا طلب التطبيق رمز التأكيد، فاتبع [تعليمات الدفع](payments.md)، وتحقق من المبلغ واستخدم الرمز الحالي. QR ليس إيصالاً. يحتاج التاجر إلى الاتصال لمعالجة الطلب. إذا أشار التطبيق إلى عدم تكوين التأكيد، فأكمل إعداده في Heth أثناء الاتصال بالإنترنت. ## تواصل مع الدعم أرسل معرف المعاملة والوقت التقريبي مع المنطقة الزمنية والأصول/الشبكة والمبلغ والخطأ المرئي إلى [Heth support](https://t.me/hethmesupport_bot). إخفاء المعلومات الشخصية غير ذات الصلة في لقطات الشاشة. لا تقم أبدًا بتضمين عبارة استرداد أو مفتاح خاص أو مفتاح API أو الدافع QR أو رمز بطاقة الهدايا أو سر الدفع القابل لإعادة الاستخدام. ## ar: ابدأ وافهم محفظتك Source: https://docs.heth.me/markdown/ar/user/wallets.md --- title: "ابدأ وافهم محفظتك" last_update: date: 2026-10-20 --- # ابدأ وافهم محفظتك فتح [Heth.me](https://app.heth.me). قم بإنشاء عبارة استرداد أو استعادة حسابك الحالي، ثم اتبع خطوات التطبيق لتعيين PIN وإلغاء القفل البيومتري حيثما يكون ذلك مدعومًا. احتفظ بعبارة الاسترداد بشكل منفصل قبل تلقي الأموال. راجع [أمان الحساب](security.md). ## حساب ومحفظة التشفير | العنصر | ماذا يعني | كيف يتم التصريح بالنقل | | --- | --- | --- | | حساب التشفير (البارد) | عنوان blockchain، تم إنشاؤه أو توصيله في التطبيق | يقوم المالك بالتوقيع باستخدام محفظة أجهزة محلية أو خارجية أو مدعومة | | المحفظة (ساخنة) | رصيد حساب يستخدم للمدفوعات والتحويلات الداخلية | تقوم الخدمة بمعالجة العملية المعتمدة | | حساب للمشاهدة فقط | تمت إضافة عنوان للعرض بدون مفتاحه الخاص | المشاهدة لا تعطي الإذن بالإنفاق؛ استخدم المُوقع المتصل | يمكن تخزين الحسابات الباردة وتسمياتها على جهازك. تسجيل الدخول في مكان آخر لا يؤدي بالضرورة إلى استعادة كل حساب إضافي قمت بتوصيله على جهاز آخر. عمل نسخة احتياطية لكل حساب من خلال محفظته الأصلية. ## استلام الأموال 1. افتح حساب التشفير أو المحفظة المطلوبة. 2. فحص الأصول والشبكة. USDT على Ethereum وUSDT على TRON هي وجهات نقل مختلفة. 3. استخدم تفاصيل الاستلام أو QR الموضحة لذلك الحساب. لا تستبدل عنوان blockchain بمعرف المحفظة الداخلي. 4. تأكيد العملية الواردة في التاريخ. الرصيد المعلق ليس هو نفس الأموال المتاحة. للشراء عبر صرافة خارجية، تأكد من الشبكة الوجهة لها قبل السحب. توفر صفحة التبادل روابط لخدمات خارجية؛ يعتمد التوفر والشروط على ذلك المزود. ## الأصول المتوفرة استخدم الأصول المعروضة لحسابك. يمكن أن يتضمن سجل الرمز المميز العالمي أصولًا غير ممكّنة في الواجهة الخاصة بك أو لعملية معينة. ## zh: 连接 AI 助手 Source: https://docs.heth.me/markdown/zh/ai/mcp.md --- title: "连接 AI 助手" last_update: date: 2026-10-23 --- # 连接 AI 助手 Heth MCP 为助理提供对您自己帐户的有限访问权限，包括可用的业务功能。它无法授予平台管理访问权限。打开连接屏幕不会授予任何权限。 ## 连接助手 1. 在钱包已打开的 Heth 应用程序中，转到 **设置 → AI 连接** 并选择 **创建连接代码**。一次性代码属于该帐户，并在五分钟后过期。 2. 在 AI 客户端的连接设置中，添加 `https://mcp.heth.me/mcp` 并选择 OAuth。开始连接。 3. 在连接窗口中，仅输入 Heth 的代码。您未在此浏览器中登录您的钱包。该代码向创建它的确切帐户发送请求；它不授予任何访问权限。 4. 如果 Heth 打开，应用程序顶部会出现 **AI 连接请求** 通知。选择 **查看连接请求**，或打开推送。您还可以在**设置 → AI 连接 → 连接请求**下找到该请求。将**请求验证码**与连接窗口中的验证码进行对比，查看账户、客户端标识和服务地址。仅凭应用程序名称并不能验证身份。 5. 在 Heth 中，取消选中您不想共享的权限，然后选择 **批准选定的 AI 访问**，或选择 **拒绝 AI 访问**。单独打开推送并不能批准任何事情。 6. 返回AI客户端。当你在Heth做出决定后，它的连接窗口会自动结束。您的钱包会话和签名密钥保留在 Heth 中。 已使用或过期的连接代码无法重复使用。在Heth中创建一个新的代码；创建一个替换以前未使用的代码。如果整个连接请求过期，则从AI客户端重新启动。 ### 在 ChatGPT 中 打开**插件 → 添加 → 添加自定义 MCP 服务器**，输入名称（例如 Heth.me）和上面的服务器地址，并保持选中 **OAuth**。 ChatGPT 自动发现连接设置；不需要钱包 API 密钥、客户端密钥或恢复短语。创建个人插件，选择 **Connect Heth.me**，然后按照上面的代码和推送步骤操作。您可以在**高级 OAuth 设置**下选择默认权限；最终帐户权限选择在 Heth 应用程序中确认。 连接后，在聊天中选择 Heth.me 并尝试“使用 Heth 显示我的钱包余额”。可用的工具取决于您批准的权限。 ### Claude Code 在终端中，添加 Heth 并开始连接： ```sh claude mcp add --transport http heth https://mcp.heth.me/mcp claude mcp login heth ``` Claude Code 自动注册连接并打开浏览器窗口。在那里输入 Heth 的一次性代码，然后使用上述步骤在 Heth 应用程序中审核并批准权限。保持终端打开，直到连接完成。您不需要客户端标识符、客户端密钥或钱包 API 密钥。 连接后，询问 Claude：“使用 Heth 显示我的钱包余额”。它只能使用您批准的权限。您可以在 Heth 的 **设置 → AI 连接** 中管理或撤销此连接。 ## 钱包余额 询问：“使用 Heth 显示我的钱包余额”。钱包名称与应用程序匹配：`USDT ERC20`、`USDT TRC20`、`USDT Base`、`cNGN Base`。每笔金额均包含其代币单位； `RUB_T`、`UZS_T` 和 `ZOLT` 仍然是不同的代币名称。不显示钱包数据库标识符。 助手会收到以代币为单位的精确余额和格式指导。例如，`1.000001 USDT` 不得显示为 `1 USDT`，并且小的非零金额不得变为零。小数点和分组分隔符遵循您的语言。如果无法精确显示，助手会显示破折号并解释原因，而不是发明一个数字。不同的货币和网络不会加在一起。仅存储在您设备上的钱包不包括在内。 ## 权限和工具 仅可以批准客户请求且当前可用于您的帐户的权限。工具仅在获得所需权限后才可见。工具涵盖账户数据、转账、普通业务变更、订阅请求和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`：在 AI 客户端中确认的普通更改 | | `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 审核链接或外观字段仅在 AI 客户端中确认 | `prepare_obs_connection` 不创建访问权限，也不返回 OBS 令牌。货币/网络、接收帐户、密钥和访问权限无法通过外观工具更改。请参阅[OBS设置和定制指南](../user/obs.md)，包括开源项目和编码助手说明。 ## 访问持续多长时间 您的连接权限将持续**直到您撤销它**。技术凭证单独过期：MCP 访问令牌有效期为 15 分钟；刷新令牌在 30 天后轮换并过期，无需续订。即使同意记录仍然有效，过期的技术凭证也可能要求您重新连接。 每个请求都会检查当前连接和帐户权限。 Heth 使用单独的受限 API 凭证，其有效期最多为 60 秒，以服务 MCP 请求；完整的钱包会话不与 MCP 共享。撤销同意或撤回帐户权限会阻止后续请求，包括使用未过期令牌的请求。已返回给客户端的数据无法撤回。 ## 撤销或重新连接 在Heth中，打开**设置→AI连接**，检查客户端标识符、服务地址、权限和状态。选择 **Revoke AI access** 并在 Heth 中确认。撤销不会取消已完成的付款或订阅借记授权；在[订阅设置](../user/features.md)中单独管理它们。 如果要求重新连接，请在 AI 客户端中启动新的授权。撤销、过期的凭据、撤回的权限或检测到刷新令牌的重复使用都可能会终止访问。请勿将恢复短语、钱包密钥或浏览器会话凭据粘贴到助手中以修复连接。服务不可用是一个错误，而不是空帐户或成功批准。 ## 付款和其他变更 Heth 要求 **每次货币操作都需要在 Heth 中单独确认**。连接权限并不授权自动支出。 普通产品和付款链接编辑需要在 AI 客户端中确认。访问权限、付款接收者或未来借记授权的更改需要 Heth 确认。 OBS 的出现遵循客户端确认策略。仅凭工具注释并不能证明客户获得了认可。 您还可以使用[Heth应用程序](https://app.heth.me)或支持的[API集成](../business/quick-start.md)。 ## 与助手一起转移 1. 告诉助理转账类型、收款人、币种、网络和金额。内部到内部 (`hot_hot`)、内部到区块链 (`hot_cold`)、区块链到您的内部帐户 (`cold_hot`) 和区块链到区块链 (`cold_cold`) 是不同的操作。使用`self`作为`cold_hot`的接收者；它记入您自己的 Heth 帐户。 2. `prepare_transfer` 保存条款并返回 Heth 审核链接。它不会产生任何付款。金额和 `max_debit` 使用代币最小货币单位中的精确整数字符串。 `max_debit` 限制代币借记（包括平台费用）。对于区块链源，`max_network_fee` 以 wei (ETH/Base) 或 sun (TRON) 为单位限制交易的网络 Gas 费用。基地可能会额外收取 L1 数据费。 3. 打开Heth并检查账户，询问客户、收件人、来源、金额、网络和费用限制。仅当所有条款均正确时才选择 **确认并发送到 Heth**。打开链接并不批准或发送任何内容。请求在 15 分钟后过期。 4. Heth 对显示的指令进行签名并使用其正常传输流程。区块链交易在您的设备或连接的签名设备上签名。打开Heth，可以对源账户进行签名；私钥永远不会交给助手。 5. 助手读取`get_transfer_request`查看原始交易。批准或处理与付费不同。超时后，读取原始结果；如果必须重试准备，请重复使用相同的 `request_id` 和相同的术语。不要创建第二次传输来解决不确定的结果。 撤销会阻止新的传输开始。已接受执行的交易仍可以完成；撤销 AI 连接不会取消已接受的区块链传输。 ## 产品、链接和订阅 助手会显示普通产品或托管链路更改，以在 AI 客户端中进行确认。价格和链接金额是最小货币单位的整数字符串；产品数量为正整数。稳定的 `request_id` 使重试具有幂等性。这些操作无法编辑付款路线、付款收件人、密钥或访问权限。删除链接或产品不会撤销之前的付款。 `request_business_subscription` 创建请求供付款人在 Heth 进行审核。它不授予未来借记许可，并且本身不产生任何费用。付款人在登录 Heth 之前查看金额、频率和首次收费。使用 `list_business_subscription_requests` 检查请求，使用 `get_business_subscription` 或 `list_business_subscriptions` 检查现有协议。 要暂停、恢复或取消协议，`prepare_business_subscription_change` 返回 Heth 查看屏幕。在所有者确认之前不会发生任何变化。恢复允许在现有付款许可下按计划收费。取消将停止未来的费用，并且不会退还已完成的付款。更改商定的计费条款需要新的付款人批准。 您设置的[付款限额](../user/payments.md#payment-limits)适用于 AI 准备的内部转账（`hot_hot`）。Heth 在执行前检查当前限额和参考汇率。链上转账与网络费用不在这些限额范围内。AI 权限或有效确认码均不能绕过最高限额；请在 Heth 中修改设置。显示金额时应注明资产和网络，换算等值金额必须标为近似值。不得直接比较不同资产的原始最最小货币单位数值。 ## zh: 身份验证和 API 密钥 Source: https://docs.heth.me/markdown/zh/business/authentication.md --- title: "身份验证和 API 密钥" last_update: date: 2026-10-20 --- # 身份验证和 API 密钥 ## 颁发和撤销密钥 1. 登录[Heth](https://app.heth.me)并打开**业务**。 2. 使用**连接** 打开集成屏幕。 3. **API集成**中，使用**+**颁发密钥。 4. 将密钥作为秘密存储在服务器端集成中。 5. 要撤销密钥，请删除该屏幕上的条目。更换密钥时更新集成。 切勿使用屏幕截图或文档示例中打印的密钥。该文档使用占位符而不是可用的凭据。 ## 请求标头 |标题 |使用 | | --- | --- | | `x-api-key` | API 密钥认证所需 | | `Content-Type: application/json` |提交时必填 JSON | 对于 `https://app.heth.me`，Heth 网关提供组织上下文。此规则适用于该主机：不要假设它适用于不同的平台 API URL。 API密钥绑定了自己的账户和权限。 ## 密钥和用户会话不同 交易集成接受 API 密钥。交互式钱包功能可能需要登录用户的 Bearer 会话；密钥不会自动授予对钱包、个人资料、用户名或每个业务功能的访问权限。客户订阅会话是一种单独的授权类型。切勿用一种令牌类型替换另一种令牌类型，或将种子复制到集成配置中。 请参阅[功能](capabilities.md) 和[错误](errors.md)。集成必须仅请求其任务所需的访问权限。 ## zh: 业务能力和可用性 Source: https://docs.heth.me/markdown/zh/business/capabilities.md --- title: "业务能力和可用性" last_update: date: 2026-10-20 --- # 业务能力和可用性 使用为登录帐户启用的功能。平台中存在的 API 端点并不意味着您的账户、网络或支付路径已启用它。 |能力|整合边界| | --- | --- | |付款和支出|交易API，已配置路线，允许的支付工具| | Heth 接收链接 |应用程序中生成的接收URL；分享不产生费用| |托管支付链接和产品 |独立的业务资源；需要启用帐户访问权限 | |商家订阅 |向您的客户收取费用的协议；需要支持的付款方式和客户授权 | |付款人自己的订阅权限 |单独的客户授权和明确的批准/撤销| |退款或取消 |仅在原始交易和支付方式支持的情况下；区块链传输一般是不可逆的 | |钱包、@usernames、礼品卡、webhooks |帐户功能可能需要用户的会话和额外的确认| |捐款|平台/作者流程及其自己的收件人、最低金额、费用和到期日 | 公共代币注册表返回配置，而不是使用每个列出的资产进行支付的权利。将资产与网络和有效的账户配置相匹配。例如，USDT/ETH 和 USDT/TRX 不能互换。 ## 文档边界 [事务参考](../transactions/overview.md) 涵盖记录流程的请求格式。不要获取操作员凭据或更改终端/路由来解决被拒绝的请求。当账户路径不可用时，请联系支持人员并提供交易标识符。 [AI 连接指南](../ai/mcp.md) 解释了您帐户可用功能的权限和确认。 ## zh: 错误、状态检查和重试 Source: https://docs.heth.me/markdown/zh/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` 并以有界退避重试读取 | | Timeout / 5xx |结果可能未知。重新提交前通过 `id` 或 `txid` 查找原始操作 | 错误响应形状可能因端点而异。最好有记录的机器可读错误代码（如果有）； `error_description` 是人类可读的文本，而不是稳定的代码。从日志中删除或遮蔽凭据及支付工具数据。 ## 交易结果 - `charged`：交易成功完成。 - `rejected` 或 `failed`：检查原因及原操作；不报告成功。 - `refunded` 或 `reversed`：资金与新结算的付款有不同的结果。 - 待处理/需要操作/未知状态：显示该状态和所需的用户操作。切勿仅根据无法识别的状态或时间戳来推断成功。 使用[GET 交易](../transactions/get_transaction.md) 来验证操作。保留相同的 `txid` 以重试相同的业务指令。 Webhook 传送失败和支付处理失败是不同的事件。 ## zh: 开始 API 集成 Source: https://docs.heth.me/markdown/zh/business/quick-start.md --- title: "开始 API 集成" last_update: date: 2026-10-20 --- # 开始 API 集成 使用为您自己的 Heth 账户颁发的 API 密钥。首先阅读[身份验证](authentication.md)、[金额和状态](../field_conventions.md)]和[可用业务能力](capabilities.md)。 ## 无需移动资金即可验证访问权限 在集成的秘密存储中设置 `HETH_API_KEY`。不要将其放入源代码管理、浏览器捆绑包、URL 或 AI 对话中。此请求读取帐户交易而不移动资金。 ```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 密钥仅授权其帐户可用的操作。 ## zh: 产品、托管链接和订阅 Source: https://docs.heth.me/markdown/zh/business/resources.md --- title: "产品、托管链接和订阅" last_update: date: 2026-10-20 --- # 产品、托管链接和订阅 这些是帐户拥有的业务资源。需要 API 密钥或合作伙伴承载访问以及相应的启用功能。钥匙并不能打开支付途径。请参阅[身份验证](authentication.md)。 对于读取和删除，env 是一个查询过滤器。对于产品/链接创建和更新，请在 JSON 正文中发送 env。合伙人所有权来自凭证；不要发送另一个partner_id。资源价格字段可以具有端点特定的整数类型：交易 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 ``` 创建产品定义其标题、文本、价格、数量和货币。产品不是付款。列出响应使用数据/总计；产品详细信息和创作响应使用数据。显示的价格为 1 USDT（小数点后 = 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/表单信息，而不是发明的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 和一个循环对象；间隔接受每日、每周、每月或每年，其中 period 指定间隔数。付款人必须授权付款方式和定期借记条款。创建订阅并不能证明存在可用的借记权限。 生命周期操作使用 `POST /recurrents/{id}/pause`、/resume 和 /cancel。读取返回的状态；取消未来的费用不会退还之前的费用。 Heth 付款人在启用该功能的“设置”→“订阅授权”中通过钱包会话管理自己的加密货币订阅授权。这与商家订阅管理是分开的。 ## zh: Webhook 集成 Source: https://docs.heth.me/markdown/zh/business/webhooks.md --- title: "Webhook 集成" last_update: date: 2026-10-20 --- # Webhook 集成 Webhook 向您的接收 URL 报告帐户事件。这是一个通知；通过[GET交易](../transactions/get_transaction.md).验证权威交易状态。 ## 配置接收器 在 Heth webhook 设置中，设置您控制的 URL，配置集成密钥并启用传递。更改 URL 会更改接收帐户事件的人员。保护该端点并避免重定向到不受信任的收件人。配置需要用户的帐户会话；用于交易的 API 密钥并不自动足够。 ## 安全处理通知 1. 验证帐户 Webhook 签名和重播检查，如下所述。 2. 记录事件/交易标识符并编辑敏感字段。 3. 使处理幂等：重复或延迟交付不得创建另一笔付款。 4. 使用您自己的凭证检索交易并协调其状态。 5. 返回配置的交付合约所需的接收方响应。 不要将浏览器推送通知视为 Webhook 或交付保证。本概述不承诺每个配置的集成都通用的排序、重试间隔或身份验证格式。在启用生产自动化之前获取实际的交付合同。 ## 账户 webhook 传递格式 此格式适用于 Heth 设置中配置的帐户 Webhook。其他回调集成可能使用不同的合约。 配置非空帐户 Webhook 密钥时，请求包括 x-webhook-signature（十六进制 HMAC-SHA256）、x-webhook-timestamp（Unix 秒）和 x-webhook-event-id。通过时间戳+“.”验证HMAC + 使用配置的秘密的确切原始 HTTP 主体字节；在验证之前不要解析和重新序列化 JSON。检查签名主体时间戳是否与时间戳标头匹配，拒绝高于 5 分钟的时钟差异，在恒定时间内比较签名，并按 event_id 进行重复数据删除。重试保留 event_id 但收到新的时间戳/签名。如果没有配置秘密，签名标头可能会不存在；在信任自动交付之前配置机密。 ```text hex(HMAC-SHA256(secret, timestamp + "." + raw_body)) ``` 信封包含 event_id、时间戳、类型和数据。对于账户交易事件，数据包括tx_id、txid、type、status、amount、currency和event_type。 amount 可以是 JSON 整数：使用无损解析器。捐赠可以添加捐赠对象。记录后使用 HTTP 2xx 确认已验证的事件；重复验证的 event_id 值不得触发业务操作两次。即使在有效通知后也可以通过 GET 确认交易。 ## zh: 字段约定和术语表 Source: https://docs.heth.me/markdown/zh/field_conventions.md --- title: "字段约定和术语表" last_update: date: 2026-10-20 --- # 字段约定和术语表 API 文档中使用的规范定义。 ## 请求标头 |标题 |必填|定义 | | ------ | -------- | ---------- | | x-api-key |是的 | API-在应用程序中颁发的密钥（“业务”部分）。该组织是从请求主机解析的 | | Content-Type |是（POST）| `application/json` 用于创建请求 | ## 金额及币种 |术语 |定义 | | ---- | ---------- | | amount |以最小货币单位表示的整数字符串（例如分、最小标记分数）| | amount_with_fee |金额加申请费（最小货币单位）| | currency | ISO 类货币/代币代码（例如 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`。最常见的正常流程是`created → charging → charged`。 ## 时间字段 |领域|定义 | | ----- | ---------- | | started | ISO 处理开始时的时间戳 | | finished | ISO 处理完成时的时间戳；从状态决定结果| ## 货币存储对象 |领域|定义 | | ----- | ---------- | | network |区块链网络（ETH、TRX等）| | type |工具类型（bank_card、p2p_proxy 等）| | wallet_id |内部钱包标识符（支付/支付目标）| | cardnumber |虚拟卡 PAN（在某些回复中被掩盖）| | cvv |虚拟卡安全码（不得以明文写入日志）| | exp_month / exp_year |卡到期值（字符串，零填充）| | cardholder |持卡人姓名（ASCII 或 UTF-8）| ## 错误字段 |领域|定义 | | ----- | ---------- | | error_description |人类可读的失败原因（不稳定文本）| ## 幂等性指南 每个业务操作使用唯一的（幂等）`txid`，并在发送前将其保留。该值是一个字符串； UUID 生成很方便，但不需要 UUID 语法。在相同的账户中使用相同的标识符重试相同的指令。请勿将其重复用于不同的收件人或金额。超时后恢复原来的操作；重试不能默默地成为新的付款。 ## 轮询策略 轮询读取具有有限的退避，例如 1s → 2s → 4s → 8s，交互预算为 30s。在已知的最终状态或预算到期时停止。超时时报告待定/未知结果并保留原始 `id`/`txid`。未知的状态并不代表成功。请参阅[错误和重试](business/errors.md)。 ## Webhooks（信息） Webhooks 指示状态更改，但不具有权威性。始终通过 GET 交易确认。 ## 金额精度 金额是最小货币单位的整数字符串，而不是浮点值。从`GET https://app.heth.me/api/v1/contracts?env=prod`中获取货币、网络的小数位数。 USDT/ETH 和 USDT/TRX 目前使用 6 小数：1 USDT = `"1000000"`、0.25 USDT = `"250000"`。 ETH 有 18 小数位；这并不适用于以太坊上的每个代币。未知的金额精度必须停止金额转换。请参阅[API 架构](/openapi.json)。 ## zh: 使用 Heth.me：钱包、转账和付款 Source: https://docs.heth.me/markdown/zh/intro.md --- slug: "/" sidebar_position: 1 title: "钱包、转账和支付 API" 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)支付或接受付款并分享接收链接。 - [使用@username、礼品卡和捐款](user/features.md)，并配置通知。 - [保护账户访问](user/security.md)并了解离线限制。 以太坊上的 USDT 转账和 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 成功未确认付款：查看原始交易状态。 ## 将 AI 连接到 Heth.me [通过Heth MCP](ai/mcp.md)连接您的AI助手，即可使用您自己的账户和可用的业务功能。您选择其权限并确认 Heth 中的每项货币操作。该指南解释了连接、转移、业务变更、OBS 和撤销。 AI 集成开发人员可以使用[已记录的 API 子集](/openapi.json)、[文档索引](/llms.txt) 和[全文指南](/llms-full.txt)]。这些描述了接口和规则；从API获取当前余额、权限和操作结果。 ## 应用程序和支持 [打开Heth.me](https://app.heth.me) · [联系支持](https://t.me/hethmesupport_bot) ## zh: 订阅和自动转账 Source: https://docs.heth.me/markdown/zh/subscriptions.md --- title: "订阅和自动转账" --- # 订阅和自动转账 商店可以要求 Heth.me 用户批准定期付款。付款人使用普通的未锁定 HethWallet 审查并签署条件。不需要单独的电子邮件帐户或客户门户登录。付款以约定的货币和网络扣除 **Heth 账户余额**。 ## 对于付款人 1. 打开**设置→订阅和自动付款**。新请求与现有订阅分开显示。 2. 打开请求并检查商店、每次付款的金额、货币/网络和计费周期。确认链接会打开同一屏幕。锁定的钱包会请求其通常的 PIN 并返回该请求。 3. 选择**启用订阅**或**拒绝**。打开链接或接收通知永远不会批准订阅。 4. 审核通过后，安排第一笔付款。列表显示金额、期限和下一次付款日期；重试失败支付时，会显示下次重试时间。 5. 撤销订阅以停止未来收费。撤销不会退还已完成的付款。 批准记录同意并安排付款；并不代表支付成功。检查交易状态。执行付款时，余额必须足够。 ## 如何宣布新请求 对于认可的付款人，服务器会向注册设备发送订阅请求推送，并带有指向 `/subscriptions/confirm/?env=` 的链接。即使没有设备可以接收推送，条目也会保存在通知铃声中。待处理的请求仍然可以在**设置 → 订阅和自动付款**中找到。 安装的 PWA 使用网络推送。适用于 iOS 和 Android 的 Heth.me，从版本 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` |以令牌最小货币单位表示的正整数。对于 6- 十进制 USDT，`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`。请求将在 7 天后过期。成功的创建并不表明所提供的付款人是否存在；只有实际收件人才能阅读并批准该请求。 ## API 操作 以下所有路径均以 `/api/v1` 开头。商店操作需要商店的 API 密钥或合作伙伴承载会话。 |方法与路径|目的| | --- | --- | | `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"}`。 | 签名绑定店铺、付款人、组织、描述、金额及其精度、货币/网络、间隔和周期、首次付款规则、随机数和到期日。更改条件需要新的请求和新的同意。重试批准或预定付款不能在同一期间两次借记。不带时区后缀的 API 时间戳为 UTC；该应用程序显示设备本地时间。 ## 状态和错误 请求状态为 `pending`、`signed`、`rejected` 和 `expired`。已批准的请求具有 `subscription_id`。通过交易 API 和配置的 webhooks 跟踪实际支付完成情况。 `401` 表示身份验证缺失/无效； `403` 表示订阅已禁用或 API 密钥为只读。无法访问的请求返回 `404`。 `422` 表示无效条款、在不同条件下重复使用的 UUID、无效签名或过期/关闭的请求。未经新付款人同意，商店不能更改有效订阅的已签署条件。 ## zh: 聚合支付（商户按卡号收款） Source: https://docs.heth.me/markdown/zh/transactions/aggregator_payment.md --- title: "聚合支付（商户按卡号收款）" last_update: date: 2026-10-20 --- # 聚合支付（商户按卡号收款） 示例：当小数 = 6 时，`"1000000"` 为 1 USDT。将所有占位符替换为经过验证的收件人和仪器详细信息。发送此请求可以转移真实资金。在提交操作之前进行审查并明确授权该操作。请参阅[快速入门](../business/quick-start.md)。 此交易类型使支付服务聚合器能够代表集成商户接受客户付款。资金从付款人处扣除，并自动在商户（扣除聚合商费用）和聚合商（费用部分）之间分配。 ## 业务流程 1. 商户与聚合商签署协议/加入。 2. 聚合器指示商家在 heth.me 系统中创建（或提供）钱包并发回 `wallet_id`。 3. 使用自己的 API 密钥，聚合器创建支付交易，指定 `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": "Payment", "txid": "d9428888-122b-41e1-b85c-61cb3f548aa7" } }' ``` ## 现场参考 |领域|描述 |类型 |示例| | ----- | ----------- | :--- | ------- | | amount |交易金额（最小货币单位整数字符串）| String | 1000000 | | currency |交易币种（默认USDT） | String | USDT | | env | `prod`（默认）。打开并确认请求时保留该值。 | String | prod | | type |交易类型（支付）| String | payment | | route |处理路由（必须匹配配置的映射） | String | hot_hot_ETH | | money_storage_merchant |商户（收款人）钱包描述符 | Object | | | > wallet_id |商户钱包标识符 | String | YOUR_WALLET_ID | | > network |区块链网络（TRX 或 ETH）| String | ETH | | > type |钱包交互类型（例如 p2p_proxy）| String | p2p_proxy | | > currency |商户结算币种（默认USDT） | String | USDT | | money_storage |付款人融资工具描述符| Object | | | > network |区块链网络（TRX 或 ETH）| String | ETH | | > type |工具类型（银行卡）| 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 | Payment | | txid |幂等事务标识符（字符串）| String | d9428888-122b-41e1-b85c-61cb3f548aa7 | ## 注释 * 聚合器费用逻辑根据 API 密钥配置自动应用。 * 确保 `route` 与所提供的 API 密钥的启用处理路由匹配。 * 使用幂等 `txid` 值以避免意外重复提交。 * 通过标准 GET 交易端点检索交易状态（轮询直到达到最终状态）。 ## zh: 获取交易状态 Source: https://docs.heth.me/markdown/zh/transactions/get_transaction.md --- title: "获取交易状态" last_update: date: 2026-10-20 --- # 获取交易状态 使用您的 API 密钥通过其内部 `id` 检索特定交易的最新状态。 ## 请求 ``` GET /api/v1/transactions/{transaction_id}?env=prod Headers: x-api-key: ``` `{transaction_id}` 是交易的内部 `id` (UUID)，作为路径段传递。 ## 响应字段 |领域|描述 | | ----- | ----------- | | amount |以最小货币单位表示的金额 | | amount_with_fee |含费用金额（最小货币单位）| | amount_dest |转换的目标金额（最小货币单位）（如果适用）| | currency |货币代码（例如 USDT）| | currency_dest |用于转换的目标货币（如果适用）| | description |提供原始描述 | | env | `prod`（默认）。打开并确认请求时保留该值。 | | error_description |如果状态被拒绝，则错误详细信息 | | finished |完成时间戳 (ISO) 如果终端 | | id |内部事务标识符（UUID）| | route |使用的加工路线| | started |开始时间戳（ISO）| | status |当前状态（请参阅现场约定中的状态生命周期；例如创建、收费、收费、退款、拒绝、失败）| | txid |客户提供的外部标识符 | | type |交易类型（付款或支出）| | widget_url |小部件链接（如果小部件流）| | simple_auth_redirect_url | 3DS / 附加授权 URL（适用时）| ## 示例 ```bash curl --location 'https://app.heth.me/api/v1/transactions/c033ceaa-3726-4479-8be3-c9af8a0b2336?env=prod' \ --header "x-api-key: $HETH_API_KEY" ``` ## 使用说明 * 使用指数退避（例如 1s、2s、4s、8s）进行轮询，直到达到最终状态。 * 判断`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' ``` ## zh: 列出交易 Source: https://docs.heth.me/markdown/zh/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` |开始或更新 | | `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` 作为查询字符串 `cursor` 传递，而不是整个游标对象。保持相同的过滤器和 order_by。对于 order_by=updated，cursor_field 可以 update_at。当数据为空或没有返回前进光标时停止。当遍历过程中记录发生更改时，通过事务 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' ``` ## zh: 交易API Source: https://docs.heth.me/markdown/zh/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) - [支付至钱包ID](wid.md) - [聚合支付](aggregator_payment.md) ## 阅读 - [获取一笔交易](get_transaction.md) - [列出交易](list_transactions.md) ## 参考 - [金额、标识符和状态](../field_conventions.md) ## zh: 卡号支付 Source: https://docs.heth.me/markdown/zh/transactions/pcn.md --- title: "卡号支付" last_update: date: 2026-10-20 --- # 卡号支付 示例：当小数 = 6 时，`"1000000"` 为 1 USDT。将所有占位符替换为经过验证的收件人和仪器详细信息。发送此请求可以转移真实资金。在提交操作之前进行审查并明确授权该操作。请参阅[快速入门](../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": "Payment", "txid": "f47ac10b-58cc-4372-a567-0e02b2c3d479" } }' ``` |领域|描述 |类型 |示例| | ----- | ----- | :--- | ----- | | amount |交易金额（最小货币单位整数字符串）| String | 1000000 | | currency |交易币种（默认USDT） | String | USDT | | env | `prod`（默认）。打开并确认请求时保留该值。 | String | prod | | type |交易类型（在本例中为付款）| String | payment | | route |交易路线（必须匹配路线映射）| String | hot\_hot\_ETH | | money_storage |卡式仪器描述符| Object | | | \>network |区块链网络（TRX 或 ETH）| String | ETH | | \>type |工具类型（银行卡）| String | bank_card | | \>currency |工具货币（默认USDT）| String | USDT | | \>cardnumber |虚拟卡号 | String | YOUR_CARD_NUMBER | | \>cvv |虚拟卡CVV | String | YOUR_CVV | | \>exp_month |到期月份 | String | 10 | | \>exp_year |到期年份| String | 2026 | | \>cardholder |持卡人姓名 | String | John Doe | | description |交易说明 | String | Payment | | txid |幂等事务标识符（字符串）| String | f47ac10b-58cc-4372-a567-0e02b2c3d479 | ## zh: 钱包支付 ID Source: https://docs.heth.me/markdown/zh/transactions/pid.md --- title: "钱包支付 ID" last_update: date: 2026-10-20 --- # 钱包支付 ID 此页面描述了与规范参考相同的钱包-ID 支付流程。使用那里的请求和字段定义。 [钱包支付ID](wid.md) ## zh: 通过虚拟卡聚合支付 Source: https://docs.heth.me/markdown/zh/transactions/rcn.md --- title: "通过虚拟卡聚合支付" last_update: date: 2026-10-20 --- # 通过虚拟卡聚合支付 此页面描述了与规范聚合器参考相同的商家收款流程。使用该请求及其定义。 [虚拟卡聚合支付](aggregator_payment.md) ## zh: 卡号提款 Source: https://docs.heth.me/markdown/zh/transactions/wcn.md --- title: "卡号提款" last_update: date: 2026-10-20 --- # 卡号提款 示例：当小数 = 6 时，`"1000000"` 为 1 USDT。将所有占位符替换为经过验证的收件人和仪器详细信息。发送此请求可以转移真实资金。在提交操作之前进行审查并明确授权该操作。请参阅[快速入门](../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": "Withdrawal", "txid": "2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f" } }' ``` |领域|描述 |类型 |示例| | ----- | ----- | :--- | ----- | | amount |交易金额（最小货币单位整数字符串）| String | 1000000 | | currency |交易币种（默认USDT） | String | USDT | | env | `prod`（默认）。打开并确认请求时保留该值。 | String | prod | | route |交易路线（必须匹配路线映射）| String | hot\_hot\_ETH | | type |交易类型（在本例中为支付）| String | payout | | money\_storage |接收者数据对象 | Object | | | \>network |区块链网络（TRX 或 ETH）| String | ETH | | \>type |工具类型（银行\_卡）| String | bank\_card | | \>currency |收款币种（默认USDT）| String | USDT | | \>cardnumber |收款人卡号 | String | YOUR_CARD_NUMBER | | description |交易说明 | String | Withdrawal | | txid |幂等事务标识符（字符串）| String | 2b9d6a7e-1c34-4f8a-9e21-7c5d0a1b2e3f | ## zh: ID 提现 Source: https://docs.heth.me/markdown/zh/transactions/wid.md --- title: "ID 提现" last_update: date: 2026-10-20 --- # ID 提现 示例：当小数 = 6 时，`"1000000"` 为 1 USDT。将所有占位符替换为经过验证的收件人和仪器详细信息。发送此请求可以转移真实资金。在提交操作之前进行审查并明确授权该操作。请参阅[快速入门](../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": { "wallet_id": "YOUR_WALLET_ID", "network": "ETH", "type": "p2p_proxy", "currency": "USDT" }, "description": "Withdrawal", "txid": "7c9e6679-7425-40de-944b-e07fc1f90ae7" } }' ``` |领域|描述 |类型 |示例| | ----- | ----- | :--- | ----- | | amount |交易金额（最小货币单位整数字符串）| String | 1000000 | | currency |交易币种（默认USDT） | String | USDT | | env | `prod`（默认）。打开并确认请求时保留该值。 | String | prod | | route |交易路线（必须匹配路线映射）| String | hot\_hot\_ETH | | type |交易类型（在本例中为支付）| String | payout | | money\_storage |接收者数据对象 | Object | | | \>wallet\_id |收件人钱包标识符 | String | YOUR_WALLET_ID | | \>network |区块链网络（TRX 或 ETH）| String | ETH | | \>type |钱包的交易类型（在本例中为 p2p\_proxy）| String | p2p\_proxy | | \>currency |收款币种（默认USDT）| String | USDT | | description |交易说明 | String | Withdrawal | | txid |幂等事务标识符（字符串）| String | 7c9e6679-7425-40de-944b-e07fc1f90ae7 | ## zh: 其他帐户功能 Source: https://docs.heth.me/markdown/zh/user/features.md --- title: "其他帐户功能" last_update: date: 2026-10-21 --- # 其他帐户功能 您帐户中显示的功能取决于其设置。以下解释并不意味着每个功能都为每个用户启用。 ## @username 在用户名设置中，检查可用性和显示的注册价格。选择符合条件的资金钱包并按照付款说明进行操作。未付款的预订不是有效的接收名称。付款前检查到期和续订条款；过期或暂停的名称可能无法解析。在付款过程中可以拒绝公布姓名。 ## 礼品卡 在礼品卡屏幕中，您可以查看您的问题、准备支持的问题或兑换代码。发行卡的资金来自您自己的合格钱包，并且需要确认。安全地存储所显示的代码：拥有该代码可以进行兑换。如需兑换，请输入Heth代码；服务器确定其面额。单独提交的请求并不构成信用确认。 ## Gas Gas购买屏幕使用支持的资金来源准备单独的操作。检查目的地账户、金额和网络。冷的资金来源可能需要签名。区块链传输的 Gas 与传输的代币数量是分开的。 ## 捐款 打开作者捐赠页面，查看平台、作者、资产、网络、最低金额、费用。选择可用的 Heth 钱包或外部账户并在授权前进行审核。外部转账可能会过期；发送前检查当前详细信息。结果页面显示原始捐赠状态。 ## 通知和 webhooks 1. 打开**设置→通知**，打开通知并批准系统或浏览器提示。在移动应用程序中，Heth 使用系统通知；浏览器版本使用受支持的浏览器通知服务。 2. 如果权限被拒绝，请在设备或浏览器设置中允许 Heth 发送通知，重新打开 Heth 后重试。通知送达还取决于网络连接及设备限制。 3. 要停止此设备上的通知，请关闭同一开关。这不会取消付款、订阅或 AI 连接。 打开付款通知后将进入 Heth。请解锁账户，并在应用中查看需要执行的操作；点击通知不会签署或批准付款。最终结果请在交易记录中核实。 在 webhook 设置中，可为外部集成配置接收 URL 和密钥。账户事件会发送到此 URL；请使用由您控制的端点。参见 [webhook 集成](../business/webhooks.md)。 ## 订阅、硬件钱包及多重签名 在 Heth 中管理订阅请求和未来扣款授权。[订阅与自动付款指南](../subscriptions.md) 说明付款人批准、商户请求、付款日期及授权撤销。绑定银行卡或授权未来扣款均需要您明确同意。对于硬件钱包或多重签名账户，发送资金前请确认设备与签名方式支持所选网络。 在**设置 → 订阅授权**中，具备此功能的账户可查看自己的加密货币订阅授权及单次扣款上限。选择一项授权，点击**撤销授权**并在 Heth 中确认，即可停止未来扣款。撤销不会退还已经完成的付款。 ## OBS Studio 捐赠小工具 添加 Heth 小部件作为 OBS Studio 浏览器源，以显示接收 QR、视觉主题和收款警报。通过 Heth 中的 **设置 → OBS Studio** 连接它。使私人连接 URL 远离公共场景和 AI 对话。使用 MCP 的助手可以读取受限事件源并更改支持的外观设置；访问权限在 Heth 中得到确认。 [OBS 设置指南](./obs.md)。 [付款限额](payments.md#payment-limits)也适用于您发行的礼品卡总额。有效确认码不能绕过最高限额。 ## zh: OBS Studio：收款二维码与付款提醒 Source: https://docs.heth.me/markdown/zh/user/obs.md --- title: "OBS Studio：收款二维码与付款提醒" last_update: date: 2026-10-21 --- # OBS Studio：收款二维码与付款提醒 Heth 小组件是 OBS Studio 中的**浏览器源**，用于显示收款二维码及已完成的 Heth 收款提醒。它不会安装原生 OBS 插件，也不会控制场景、录制或推流。收到转账并不自动意味着该款项属于作者或平台捐赠。 ![更新后的小部件英文预览。示例事件；预览 QR 不发起付款。](/img/obs-preview-en.png) 新版小组件的英文预览。图中事件为演示数据；预览二维码不会发起付款。 ## 连接小部件 1. 打开 Heth 并登录将接收捐款的帐户。 2. 打开**设置 → OBS Studio**。收款方为您当前登录的 Heth 账户。 3. 选择可用的币种与网络组合。可选填建议金额、说明文字、主题及语言；金额留空时由付款人选择。 4. Save the appearance.选择 **批准并创建 OBS 连接** 为小部件创建单独的、受限的访问权限。 5. 复制连接 URL。在 OBS 中添加**浏览器**源并粘贴该 URL。初始尺寸可设为 **900 × 500** 像素，再按场景调整大小或裁剪。 6. 用手机扫描二维码，核对收款方、币种与网络。确认任何付款前，请查看付款界面。二维码本身不会转移资金。 背景为透明。请勿遮挡二维码，并保持足够尺寸以便扫描。在实际场景中检查效果，包括观众实际接收到的分辨率。小组件支持俄语和英语，其语言独立于 Heth 的界面语言。 ## 访问权限与隐私 连接使用一个仅限 OBS 的独立 API 密钥。Heth 会创建密钥并将其放入连接 URL，无需从业务设置中手工复制密钥。已有 webhook 设置与此独立：webhook 将事件发送至您的服务器，而 OBS 浏览器源直接读取受限的小组件数据源。使用标准小组件无需运行 webhook 接收服务。 OBS 密钥属于您的账户，可读取该账户的小组件数据源。MCP 权限单独授予；撤销 OBS 连接与撤销 AI 连接是两项独立操作。 连接 URL 在 `#` 后的片段中包含私有 OBS 访问令牌。请将整个 URL 作为机密处理，不要放入直播说明、截图、公开导出的场景或 AI 对话。观众看到的二维码仅含付款信息，不含该令牌。 OBS 访问权限仅可读取收款标识、外观设置和受限的收款事件流；不能读取余额或完整交易记录、发送资金或编辑设置。如果连接 URL 泄露或已停止使用，请在**设置 → OBS Studio**中撤销旧连接；需要时在 Heth 中创建新连接。 ## 提醒的工作方式 提醒仅对应状态为 `charged` 的入账转账，不包括待处理、失败或转出的操作。金额采用收款方金额及其存储精度，不会舍入为整枚代币；若无法取得精度，小组件不会编造金额。 新的联系从新的事件开始。正在运行的浏览器源可以在短暂中断后从其保存的光标处恢复；其重播窗口仅限于 24 小时。重新加载或重新创建源并不是导出帐户历史记录的方法。验证[交易历史记录](./payments.md)中的收据和最终操作详细信息，独立于流中警报。 ## 使用 AI 助手更改小部件 使用具有适当权限的[远程 MCP 服务 ](../ai/mcp.md) 的连接助手可以读取小部件设置、查看受限事件源并提出连接。可以在AI客户端确认后更改普通外观设置。已连接的小部件会自动刷新保存的外观，通常在 30 秒内。 创建或撤销访问权限以及更改接收帐户需要在 Heth 中进行确认。助手提供了 Heth 设置屏幕的链接；它不接收私有 OBS 连接 URL。示例请求：“为我的 OBS 小部件使用英文标题和最小主题”或“显示我的小部件最近传入的事件”。 MCP本身并没有给予OBS Studio的辅助控制。 ## 自己的布局和AI辅助定制{#custom-layout} 标准 Heth 设置不需要源代码访问。对于任意布局，请分叉公共 [Heth OBS widget](https://github.com/Heth-me/obs-widget)，在 MIT 下获得许可。从其 [AI 指南 ](https://github.com/Heth-me/obs-widget/blob/main/AI_GUIDE.md)、文件映射和托管说明开始。该存储库包括构建和托管说明。 有权访问您的副本的编码助理可以更改布局、CSS、字体、颜色和通知演示，然后检查综合预览和构建。它不需要您的实时 OBS 连接 URL 或支付凭证。必须托管自定义构建：公共存储库本身不提供收款警报。 Heth MCP 可以读取事件并更改支持的 Heth 外观设置。它不会编辑存储库、编译自定义版本或授予助理访问您的托管帐户的权限。对于任意HTML/CSS布局，自定义开源项目。您可以继续使用标准 Heth 托管的小部件，而无需构建任何内容。 ## 故障排除 **Heth 显示 404 而不是小部件：** 更新 Heth，检查浏览器源 URL 并重新打开源。如果错误仍然存​​在，请联系支持人员。不要创建新密钥来修复页面加载错误。 - **无 OBS 设置条目：** 更新 Heth 并在支持人员的帮助下检查您的帐户访问权限。请勿将普通帐户 API 密钥粘贴到小部件 URL 中。 - **出现二维码但没有提醒：** 确认转账已完成且收款方为此账户。浏览器源必须保持启用并联网。 - **访问已禁用：** 在 Heth 中重新建立连接。重试已撤销的 URL 不会恢复权限。 - **币种或网络错误：** 在 Heth 中修正设置，等待小组件刷新，并在接受付款前重新扫描二维码。 - **旧URL使用`api_key=`：**通过设置→OBS Studio重新连接。将旧的 URL 保密并撤销过时的帐户密钥。 ## zh: 支付和收款 Source: https://docs.heth.me/markdown/zh/user/payments.md --- title: "支付和收款" last_update: date: 2026-10-23 --- # 支付和收款 ## 付款限额 {#payment-limits} 打开 `Settings → Amount Confirmation → Payment limits`。限额使用单独的币种，默认为 USDT。 这些限额仅适用于 Heth 内部：使用付款人二维码或金额确认码付款、使用确认码发行礼品卡，以及通过 AI 发起的内部转账。不适用于链上转账或您手动发起的普通转账。网络费用不计入这些限额。 - **Without a code, up to**：不超过此数值（含此值）的付款无需额外的金额确认码。设为零可要求每笔付款均确认。 - **Maximum per payment**：超过此数值的付款将被拒绝，即使确认码有效。留空表示不设置上限。 执行这些付款前，Heth 会按限额币种计算从您账户扣除的金额，包括从该账户扣除的平台费用。法币代币使用其原始币种的汇率：RUB_T 使用 RUB，UZS_T 使用 UZS，cNGN 使用 NGN。代币的小数位数单独处理。参考计算将 USDT 按 1 USD 计值。此检查不会兑换您的资产。 近似等值金额用于辅助理解。更改显示币种不会更改已保存的限额或付款金额。设置页面会在可用时显示汇率日期。如果无法获得当前汇率，Heth 无法批准受硬性上限约束的付款；请稍后重试。 金额确认码允许在已确认的数值以内付款：账单为 **9987** 时，可以确认 **10000**，实际扣除 **9987**。确认码不能绕过付款限额。无论免确认码阈值如何，AI 辅助转账仍需在 Heth 中批准。 参考法币汇率来自中央银行数据；未覆盖的币种使用 [ExchangeRate-API](https://www.exchangerate-api.com)。 ## 使用 Heth 支付 打开付款界面并按可用付款方式操作。付款人二维码可授权付款，仅应向目标商户展示。如果应用要求确认金额，请先核对商户与金额。切勿向商户或 AI 助手发送恢复短语或付款机密。 应用可在离线时显示部分缓存信息或生成某些付款人代码。商户仍须联网才能处理付款；普通转账不能离线执行。参见[离线限制](security.md)。 ## 确认付款金额 请按照 Heth 所示的付款确认方法进行操作： 1. 打开您的付款人 QR 并仅向目标商户显示。 2. 在批准之前检查请求的金额和收件人。 3. 如果 Heth 要求生成确认码，请在展示付款二维码后返回金额确认界面，输入付款金额并生成当前确认码。 4. 仅针对本次付款向收银员读取该代码。它与恢复短语、PIN 或可重复使用的支付秘密不同，您必须对其保密。 5. 如果 QR 或代码过期，请打开一个新的并按照当前提示进行操作。如果未配置确认，请在 Heth 中在线完成设置。 6. 查看原始交易状态。显示的 QR、生成的代码或收银员请求本身并不证明付款。 ## 接受 Heth 付款 1. Open **Business**. 2. 输入金额并选择可用的资产/网络。 3. 扫描付款人Heth QR并提交请求。 4. 如果需要付款人批准，请等待。 5. 仅当付款状态为 `charged` 时才将其视为已收到。 拒绝、等待结果和超时是不同的结果。检查结果时保留原始操作标识符。 ## 分享收款链接 付款链接界面会生成 Heth 收款 URL，其中包含收款标识、所选币种及可选金额。付款人须查看并授权转账；分享链接不会自动向任何人扣款。 此接收 URL 不同于通过 API 创建的托管业务付款链接。不要假设本地生成的接收链接具有服务器端列表、到期或取消功能。 ## 其他 QR 提供商 仅使用账户实际启用的方式。二维码上的服务商标识或扫描器能够识别某种格式，并不代表相应支付渠道可用。若某种方式无法使用，请联系支持；不要通过替换收款方或网络来强行付款。 ## zh: 账户安全与离线使用 Source: https://docs.heth.me/markdown/zh/user/security.md --- title: "账户安全与离线使用" last_update: date: 2026-10-21 --- # 账户安全与离线使用 ## 恢复与签名 请在所属钱包中保管恢复短语和私钥。PIN 或生物识别解锁仅保护当前设备上的访问，不能代替恢复备份。切勿向支持人员、商户或 AI 助手提供种子、私钥或可重复使用的付款机密。一次性付款二维码只应展示给目标商户。若模式 B 明确要求向收银员报读确认码，请先核对该笔付款及金额。 签名前请核对来源、收款方、金额、币种和网络。重新连接账户、更换网络或打开钱包提示本身均不会完成付款。使用硬件钱包时，也应在设备屏幕上核对详情。 ## Face ID / Touch ID 与通行密钥 在**设置 → Face ID / Touch ID**中，若该选项可用，请启用生物识别解锁并确认系统提示。Heth 使用 WebAuthn 凭据（通行密钥）进行本地解锁。可用性取决于设备及浏览器；若生物识别不可用或已取消，请使用 PIN。 此操作仅解锁当前设备上的 Heth，不能代替恢复短语、在其他设备上恢复账户，或授权 AI 连接及付款。更换设备或重新安装 Heth 前，请保留恢复备份。 ## 离线限制 离线时可查看缓存的余额与历史记录，但信息可能已过期。部分付款人代码可在本地生成，供已联网的商户处理。发送转账、加载最新余额和获得确认的处理结果均需要网络连接。恢复联网后，请先刷新记录，再决定是否重复操作。 ## 费用与支持 请查看实际操作界面显示的费用及金额。区块链 Gas 费可能独立于服务费；不要根据另一种转账类型推断当前费用或保证完成时间。 通过 [Heth 支持](https://t.me/hethmesupport_bot) 提供交易标识及问题说明，不要发送账户机密。请在 Heth 中阅读[隐私政策](https://app.heth.me/settings/legal/privacy-policy)及[服务条款](https://app.heth.me/settings/legal/terms-of-service)。 [付款问题与状态](troubleshooting.md). ## zh: 转账及提现 Source: https://docs.heth.me/markdown/zh/user/transfers.md --- title: "转账及提现" last_update: date: 2026-10-20 --- # 转账及提现 先选择资金来源：内部 Wallet 余额或 Crypto Account。然后选择收款方、资产及网络；授权操作前，在最终确认界面核对金额、收款方及费用。 ## 传输类型 |转让|用户操作 | | --- | --- | | Wallet → Wallet | 输入收款方标识，或解析有效的 @username，再核对转账详情。 | |钱包 → 加密账户 |输入外部地址及其网络；审查提款和费用 | | Crypto Account → Wallet | 选择来源账户及目标 Wallet，并签署已准备的区块链交易。 | | Crypto Account → Crypto Account | 核对外部收款地址，并使用所有者的钱包签名。 | 内部转账与区块链提现的处理流程和费用不同。区块链转账可能需要原生代币余额来支付 Gas；购买 Gas 代币是独立操作，请核对来源与目标账户。 ## 外部钱包和硬件钱包 对于只读地址，请使用与该地址连接的外部钱包。连接的账户和网络必须与资金来源一致。支持的签名方式取决于网络、浏览器及设备。通过钱包链接发起的转账可能不会将交易哈希返回 Heth；打开另一个钱包并不能证明已付款。 ## 如果结果不清楚 打开交易记录，检查原操作。不要仅因界面超时或断网就再次转账。请保留操作标识；若状态仍不明确，联系支持。待处理操作不得描述为已完成付款。 [付款问题与状态](troubleshooting.md). ## zh: 付款问题与交易状态 Source: https://docs.heth.me/markdown/zh/user/troubleshooting.md --- title: "付款问题与交易状态" description: "查找 Heth 原付款，核实待处理结果，解决网络、余额及二维码确认问题。" 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` | 阅读原错误并解决原因，再尝试新的操作。 | | No status or an unfamiliar status | 保持结果未确认并请求说明；不要推断成功或失败。 | 退款或冲正是独立结果，应通过原操作及实际入账余额确认。关闭 Heth 并不能取消区块链转账。 ## 余额或收款信息不正确 - 检查账户、资产和网络。内部 Wallet 和 Crypto Account 是不同的收款目标。 - 重新联网后刷新。离线界面可能显示缓存信息。 - 对于外部充值，请将发送钱包中的目标地址及网络与 Heth 的收款信息进行比较。在另一网络上的交易不会自动记入此账户。 - 若其他设备上缺少某个额外冷账户，请重新连接其原始钱包。参见[账户与备份](wallets.md)。 ## 付款人二维码或金额确认无法使用 在 Heth 中打开新的付款人二维码。若应用要求确认码，请按照[付款说明](payments.md)，核对金额并使用当前确认码。二维码不是收据。商户须联网才能处理请求。若应用提示尚未配置确认功能，请在联网状态下先在 Heth 中完成设置。 ## 联系支持 向 [Heth 支持](https://t.me/hethmesupport_bot) 提供交易标识、含时区的大致时间、资产与网络、金额及可见错误。截图中应遮蔽无关个人信息。切勿包含恢复短语、私钥、API 密钥、付款人二维码、礼品卡代码或可重复使用的付款机密。 ## zh: 开始使用并了解钱包 Source: https://docs.heth.me/markdown/zh/user/wallets.md --- title: "开始使用并了解钱包" last_update: date: 2026-10-20 --- # 开始使用并了解钱包 打开 [Heth.me](https://app.heth.me)，创建恢复短语或恢复现有账户，按应用步骤设置 PIN，并在设备支持时启用生物识别解锁。收款前请另行保存恢复短语。参见[账户安全](security.md)。 ## 加密账户和钱包 |项目 |这意味着什么 |如何授权转让 | | --- | --- | --- | | Crypto Account（冷） | 在应用中生成或连接的区块链地址 | 所有者通过本地、外部或受支持的硬件钱包签名。 | |钱包（热门）|用于内部付款和转账的账户余额 |服务处理授权操作| | 只读账户 | 仅添加用于查看的地址，不包含其私钥 | 可查看不代表可支出；须使用已连接的签名钱包。 | 冷账户及其标签可能存储在当前设备上。在其他设备登录时，并不一定恢复您在原设备连接的全部额外账户。请通过各账户所属的原钱包分别备份。 ## 收到资金 1. 开设所需的加密货币帐户或钱包。 2. 核对资产及网络。以太坊网络上的 USDT 与 TRON 网络上的 USDT 使用不同的转账目标。 3. 使用该账户界面显示的收款信息或二维码；不要用区块链地址替代内部钱包标识。 4. 在历史记录中确认入账操作。待处理余额不同于可用资金。 对于通过外部交易所购买的商品，提现前请检查其目的地网络。交换页面提供外部服务的链接；可用性和条款取决于该提供商。 ## 可用资产 使用您帐户显示的资产。全局令牌注册表可以包含您的界面中未启用或未针对特定操作启用的资产。