| Time | Status | User Agent | | | :-- | :-- | :-- | :-- | | Make a request to see history. | #### URL Expired The URL for this request expired after 30 days. subaccountId uuid required configurations object Subaccount network and regional configurations which determine the available networks and geographies during card enrollment. The `countries` property for each network accepts either: - An array of ISO 3166 alpha-3 country codes (e.g. `["USA", "CAN"]`) - The string `"*"` to inherit all countries from the parent account's capabilities for that network When `"*"` is used, the subaccount automatically reflects the parent account's current country list. If the parent account's capabilities change, subaccounts using `"*"` will inherit the updated countries. API responses always return the resolved country list, never the `"*"` literal. The single and bulk enrollment configurations are not required when creating a subaccount, but if not provided they will default to the same country list as the main countries property for that network. The supported card types for single and bulk enrollment is CONSUMER, while the supported funding card types is DEBIT. If not provided, the block rules for both card types will default to the parent account's default block rule for that network and enrollment level. To set the default rule on the parent account, please reach out to your account manager or support. configurationsobject name string verificationPolicy object Admin-managed overrides controlling how card verification is performed for an account or subaccount. Fields are optional and nullable; absent fields leave the current value unchanged, explicit `null` clears an override. verificationPolicyobject enrollmentPolicy object The customer-writable subset of the enrollment policy: the three unified-SDK rails. All other fields (`spinwheelEnabled`, `programBins`, and the deprecated `bulkEnrollmentEnabled`) are managed on the internal enrollment-policy endpoints and are ignored if sent here. Fields are optional and nullable; absent fields leave the current value unchanged, explicit `null` clears the subaccount-level value. A cleared rail falls back to the account-level value when one is set; only when neither level sets the rail does it disappear from reads, letting the host page's client configuration and then the SDK's card-only default apply. enrollmentPolicyobject accept string enum Defaults to application/hal+json Generated from available response content types application/hal+jsonapplication/problem+json Allowed: `application/hal+json``application/problem+json` # ``200 Specified subaccount updated successfully object \_links object required self object required self object accountId uuid required The unique identifier of the account related to this entity. id uuid required The unique identifier of this subaccount entity. name string required The name of this subaccount entity. createdAt date-time required Date and time when this resource was created, in UTC, following ISO 8601 format. updatedAt date-time required Date and time when this resource was last updated, in UTC, following ISO 8601 format. configurations object required Subaccount network and regional configurations which determine the available networks and geographies during card enrollment. VISA object VISA object MASTERCARD object MASTERCARD object AMEX object AMEX object verificationPolicy object Admin-managed card verification policy for this subaccount. Overrides the parent account's policy when set. `null` or absent means no subaccount-level override. stripeValidationLevel string \| null enum Routes card verifications through Stripe at the specified risk tier when set. `null` (or absent) routes through the default TokenEx/IXOPAY (Visa) or TNS (Mastercard) path. Tiers (increasing strictness): - `LOW` — internal-only; 3DS engaged only when risk/regulation requires it; issuer-unsupported soft declines are tolerated. Cannot be self-assigned via this endpoint. - `MEDIUM` — 3DS always requested (challenge preferred); the standard tier to opt into. - `HIGH` — 3DS plus a transient authorization hold (no settled charge) and added fraud signals. - `HIGHEST` — 3DS challenge; if the issuer approves frictionlessly, a two-hold confirmation becomes a mandatory second factor. See the "HIGHEST Verification" guide. Network note: Visa uses Stripe at every set tier; Mastercard uses its network 3DS at all tiers and engages Stripe only at `HIGHEST` (for the two-hold second factor). Resolution: the subaccount value is operative at request time; the account-level value is the inheritance source applied when a subaccount is created, not a live fallback. `HIGHEST``HIGH``MEDIUM``LOW` sandbox boolean \| null Test flag, settable by the customer via `PATCH /subaccounts` (and internally via the verification-policy endpoints). When `true`, card verifications on this subaccount route KNOWN test PANs through the Stripe/TNS sandbox (real cards still go live), and new bank links are created against Plaid Sandbox (Plaid test fixtures only — real bank credentials require the flag off), so an integrator can deterministically test against a provisioned subaccount. Absent / `null` / `false` → live processing only. failedAttemptLockout boolean \| null When `true`, ENFORCE the cross-network attempt lockout for this tenant: a card with too many recent hard verification failures is refused at create (`400``verification.attempts_locked`) before any provider is called. Account-level fallback (set once for all partner subaccounts), overridable per subaccount. Absent / `null` / `false` → not enforced (failures are still recorded; only enforcement is gated). enrollmentPolicy object \| null Enrollment policy for an account or subaccount. Two groups of fields: **Unified-SDK rails** (`cardEnrollment`, `bankEnrollment`, `bulkEnrollment`) — which enrollment options the unified SDK renders. Customer-writable per subaccount via `PATCH /subaccounts/{subaccountId}`; account-level defaults are admin-managed. Rails resolve live per field (subaccount value if set, else account) and reads are SPARSE: only explicitly-configured rail fields are returned — an absent field means "not configured here" and the SDK falls back to the host page's client configuration, then its card-only default. **Admin fields** (`spinwheelEnabled`, `programBins`) — whether the Spinwheel enrollment option is offered, and which card-program BINs identify the customer's program. Managed only on the internal enrollment-policy endpoints. Fields are optional and nullable; absent fields leave the current value unchanged, explicit `null` clears a field. spinwheelEnabled boolean \| null Master gate for offering Spinwheel enrollment. Absent / `null` / `false` → disabled. Resolution: the account-level value is the master switch. A subaccount's stored value only takes effect while the account's is also `true` — subaccount GETs return this **effective** value, not the stored one. Disabling at the account level is non-destructive: stored subaccount values are unchanged, so re-enabling the account automatically restores subaccounts whose stored value is `true`. Setting `true` on a subaccount while the parent account's gate is off is rejected with `400` (no escalation past the account). bulkEnrollmentEnabled boolean \| null deprecated **Deprecated:** superseded by the `bulkEnrollment` tri-state rail (the SDK maps `true` to `suggested`, `false` to `off`, and prefers the tri-state when present). Whether the unified enrollment SDK offers bulk-enrollment steering (BIN eligibility check + bulk feed wizard) for this account/subaccount. `false` = the SDK skips the eligibility check entirely and opens the card form directly (American Express cards pivot to the bank-linking flow). Absent / `null` = not configured — the SDK falls back to the host page's client configuration, then its card-only default (bulk off). Resolution: plain override-fallback — a subaccount value overrides the account value when set (no master gate; unlike `spinwheelEnabled`). An explicit `bulkEnrollment` flag in the SDK's `open()` config wins over this policy. cardEnrollment boolean \| null Unified-SDK rail: offer manual card enrollment (PAN entry + 3DS verification). Resolution: live per-field override-fallback (subaccount value if set, else account). bankEnrollment string \| null enum Unified-SDK rail: offer bank linking. `on` = first-class (chooser tile, any-order linking); `amex-only` = reachable only via the American Express pivot from card entry; `off` = disabled. Resolution: live per-field override-fallback. `off``amex-only``on` bulkEnrollment string \| null enum Unified-SDK rail: offer network bulk-feed enrollment for bulk-capable programs. `suggested` = bulk wizard with a link-just-this-card escape; `forced` = the wizard is the only path for bulk-capable cards; `off` = no bulk routing (direct card form). Supersedes the deprecated `bulkEnrollmentEnabled` boolean; when both are set, the SDK prefers this field. Resolution: live per-field override-fallback. `off``suggested``forced` programBins array of strings \| null The customer's card-program BIN prefixes (tier-2 manual registry), used to match cards to the program during enrollment-option resolution. 6–8 digit numeric strings — both legacy 6-digit and ISO 8-digit prefixes are accepted. Managed via customer onboarding; returned as stored on the subaccount (not resolved against the account). bankLinkingPolicy object Admin-managed bank-linking policy. On reads, fields are the EFFECTIVE values — per-field live resolution against the parent account (subaccount field if set, else account, else `null`). A whole-`null` policy means neither level has one set. The credit-only system default (`accountTypes: [credit]`) is applied downstream at bank-link creation, not materialized in this read. accountTypes array of strings \| null Account types selectable during bank linking. Enforced by the provider at link-token creation (Plaid account_filters: checking/savings → depository subtypes, credit → credit card); institutions offering none of the allowed types are hidden from institution search. Default: `[credit]`. `checking``savings``credit` pinnedInstitutionId string \| null `^ins_[A-Za-z0-9]+$` Provider institution id to pre-select at link creation (e.g. `ins_10` for American Express). NOTE: Plaid's `institution_id` pre-selection is currently rejected on production (`INVALID_INSTITUTION`) — this field is stored and forwarded only behind a provider capability flag; until the provider supports it, institution limiting is achieved with `plaidLinkCustomizationName` plus account-type filtering. plaidLinkCustomizationName string \| null Name of a Plaid Dashboard Link customization to pin on created link tokens (institution shortlist, Account Select mode). The customization must already exist in the Plaid Dashboard — unknown names fail link creation outright. Never client-suppliable; applied via this policy only. # ``400 The server cannot or will not process the request due to something that is perceived to be a client error # ``401 Authentication credentials were either missing or incorrect # ``403 Authentication credentials used do not have have permissions to perform the request # ``404 The requested resource was not found on the server # ``500 The server encountered an unexpected condition that prevented it from fulfilling the request Updated about 2 months ago * * * ShellNodeRubyPHPPython Bearer ``` xxxxxxxxxx curl --request PATCH \ --url https://api.astrada.co/subaccounts/subaccountId \ --header 'accept: application/hal+json' \ --header 'content-type: application/json' ``` ``` xxxxxxxxxx { "_links": { "self": { "href": "/subaccounts/81e7c267-0927-4234-a2bd-78cef799de54" } }, "accountId": "073fe1bb-3350-46ad-b3a6-32afb3780994", "id": "81e7c267-0927-4234-a2bd-78cef799de54", "name": "Subaccount A", "createdAt": "2024-05-01T17:08:43.810Z", "updatedAt": "2024-05-01T17:08:43.810Z", "configurations": { "VISA": { "countries": [\ "USA",\ "CAN"\ ], "single-enrollment": { "countries": [\ "USA"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] }, "bulk-enrollment": { "countries": [\ "CAN"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] } }, "MASTERCARD": { "countries": [\ "USA"\ ], "single-enrollment": { "countries": [\ "USA"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] }, "bulk-enrollment": { "countries": [\ "GBR"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] } }, "AMEX": { "countries": [\ "ITA"\ ], "single-enrollment": { "countries": [\ "ITA"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] }, "bulk-enrollment": { "countries": [\ "SWE"\ ], "blockedCardTypes": [\ "CONSUMER"\ ], "blockedFundingCardTypes": [\ "DEBIT"\ ] } } } }