Skip to main content
Build a seamless, zero-configuration integration between your app and Appstle Memberships. Once connected, your app gets a scoped API token for each merchant — no manual key exchange needed.
Is this the right framework for you? The Partner Integration Framework is for products that connect to Appstle for many merchants, such as helpdesks, CRMs and email platforms. Appstle onboards your product once, and each merchant then approves its connection.If you’re building an app or tool for one store, your own or a client’s, you don’t need to be a partner. Create a regular API key in that store’s Appstle admin instead. It can be Read only, needs no callback URL and works once the store’s plan includes API access. See Creating an API key and Key permissions.
Why become a partner?
  • Frictionless merchant onboarding — merchants approve each connection from their Appstle dashboard
  • No API paywall — merchants don’t need a paid API plan to use your integration
  • Scoped tokens — each merchant gets an isolated API key; revocable at any time
  • Automatic cleanup — when a merchant disconnects or uninstalls, access is revoked instantly

How it works

The Partner Integration Framework uses a secure handshake protocol with two flows. In Flow A, your app sends Appstle a nonce. In Flow B, your app calls initiate-connect, and Appstle sends your app a nonce. Both flows end the same way: the merchant approves the connection in their Appstle dashboard, and your app receives a scoped API token.
Merchant approval: In both flows, the merchant approves the connection on the Partner Connections page in their Appstle dashboard (More → App Integrations & Exports → Partner Connections) before you receive an API token. Until they do, the connection is pending.

Getting started

Step 1: Get onboarded

To get started, reach out to the Appstle team at support@appstle.com with the information below. Our team will set up your partner account and send you your credentials.

What you’ll need to provide

Not sure about some of these? Only the first four fields are required to get started. You can always reach out to support@appstle.com to change your authentication mode or connect mode later.
Not sure which to pick? Start with the defaults, Nonce Handshake + Partner Secret. Your app receives a scoped Appstle API key (apst_...) for each merchant who approves the connection.

API namespaces — what you call vs. what is internal

Three URL namespaces appear in this codebase. As a third-party partner, you only ever call the first one. The others exist for Appstle’s merchant portal and inter-app integrations and are documented here so the surface area is unambiguous: If you see an example referring to /api/integrations/..., it’s an internal Appstle flow and doesn’t apply to your integration.

What you’ll receive

Once onboarded, you’ll receive three values:
Your Partner Secret is shown only once during onboarding. Copy it immediately and store it in a secure location (environment variable, secrets manager, etc.). If you lose it, contact Appstle to rotate it — the old secret will be invalidated immediately.
Store your credentials as environment variables:

Step 1b: Choose your authentication mode

Appstle supports two ways to authenticate partner API calls. Your auth mode is configured during onboarding.

Option A: Partner Secret (default)

The simplest approach. Pass your secret in a header with every request:
That’s it. No computation needed. Good for getting started quickly.

Option B: HMAC-SHA256

A more secure approach where requests are signed with a shared HMAC key. Instead of sending the secret directly, you compute a signature over the request body. HMAC signing works on /disconnect and /status, and on /connect and /initiate-connect in Simple Token Exchange mode. If you use the Nonce Handshake, /connect, /initiate-connect and /verify always take X-Partner-Secret, whichever auth mode you choose. Headers required:
How to compute the signature:
  1. Get the current Unix timestamp (seconds, not milliseconds)
  2. Concatenate the timestamp and the raw JSON request body: timestamp + body. GET /status has no body, so sign the timestamp alone.
  3. Compute HMAC-SHA256 of that string using your HMAC key
  4. Send the hex-encoded result in X-Partner-Signature
Timestamp validation: Appstle rejects requests where the timestamp is more than 5 minutes from the server’s current time. Make sure your server clock is synced (NTP).
Which should I choose?
  • Partner Secret — simpler to implement, fine for most integrations
  • HMAC-SHA256 — signs requests instead of sending your secret, on the endpoints that support it. Recommended for security-sensitive integrations
You can switch modes later by contacting Appstle.

Step 1c: Choose your connect mode

Appstle supports two ways to establish merchant connections. Your connect mode is configured during onboarding.

Option A: Nonce Handshake (default)

The full two-way verification flow described in this guide. Both sides verify each other using a one-time nonce. After the handshake, your app receives an Appstle API key (apst_...) to call Appstle’s External API. Best for: partners who want to read/write data in Appstle (membership contracts, plans, billing, etc.)

Option B: Simple Token Exchange

A streamlined flow where your app sends its own access token to Appstle (or you call initiate-connect, and return your token when Appstle calls your connect endpoint). No nonce, no verify endpoint needed. Appstle stores your token with the connection, but Appstle Memberships doesn’t currently call your API or push data with it. Best for: Connections where your app only needs Appstle to hold a token it issued. Your app can’t call Appstle’s API in this mode, so if you need membership data, use Nonce Handshake. Key difference from Nonce Handshake: In Simple Token Exchange, your app provides its own access token to Appstle and does not receive an Appstle API key. Appstle Memberships doesn’t currently push data to partner apps, so a sync_path isn’t used.
Need membership data in your app? Use Nonce Handshake and call the External API with your apst_ key. For real-time events, the merchant can send webhooks to your endpoint.
How Simple Token Exchange works. Started with connect:
Response:
Your access_token is stored securely but will not be activated until the merchant approves the connection from their Appstle dashboard. Once approved, Appstle calls your /appstle/approved endpoint to confirm (see Handling the approval callback).
Started with initiate-connect: Your app calls POST /api/partner/{id}/initiate-connect with { "shop_domain": "..." }, authenticated the same way as /connect. Appstle then calls your /appstle/connect endpoint with { "shop_domain": "..." }, and your app answers within 5 seconds with:
success must be the JSON boolean true. Appstle stores your token, and your initiate-connect call returns { "status": "pending_merchant_approval" }. The connection then waits for the merchant’s approval, the same as one started with connect, and Appstle calls your /appstle/approved endpoint when the merchant approves. If your answer lacks "success": true or an access_token, the call fails with VERIFICATION_FAILED. If Appstle can’t reach your endpoint, or your endpoint answers with a status other than 2xx, with a body that isn’t a JSON object sent as Content-Type: application/json, or after more than 5 seconds, it fails with PARTNER_UNREACHABLE.
With Simple Token Exchange, your app does NOT receive an Appstle API key. If you also need to call Appstle’s External API, use the Nonce Handshake mode instead.

Step 2: Understand the callback nonce

This section applies to Nonce Handshake mode only. If you’re using Simple Token Exchange, skip to Step 4.
Before implementing, you need to understand the callback nonce — it’s the core security mechanism of the handshake.

What is a callback nonce?

A nonce (number used once) is a random, single-use string that proves both sides of the connection are who they claim to be. It prevents replay attacks and ensures the handshake can’t be forged.

Requirements

How to generate a nonce

Use your language’s cryptographically secure random number generator.
Common mistakes:
  • Math.random().toString(36) — not cryptographically random, predictable
  • uuid.v4() — UUIDs are not designed as security tokens (some implementations use weak RNG)
  • Date.now().toString() — trivially guessable
  • Reusing nonces across multiple connect attempts
Always use your language’s crypto / secrets / SecureRandom module.

How to store a nonce

Store the nonce temporarily, keyed by shop domain, with a 5-minute expiry. Delete it after verification.

Step 3: Implement your endpoints

Appstle calls one endpoint on your app during the handshake: /appstle/verify in Flow A, or /appstle/connect in Flow B. Implement the one for the flow you use. The paths default to /appstle/connect and /appstle/verify but can be customized during onboarding. Each endpoint must:
  • Accept POST requests with a JSON body
  • Return JSON responses
  • Be accessible over HTTPS (Appstle will not call HTTP endpoints)
  • Respond within 5 seconds. After that, Appstle stops waiting and treats the call as failed.
  • Be idempotent. Appstle doesn’t retry these calls, but your endpoints can still get more than one call for the same shop: a merchant can disconnect and reconnect quickly, and when you retry a call to Appstle, Appstle can call your endpoint again. Treat every call as an upsert keyed by (shop_domain, partnerId), never a blind insert. The same rule applies to your /appstle/approved and /appstle/disconnect endpoints described later.

Endpoint 1: POST /appstle/connect

When is this called? Only in Flow B. When your app calls initiate-connect, Appstle calls this endpoint before it answers you. In Simple Token Exchange mode the body is { "shop_domain": "..." } instead (see Step 1c). What does it receive?
What should your app do?
  1. Validate the shop — check that this shop_domain exists in your system. If you don’t recognize the shop, return an error.
  2. Store the nonce and callback URL — save callback_nonce and callback_url associated with this shop_domain. You’ll need them to complete the handshake.
  3. Call back to Appstle — call the callback_url to complete the handshake. Appstle then holds the connection until the merchant approves it, and delivers your API token to your /appstle/approved endpoint. See Completing the handshake below.
  4. Answer within 5 seconds — a 2xx status with no body, or with a JSON object sent as Content-Type: application/json (Express’s res.json() does this), tells Appstle you received the nonce. Any other answer makes your initiate-connect call fail with PARTNER_UNREACHABLE, including a plain-text OK from res.sendStatus(200). If you call callback_url before you answer, as the sample below does, keep the whole handler under 5 seconds.
Node.js (Express)

Endpoint 2: POST /appstle/verify

When is this called? Only in Flow A, while your connect call waits. Appstle is asking your app: “Did you actually send this nonce?” What does it receive?
What should your app do?
  1. Look up the stored nonce for this shop_domain
  2. Compare the callback_nonce from the request against your stored nonce
  3. If they match: delete the stored nonce (it’s single-use) and return { "verified": true }
  4. If they don’t match: return { "verified": false }
Node.js (Express)

Step 4: Implement the connect flow (your dashboard)

Now build the merchant-facing “Connect Appstle Memberships” button in your app’s dashboard.

Your app sends the nonce (Flow A) — step by step

This is the flow where the merchant clicks “Connect Appstle” in your dashboard.
1

Merchant clicks "Connect Appstle" in your dashboard

The merchant initiates the connection from inside your app’s UI.
2

Your app generates a cryptographically random nonce

Store it keyed by shop_domain with a 5-minute TTL.
3

Your app calls POST /api/partner/{id}/connect

Send the shop_domain, the callback_nonce, and your Partner Secret.
4

Appstle validates your Partner Secret

Appstle also confirms the shop has Appstle Memberships installed.
5

Appstle calls YOUR /appstle/verify endpoint

Payload: the shop_domain and the same callback_nonce.
6

Your /appstle/verify checks the nonce

Confirm it matches, delete it, return { "verified": true }.
7

Appstle returns pending_merchant_approval

The connection is pending — no access token has been issued yet.
8

Merchant approves in their Appstle dashboard

They open More → App Integrations & Exports → Partner Connections, click Approve under Pending Requests, then click Approve again to confirm.
9

Appstle creates a scoped API key

The token is POSTed to YOUR /appstle/approved endpoint.
10

Your app stores the access_token

Show “Connected!” to the merchant. You’re done.
Full implementation (Node.js):
curl equivalent:
Success response:
What happens next? The merchant will see your request under Pending Requests on More → App Integrations & Exports → Partner Connections in their Appstle dashboard. That section appears only while a request is waiting. When they click “Approve,” Appstle creates a scoped API key and delivers it to your /appstle/approved endpoint (see Handling the approval callback below). Pending requests expire after 30 days if not acted on.
Deep link to approval screen: You can redirect the merchant directly to the approval screen to minimize friction:
Replace {shop-handle} with the merchant’s store handle (the part before .myshopify.com). This opens the Partner Connections page, where your request is listed under Pending Requests. You can trigger this redirect in your UI immediately after receiving the pending_merchant_approval response.

Appstle sends the nonce (Flow B) — step by step

In this flow, your app calls initiate-connect, and Appstle sends the nonce to your /appstle/connect endpoint. Start it when the merchant asks your app to connect.
1

Your app calls POST /api/partner/{id}/initiate-connect

Send the shop_domain and your Partner Secret.
2

Appstle checks the request

It validates your Partner Secret, then confirms that the shop has Appstle Memberships installed and has no active connection with your app.
3

Appstle generates a nonce (5-min TTL) and calls YOUR /appstle/connect

Payload: shop_domain, app, callback_url, and callback_nonce.
4

Your /appstle/connect stores the nonce and callback_url

Persist them keyed by shop_domain for the verify step.
5

Your app calls the callback_url (Appstle's /verify endpoint)

Send shop_domain, callback_nonce, and your Partner Secret.
6

Appstle verifies the nonce and records a pending connection

The response is { "verified": true, "status": "pending_merchant_approval" }. It has no access_token.
7

Merchant approves in their Appstle dashboard

They approve your request under Pending Requests on More → App Integrations & Exports → Partner Connections, the same as in Flow A. Appstle creates your scoped API key only then.
8

Appstle calls your /appstle/approved endpoint and your app stores the access_token

Connection complete.
Starting the handshake (Flow B)
Success response (Nonce Handshake mode, sent after your /appstle/connect endpoint answers):
Errors use the shape in Error handling: INVALID_REQUEST, TOKEN_INVALID, SHOP_NOT_FOUND, ALREADY_CONNECTED, and PARTNER_UNREACHABLE when your /appstle/connect endpoint can’t be reached, answers with a status other than 2xx or with a body that isn’t a JSON object, or takes longer than 5 seconds.
Completing the handshake (Flow B)
After your /appstle/connect endpoint receives the nonce and callback URL, your app completes the handshake by calling Appstle’s verify endpoint:
Success response:
The response carries no access_token. Appstle creates the API key when the merchant approves the connection, and delivers it to your /appstle/approved endpoint. Failed response (nonce expired or mismatched):
If the store already has an active connection with your app, verify returns 400 with ALREADY_CONNECTED (see Error codes).
Call callback_url within 5 minutes of receiving the nonce. After that the nonce expires, and verify returns { "verified": false }. Call initiate-connect again to get a new one.

Using the API token

After a successful connection, your app has an access_token (prefixed with apst_). In both flows, the token is delivered to your /appstle/approved endpoint after the merchant approves (see Handling the approval callback below). Use this token exactly like a merchant API key — pass it in the X-API-Key header:

Token properties

Available endpoints

Partner tokens grant access to the same External API endpoints as merchant API keys:
  • Membership contracts — GET /api/external/v2/subscription-contract-details (list membership contracts, filter by customer, status, plan)
  • Cancel membership — DELETE /api/external/v2/subscription-contracts/{id} (requires READ_WRITE)
  • Send payment method update email — PUT /api/external/v2/subscription-contracts-update-payment-method (requires READ_WRITE)
  • Apply discount — PUT /api/external/v2/subscription-contracts-apply-discount (requires READ_WRITE)
  • Add discount — PUT /api/external/v2/subscription-contracts-add-discount (requires READ_WRITE)
  • Remove discount — PUT /api/external/v2/subscription-contracts-remove-discount (requires READ_WRITE)
  • Add line item — PUT /api/external/v2/subscription-contracts-add-line-item (requires READ_WRITE)
See the full Integration guide for complete endpoint documentation.

Data sync

Appstle Memberships doesn’t push data to partner apps, and a sync_path set during onboarding isn’t used. To keep your platform in sync, poll the External API with the merchant’s apst_ token, or ask the merchant to send webhooks to your endpoint.

Authentication

When Appstle calls your endpoints, it authenticates using the auth mode configured for your partner:
  • Partner Secret mode: if you gave Appstle an outbound secret during onboarding, every request carries it in the X-Partner-Secret header, so check it on each request. Without an outbound secret, requests carry no auth header.
  • HMAC-SHA256 mode (recommended): Appstle signs every request with X-Partner-Timestamp and X-Partner-Signature headers. Your app should verify the HMAC signature to confirm the request came from Appstle.
Verifying incoming HMAC signatures (Node.js):

Disconnecting

Merchant disconnects from Appstle

Merchants can disconnect your integration anytime from More → App Integrations & Exports → Partner Connections by clicking Disconnect. When they do:
  • Your API token for that merchant is revoked immediately
  • Subsequent API calls will return 401 Unauthorized
  • Appstle sends a disconnect webhook to your app (if you configured a disconnect_path during onboarding — see below)
  • Your app should handle this gracefully and show a “Reconnect” option
Best practice: in your API client, check for 401 responses and update your UI to show the connection as disconnected:

Disconnect webhook (first-class endpoint)

Configure a disconnect_path during onboarding, for example /appstle/disconnect. There’s no default: without one, Appstle skips this call. Appstle calls this when the merchant disconnects your app in their Appstle dashboard, rejects your connection request, or uninstalls Appstle entirely. It doesn’t call it when your app disconnects with /disconnect. You should implement this endpoint for every integration — it is the only reliable signal that the merchant has revoked access on Appstle’s side. Polling 401 responses as a fallback works but lags behind. Request body from Appstle:
If your partner uses HMAC-SHA256 auth, the webhook includes signed headers (X-Partner-Timestamp, X-Partner-Signature) so you can verify it came from Appstle. Your endpoint must:
  1. Look up the connection without filtering on status. Don’t WHERE status = 'active' — if the merchant rapid-clicks disconnect twice, the second call may arrive when the row is already inactive. Find by (shop_domain, partnerId) only.
  2. Revoke the Appstle access token idempotently. If the token is already revoked or absent, return success — don’t error. Revocation must be safe to call repeatedly.
  3. Mark the local connection inactive. Clear or null out the stored Appstle token so subsequent API calls don’t try to use it.
  4. Return 2xx even when there was nothing to do. A no-op disconnect is a successful disconnect from Appstle’s perspective.
This is a best-effort notification — your app should also handle 401 responses from the Appstle API as a fallback signal that the connection was revoked.

Partner disconnects programmatically

Your app can disconnect a merchant using your partner authentication (Partner Secret or HMAC-SHA256):
Response:
If the connection is still waiting for the merchant’s approval, disconnect withdraws your request: it leaves Pending Requests in the merchant’s Appstle dashboard, and GET /status returns not_connected.

Check connection status

GET /api/partner/{partnerId}/status?shop_domain=... is the authoritative source of truth for whether a merchant is connected. If your UI shows a “Connected” badge, derive it from this endpoint — not from whether you happen to have a stored API key locally.
Why this matters: Older integrations sometimes inferred “connected” from the presence of a per-app API key column in their own database. That column is now a deprecated fallback — it can be stale (key revoked on Appstle’s side, your row never updated) and it can’t represent pending_merchant_approval or rejected. Always call /status before showing connection state to the merchant or making business decisions based on it.
Partners can authenticate with their Partner Secret or HMAC signature:
Response (active connection):
Response (pending merchant approval):
All possible status values:
Poll this endpoint every 30–60 seconds after a Flow A connect or a Flow B verify to see when the merchant acts. In Nonce Handshake mode the token reaches you only through your /appstle/approved endpoint: if that call fails, the approval fails and the status stays pending_merchant_approval.

Handling the approval callback

When the merchant approves a connection, in either flow, Appstle calls this endpoint on your server.

Endpoint: POST /appstle/approved

The path defaults to /appstle/approved but can be customized during onboarding (configured as approval_callback_path).
Your /appstle/approved endpoint must accept unauthenticated POST requests from Appstle’s servers. Do not put authentication middleware (e.g., JWT validation, API key checks) on this endpoint — Appstle will not send your app’s auth credentials when calling this callback. If you need to verify the request is from Appstle, use HMAC-SHA256 authentication mode — when enabled, the callback includes signed headers (X-Partner-Timestamp, X-Partner-Signature) you can verify. In Partner Secret mode, the callback carries your outbound secret in X-Partner-Secret if you set one during onboarding.
Request body from Appstle (Nonce Handshake mode):
Request body from Appstle (Simple Token Exchange mode):
If Appstle also issues your app its own access token in Simple Token Exchange mode, an option set during onboarding, this callback carries shop_domain and access_token instead of status, the same body as in Nonce Handshake mode, and the connection becomes active only when your endpoint accepts it.
In Simple Token Exchange mode, your app already provided its own token during the connect call. When Appstle doesn’t also issue your app its own access token, the approval callback only confirms that the connection is now active.
Expected response: answer within 5 seconds with a 2xx status and either no body or a JSON object sent as Content-Type: application/json, for example { "success": true }. Any other answer fails the approval, including a 2xx with a plain-text body such as OK, which is what Express’s res.sendStatus(200) sends. See What if the callback fails? below.
Appstle saves the access token only after your endpoint has answered. Store the token, answer, and only then call the Appstle API with it. A call made with the token from inside your callback handler, before it answers, fails authentication.
If your partner uses HMAC-SHA256 auth, the callback includes signed headers (X-Partner-Timestamp, X-Partner-Signature) so you can verify it came from Appstle.

What if the callback fails?

If your endpoint can’t be reached, doesn’t answer within 5 seconds, answers with a status other than 2xx, or answers 2xx with a body that isn’t a JSON object, the approval fails. Appstle doesn’t save the access token it sent, so that token never works. It leaves the connection pending in Partner Connections and shows the merchant an error with the key PARTNER_UNREACHABLE that asks them to try approving again. After you fix your endpoint, ask the merchant to approve again. Appstle doesn’t retry the callback itself. This applies whenever Appstle sends your app its access token: in Nonce Handshake mode, and in Simple Token Exchange mode when Appstle issues your app its own access token. In Simple Token Exchange mode without one, the connection becomes active whatever your endpoint answers, so a failed callback only means your app isn’t told. Poll GET /api/partner/{id}/status?shop_domain=... until the status is active.

What if the merchant rejects?

If the merchant clicks “Reject,” the connection status changes to rejected and Appstle notifies your app via the disconnect webhook (if configured). Your app should handle this gracefully — show the merchant that the connection was not approved.

Error handling

Partner endpoints return errors in this shape:
Branch on errorKey. title is a readable message that starts with UserGeneratedError:. GET /status without credentials is the one exception: it returns success, error_code and message instead (see the table).

Error codes

Idempotency requirements — recap

Build every endpoint so that the same call arriving twice leaves the same end state. Concretely:
  • Connect / approval callbacks: upsert by (shop_domain, partnerId). When /appstle/approved arrives again for a shop, replace the stored token with the new one in the same row. A token from a failed approval never works.
  • Disconnect callback: find the connection without filtering on status; revoke tokens idempotently; return 2xx even when there is nothing to do.
  • Status reads: safe by definition — no side effects.
If your code assumes each endpoint hears about a shop only once, expect bugs the first time a merchant disconnects and reconnects quickly, or you retry a call to Appstle and Appstle calls your endpoint again.

Security checklist

Before going live, verify all of these:
  • Partner Secret / HMAC key is stored in environment variables or a secrets manager — not hardcoded in source code
  • Nonces are generated using a cryptographically secure random generator (crypto.randomBytes, secrets.token_hex, SecureRandom, etc.)
  • Nonces are stored with a TTL (≤ 5 minutes) and deleted after verification
  • Nonces are compared using a constant-time comparison to prevent timing attacks (most frameworks do this by default for string equality)
  • Endpoints are served over HTTPS — Appstle will not call HTTP endpoints
  • shop_domain is validated in your /appstle/connect and /appstle/verify endpoints — reject domains you don’t recognize
  • Access tokens are stored encrypted at rest (or in a secrets manager)
  • 401 responses are handled gracefully — show a “Reconnect” option, don’t break silently
  • Error responses from Appstle are logged for debugging
  • (HMAC only) Server clock is synced via NTP — timestamps more than 5 minutes off will be rejected
  • (If using disconnect webhook) Your /appstle/disconnect endpoint cleans up stored tokens and marks the connection as inactive

Complete example: partner-initiated flow (Node.js)

Here’s a full, copy-pasteable implementation of both flows in Express:

Complete example: partner-initiated flow (Python)

FAQ

Yes. Each partner gets its own scoped API token. Merchants can connect as many partners as they want. The tokens are completely independent.
All active partner connections for that shop are automatically disconnected. Your tokens will stop working (401 responses).
Yes — contact the Appstle team. New connections will use the updated permission, but existing connections keep their original permission until reconnected.
Partner tokens share the same rate limits as regular API keys. If you receive a 429 Too Many Requests, implement exponential backoff.
Use a Shopify development store with Appstle Memberships installed. The connection flow works the same in development and production. You can use a tool like ngrok to expose your local endpoints to the internet for testing.To choose a paid plan on a development store, first email support@appstle.com with the store’s myshopify.com domain, and choose the plan after Appstle confirms. Appstle sets the store up so that the plan is a Shopify test charge and no real money moves.
Start the connection again. In Flow A, generate a new nonce and call connect again. In Flow B, call initiate-connect again, and Appstle sends a new nonce. An expired nonce can’t be used.
No. Implement the flow you use. Flow A needs your /appstle/verify endpoint, and Flow B needs your /appstle/connect endpoint. Both need your /appstle/approved endpoint, where the API token arrives after the merchant approves.
No. Every new connection waits until the merchant approves it in their Appstle dashboard. This is by design — merchants must explicitly authorize each connection.
For security and trust. The approval step ensures that merchants consciously grant each partner app access to their store.
Pending connection requests expire after 30 days. If the merchant doesn’t approve or reject within that window, the request expires and your app will need to initiate a new connection. To withdraw a request sooner, call /disconnect.
The status changes to rejected and your app is notified via the disconnect webhook (if configured). The merchant can be asked to reconnect later if they change their mind — your app can initiate a new connection request.

Need help?