# Accounts Source: https://docs.waycore.com/accounts Read bank account details and balances An **Account** represents a single bank account discovered on a [Connection](/connections). Accounts are read-only and are created automatically as Waycore activates and syncs a connection. ## Account types today The public API uses the canonical account type enum: `checking` · `savings` · `moneyMarket` · `creditCard` · `loan` · `investment` · `wallet` · `other` · `unknown` ## Current balance fields | Field | Description | | ------------------ | -------------------------------------------------------------------- | | `currentBalance` | Current ledger balance as reported by the bank. | | `availableBalance` | Funds available to spend (may differ for pending items). | | `balanceAsOf` | Timestamp of the balance snapshot. | | `updatedAt` | Best-effort timestamp for the current public account representation. | Balance values are signed decimal strings (e.g. `"1234.56"`). They may be `null` if the institution does not expose them. ## Daily balance history Use `GET /v1/balances` when you need date-indexed balance rows for reconciliation, reporting, or cash position views. The endpoint returns projected balances visible to your API key, ordered by `date desc, accountId asc`. Each balance row belongs to an account, connection, and entity, and includes: | Field | Description | | ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | | `date` | Balance date. | | `ledgerBalance` | End-of-day posted/current ledger balance for that date. | | `postedTransactionDelta` | Sum of posted transaction amounts on that date. Pending transactions are excluded. | | `source` | `bankProvided` when the balance came from bank data; `derived` when Waycore computed it from an observed balance anchor and posted transactions. | | `updatedAt` | When the projected public balance row last changed. | Balance rows are mutable projections. After a connection sync or transaction backfill, call `GET /v1/balances` again for the date ranges you care about instead of treating previously fetched rows as immutable ledger snapshots. Filter balances by `entityId`, `connectionId`, `accountId`, `dateGte`, `dateLt`, and `updatedAtGte`. Use `cursor` and `limit` to page through larger ranges; cursors are valid only with the same query filters. For incremental restatement ingestion, bootstrap normally, then poll with `updatedAtGte`. When `updatedAtGte` is supplied, rows are ordered by `updatedAt asc, accountId asc, date asc`. Follow every page, upsert by `(accountId, date)`, and expect duplicate rows at the saved watermark because the lower bound is inclusive. ## Payment identifiers Accounts expose canonical routing details through `paymentIdentifiers`. Each identifier is typed by `scheme`, and all bank account values are strings so leading zeros are preserved. Current schemes include: | Scheme | Details | | ----------------------------- | ---------------------------------------------------------------- | | `us_ach` | US routing number and account number. | | `uk_sort_code_account_number` | UK sort code and account number. | | `ca_eft` | Canadian institution number, transit number, and account number. | | `au_bsb_account_number` | Australian BSB and account number. | | `iban` | IBAN and optional BIC. | Example: ```json theme={null} { "paymentIdentifiers": [ { "scheme": "us_ach", "countryCode": "US", "currency": "USD", "details": { "routingNumber": "011000015", "accountNumber": "000123456789" } } ] } ``` `accountNumber` is the best available account identifier when known. It may be a domestic account number or another provider-supplied identifier such as an IBAN. Use `paymentIdentifiers` for canonical payment-ready details. The legacy flat fields `routingNumber` and `swiftBic` are deprecated and always return `null`. Use `paymentIdentifiers` for routing and BIC details when available. ## Filtering `GET /v1/accounts` supports filtering by `connectionId`, `entityId`, `type`, `currency`, and `status`. The `type` filter uses the same canonical account type enum shown above. Use `fields=` to request a sparse fieldset and reduce payload size. ## Endpoints ## Required scopes | Scope | Used by | | --------------- | ----------------------------------------- | | `accounts:read` | List accounts, get account, list balances | # Get Account Source: https://docs.waycore.com/api-reference/accounts/get-account /openapi.json get /v1/accounts/{accountId} Canonical account fetch endpoint for API token integrations. Returns `404 not_found` when the account does not exist or is not visible to the authenticated API token on Waycore's public API surface. # List Accounts Source: https://docs.waycore.com/api-reference/accounts/list-accounts /openapi.json get /v1/accounts Canonical account browse endpoint for API token integrations. Returns only accounts visible to the authenticated API token on Waycore's public API surface. # List Balances Source: https://docs.waycore.com/api-reference/balances/list-balances /openapi.json get /v1/balances Daily account balance browse endpoint for API token integrations. Returns projected balances visible to the authenticated API token, ordered by `date desc, accountId asc`. Balances are mutable: call this endpoint again for the date ranges you care about after transaction syncs. To ingest restatements incrementally, bootstrap normally, then poll with `updatedAtGte`; when `updatedAtGte` is supplied, rows are ordered by `updatedAt asc, accountId asc, date asc`. Follow every page, upsert by `(accountId, date)`, and expect duplicate rows at the saved watermark because the lower bound is inclusive. # Complete Connection Setup Source: https://docs.waycore.com/api-reference/connections/complete-connection-setup /openapi.json put /v1/connections/{connectionId}/setupCompletion Mark the external delegated-user bank setup as complete. This endpoint is intentionally narrow and carries no credential fields. # Create Connection Source: https://docs.waycore.com/api-reference/connections/create-connection /openapi.json post /v1/connections Create or return a public connection using either a supported `institutionId` or a raw `portalUrl`. New connections return setup instructions when onboarding is still required. # Delete Connection Source: https://docs.waycore.com/api-reference/connections/delete-connection /openapi.json delete /v1/connections/{connectionId} Delete a public connection. Invoking this endpoint performs a hard delete of the connection plus any accounts and transactions tied to it. # Get Connection Source: https://docs.waycore.com/api-reference/connections/get-connection /openapi.json get /v1/connections/{connectionId} Canonical connection fetch endpoint for public API clients. Returns `404 not_found` when the connection does not exist, is not available through this API, or is not visible to the authenticated principal. # List Connections Source: https://docs.waycore.com/api-reference/connections/list-connections /openapi.json get /v1/connections Canonical connection browse endpoint for public API clients. Returns connections visible to the authenticated principal. Results are ordered newest first. # Sync Connection Source: https://docs.waycore.com/api-reference/connections/sync-connection /openapi.json put /v1/connections/{connectionId}/sync Queue an asynchronous sync for a ready connection. Returns `409 conflict` when the connection is still in setup or a sync is already in progress. Returns `429 rate_limited` when a sync was triggered recently and is still in cooldown. # Update Connection Credentials Source: https://docs.waycore.com/api-reference/connections/update-connection-credentials /openapi.json put /v1/connections/{connectionId}/credentials Provide the current working bank credentials for a connection. This is the public credential handoff endpoint for setup-stage onboarding flows. The password is accepted but never echoed back. # Create Entity Source: https://docs.waycore.com/api-reference/entities/create-entity /openapi.json post /v1/entities POST /v1/entities Create a canonical entity for the authenticated organization. # Delete Entity Source: https://docs.waycore.com/api-reference/entities/delete-entity /openapi.json delete /v1/entities/{entityId} Delete a canonical entity. Invoking this endpoint performs a hard delete of the entity plus any owned connections and related data, including linked accounts and transactions. # Get Entity Source: https://docs.waycore.com/api-reference/entities/get-entity /openapi.json get /v1/entities/{entityId} GET /v1/entities/{entityId} Get a canonical entity for the authenticated organization. # List Entities Source: https://docs.waycore.com/api-reference/entities/list-entities /openapi.json get /v1/entities GET /v1/entities List canonical entities for the authenticated organization. # Update Entity Source: https://docs.waycore.com/api-reference/entities/update-entity /openapi.json patch /v1/entities/{entityId} PATCH /v1/entities/{entityId} Update the contact emails for a canonical entity. The supplied list replaces the existing one. # Get Institution Source: https://docs.waycore.com/api-reference/institutions/get-institution /openapi.json get /v1/institutions/{institutionId} GET /v1/institutions/{institutionId} Get a single supported institution by identifier. # List Institutions Source: https://docs.waycore.com/api-reference/institutions/list-institutions /openapi.json get /v1/institutions GET /v1/institutions List or search supported institutions for public connection creation. # Get Transaction Source: https://docs.waycore.com/api-reference/transactions/get-transaction /openapi.json get /v1/transactions/{transactionId} GET /v1/transactions/{transactionId} Get a single canonical transaction for customer API clients. # List Transactions Source: https://docs.waycore.com/api-reference/transactions/list-transactions /openapi.json get /v1/transactions Canonical transaction browse and reconciliation endpoint for building a current mirror. This endpoint is not a snapshot-consistent export: pages may reflect changes that happen while you are backfilling. For a no-gap bootstrap, call `GET /v1/transactions/sync` without a cursor and save `nextCursor`, then backfill with this endpoint, then poll `GET /v1/transactions/sync` from the saved cursor. Duplicates between backfill and later sync calls are expected; reconcile by stable `transaction.id`. # Sync Transactions Source: https://docs.waycore.com/api-reference/transactions/sync-transactions /openapi.json get /v1/transactions/sync Incremental transaction changefeed for maintaining a current mirror, not an immutable history log. For a no-gap bootstrap, call this endpoint without a cursor and save `nextCursor`, then backfill with `GET /v1/transactions`, then poll from the saved cursor. Responses are ordered by the server's sync cursor ascending and act as a convergence-safe stream: reusing the same cursor later returns the then-current ordered suffix after that cursor, not a byte-for-byte replay of an earlier page. Persist `nextCursor` only after the full page has been durably applied. Clients should upsert both `added` and `modified`, delete on `removed`, and call again immediately with `nextCursor` while `hasMore` is true. Duplicates between the backfill and later sync calls are expected. Cursors are valid only for the same stream-defining filters, expire after 90 days, and return `invalid_cursor` for malformed or filter-mismatched cursors or `cursor_expired` when the client must rebootstrap. If rate limited, honor `Retry-After` when present and retry with the same cursor. Under the current product model, sync events are transaction-write driven: `removed` is emitted for transaction deletions, and account visibility changes without transaction mutations are intentionally out of scope. # Create Transfer Source: https://docs.waycore.com/api-reference/transfers/create-transfer /openapi.json post /v1/transfers POST /v1/transfers Create an internal transfer or external payment for the authenticated organization. # Get Transfer Source: https://docs.waycore.com/api-reference/transfers/get-transfer /openapi.json get /v1/transfers/{id} GET /v1/transfers/{id} Get a transfer for the authenticated organization. # List Transfers Source: https://docs.waycore.com/api-reference/transfers/list-transfers /openapi.json get /v1/transfers GET /v1/transfers List transfers for the authenticated organization ordered by `createdAt desc, id desc`. # Retry Transfer Source: https://docs.waycore.com/api-reference/transfers/retry-transfer /openapi.json post /v1/transfers/{id}/retry POST /v1/transfers/{id}/retry Retry a failed or retryable transfer for the authenticated organization. # Create Webhook Source: https://docs.waycore.com/api-reference/webhooks/create-webhook /openapi.json post /v1/webhooks Register a new webhook endpoint to receive event notifications. The response includes the HMAC-SHA256 signing `secret` in full; it is masked on subsequent reads. Access requires a machine API key with `webhooks:write` scope for the bound organization. Current producers emit `transactions.sync_available` and `connection.status_changed`, and `test` can be triggered explicitly via the API. The remaining spec-defined event types are reserved for upcoming producers. # Delete Webhook Source: https://docs.waycore.com/api-reference/webhooks/delete-webhook /openapi.json delete /v1/webhooks/{webhookId} Delete a webhook registration. Access requires a machine API key with `webhooks:write` scope for the bound organization. Current producers emit `transactions.sync_available` and `connection.status_changed`, and `test` can be triggered explicitly via the API. The remaining spec-defined event types are reserved for upcoming producers. # Get Webhook Source: https://docs.waycore.com/api-reference/webhooks/get-webhook /openapi.json get /v1/webhooks/{webhookId} Get a single webhook registration visible to the authenticated machine principal. Access requires a machine API key with `webhooks:read` scope for the bound organization. Current producers emit `transactions.sync_available` and `connection.status_changed`, and `test` can be triggered explicitly via the API. The remaining spec-defined event types are reserved for upcoming producers. # List Webhooks Source: https://docs.waycore.com/api-reference/webhooks/list-webhooks /openapi.json get /v1/webhooks List webhook registrations visible to the authenticated principal. Results are ordered newest first. Access requires a machine API key with `webhooks:read` scope for the bound organization. Current producers emit `transactions.sync_available` and `connection.status_changed`, and `test` can be triggered explicitly via the API. The remaining spec-defined event types are reserved for upcoming producers. # Trigger Test Webhook Source: https://docs.waycore.com/api-reference/webhooks/trigger-test-webhook /openapi.json post /v1/webhooks/{webhookId}/test Queue a synthetic `test` event for a single webhook registration. Access requires a machine API key with `webhooks:write` scope for the bound organization. The webhook must be active and subscribed to `test`. # Update Webhook Source: https://docs.waycore.com/api-reference/webhooks/update-webhook /openapi.json patch /v1/webhooks/{webhookId} Update a webhook registration. Only provided fields are changed. Access requires a machine API key with `webhooks:write` scope for the bound organization. Current producers emit `transactions.sync_available` and `connection.status_changed`, and `test` can be triggered explicitly via the API. The remaining spec-defined event types are reserved for upcoming producers. # Changelog Source: https://docs.waycore.com/changelog Notable product updates and customer-facing changes. * Published a [vulnerability disclosure policy](/security/vulnerability-disclosure) with `security@waycore.com` as the intake. * Added a dedicated [Support](/support) page describing how customers can reach us. * Documented the [data deletion request procedure](/legal/privacy-policy#10a-how-to-request-deletion) in the Privacy Notice, including required information and a 30-day completion target. * Added `GET /v1/balances` for retrieving account balances independently of transactions. See the [API Reference](/api-reference). * Documented connection lifecycle states `cooldown` and `invalidConfig`, including when each is emitted and how to recover. See [Connections](/connections). * Published an [aggregators vs. Waycore](/intro/aggregators-vs-waycore) comparison and refreshed [pricing](/pricing/plans). # Connections Source: https://docs.waycore.com/connections Onboard and manage entity-owned bank connections In the API, a **Connection** is the technical resource that represents one entity’s delegated-user workspace at a bank. It is scoped to the authorized bank portal or institution, and it is the parent resource for accounts, balances, transactions, statements, workflow events, and execution-support activity. The word Connection is an API resource name, not the category claim. Waycore is not a traditional bank API rail, aggregator, or account-access network. It is a universal commercial banking API adapter that operationalizes the bank workspace authorized by the business. Before you create a connection, you need: 1. An owning entity from [Entities](/entities) 2. Either an `institutionId` from [Institutions](/institutions) or a bank `portalUrl` That input becomes the payload for `POST /v1/connections`. A bank does not need to appear in `/v1/institutions` before you can start onboarding it. If it is not listed, create the connection with `entityId` plus `portalUrl`; Waycore returns a setup-stage connection and delegated-user instructions while support is added. ## Connection kinds | Kind | Meaning | | ------- | --------------------------------------------------------------------------------------- | | `setup` | A setup-stage connection that still needs delegated-user onboarding or activation work. | | `ready` | A live connection that can surface accounts and transactions and can be synced. | `POST /v1/connections` returns a `ConnectionResource`, which may be either `kind="setup"` or `kind="ready"`. New connections return setup details when delegated-user onboarding is still required. Existing connections may be returned directly with `200 OK`. When a new connection returns `kind="setup"`, the current `setup.instructions` payload is included immediately on that first `POST /v1/connections` response. Integrators can surface the returned email, username, phone number, and related setup details without waiting for a separate provisioning poll. ## Creation modes You can create or return a connection in two ways: | Input mode | When to use it | | --------------- | --------------------------------------------------------------------------------------------- | | `institutionId` | Use when the bank is already in the public catalog. | | `portalUrl` | Use when the bank is not in the catalog yet, or when you are starting from a bank portal URL. | If an institution is already supported but has multiple login portals, you can pass `portalUrl` alongside `institutionId` to anchor the connection to the correct portal. ## Setup lifecycle 1. **Create or return the connection** with `POST /v1/connections` using `entityId` plus either `institutionId` or `portalUrl`. 2. **If the response is `kind="setup"`**, show the setup details returned on the `setup` object to the end user or your operations team. 3. **Provide credentials** with `PUT /v1/connections/{connectionId}/credentials`. 4. **Mark setup complete** with `PUT /v1/connections/{connectionId}/setupCompletion` once the bank-side delegated user is ready. 5. **Poll or fetch the connection** with `GET /v1/connections/{connectionId}` until it transitions to `kind="ready"`. In normal steady state, the connection status will then be `active`. 6. **If the response is already `kind="ready"`**, start reading data or queue a sync immediately. From the integrator's perspective, `setupCompletion` hands control back to Waycore to finish activation. The initial historical data sync starts automatically as part of bringing the connection online. ## Status lifecycle | Status | Meaning | | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `draft` | The setup-stage connection exists, but onboarding inputs are still incomplete. | | `pendingActivation` | Bank-side setup is complete and Waycore is validating or activating the connection. | | `active` | Syncing normally. | | `reauthRequired` | Credentials or bank authentication need attention before sync can continue. | | `errored` | A recoverable issue is preventing sync. Waycore will address and retry automatically. | | `invalidConfig` | Connection configuration is invalid and needs correction before normal operation can resume. | | `paused` | Syncing has been intentionally suspended by the Waycore team, usually during a new version release or an active bug investigation. API read endpoints continue to work as expected during this period. | | `revoked` | Access has been removed. No further syncs will occur. | When a connection changes status, Waycore can notify you via the [`connection.status_changed`](/webhooks) webhook. ## Setup-stage fields * **`institutionId`** — Waycore's canonical identifier for the institution, when already known. * **`portalUrl`** — Normalized portal URL used as the connection anchor, when available. * **`setup.instructions`** — Structured delegated-user profile details, such as name, username, address, email, phone number, and provisioning statuses. * **`setup.credentialsPresent`** — Whether working credentials have already been submitted. * **`setup.nextAction`** — The next step in the setup flow, such as `createDelegatedUser`, `provideCredentials`, or `activateConnection`. * **`setup.actionRequiredBy`** — Who needs to do the next step: the end user, the integrator, or Waycore. * **`errorCode` / `errorMessage`** — Present when the setup-stage connection has a surfaced configuration or activation issue. ## Ready-connection fields * **`entityId`** — Stable identifier for the business that owns the connection. * **`portalUrl`** — Normalized portal URL used as the connection anchor, when available. * **`lastSyncedAt`** — When data was last successfully refreshed. Useful for freshness indicators once the connection is ready. * **`errorCode` / `errorMessage`** — Present when the connection has degraded or needs reauthentication. ## Listing and filtering `GET /v1/connections` returns results newest first and supports filtering by: * `status` * `institutionId` * `entityId` Use `GET /v1/connections/{connectionId}` to fetch the latest shape for a single connection during setup or after activation. ## Syncing `PUT /v1/connections/{connectionId}/sync` queues an asynchronous sync for a `kind="ready"` connection and returns `202 Accepted` when the job is queued. After any sync is triggered for a connection, whether by API request or by a scheduled portal job, the connection enters a 45-minute cooldown. During that cooldown, additional manual sync requests return `429 Too Many Requests`. Honor `Retry-After` when present before retrying the same request. Expect `409 Conflict` when: * The connection is still in setup * A sync is already in progress Expect `429 Too Many Requests` when: * A sync was triggered recently and the connection is still in cooldown Use the [Webhooks](/webhooks) page for the event-driven model around `transactions.sync_available`. ## Deleting a connection `DELETE /v1/connections/{connectionId}` performs a hard delete of the public connection plus any accounts and transactions tied to it. Use it carefully: * The delete is destructive. * Downstream mirrors should treat the connection and all associated records as removed. * You may receive `409 Conflict` when the connection cannot currently be represented through the requested public contract. ## Endpoints ## Required scopes | Scope | Used by | | ------------------- | -------------------------------------------------------- | | `connections:write` | Create, update credentials, complete setup, sync, delete | | `connections:read` | List, get | # Coverage Source: https://docs.waycore.com/coverage Waycore is designed for commercial-bank workflows whether or not a bank offers a usable API. If the account owner can create an appropriate delegated user or authorized portal profile, Waycore can usually turn that bank workspace into a programmable interface for the business itself or for the software provider serving it. **Coverage is not limited to a predefined list of institutions.** Commercial bank accounts can often be supported through delegated access. Simple portals are typically brought live within **4–8 hours** from the moment access is enabled; complex portals that are not currently supported are typically brought live within **48 hours**. Operational promise: already-supported bank workspaces are typically activated same day, often in under eight hours after delegated access is enabled. Newly requested bank portals are typically brought live in about forty-eight hours once the required bank-side access is available. The system is designed to operate across a wide range of environments, including banks with complex authentication and inconsistent interfaces. *** ## What “supported” includes For supported accounts, Waycore provides: * Retrieval of balances, transactions, and statements * Normalization into a consistent data model * Payment workflow preparation (where applicable) * Audit logs of access and actions Capabilities may vary slightly depending on the constraints of each bank, but the system is designed to adapt across environments. *** ## How new banks are supported 1. A delegated user is created by the account owner 2. Access is validated and the environment is assessed 3. A connection layer is deployed 4. Data and workflows are verified in production This process is repeatable across institutions and does not require prior integration work. *** # Entities Source: https://docs.waycore.com/entities Model the businesses that own connections and data An **Entity** is the ownership boundary for the public API. Every connection belongs to exactly one `entityId`, and the accounts and transactions discovered through that connection inherit the same ownership. Use entities to model the businesses, funds, subsidiaries, or customers you manage through Waycore. ## Why entities come first Before you create a connection, you need: 1. An owning entity from `GET /v1/entities` or `POST /v1/entities` 2. Either a target institution from `GET /v1/institutions` or a raw bank `portalUrl` That entity then becomes the owner in `POST /v1/connections`. ## Default org entity vs customer entities | Entity type | When to use it | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | **Default org entity** | Use the Waycore-managed default entity when the integrator and the end business are the same organization. | | **Customer entity** | Create your own entity records when you need separate ownership boundaries for customers, subsidiaries, SPVs, or operating companies. | The `isDefaultOrgEntity` flag tells you whether an entity is the special organization-attached default. ## Key fields * **`entityId`** — Stable Waycore identifier used throughout the API. * **`externalEntityId`** — Your own stable identifier for the business. This is the best key to use when mapping back to your system. * **`name`** — Human-readable display name. * **`contactEmails`** — Email addresses for people who manage this entity's connections. * **`metadata`** — Opaque key-value data for your own routing and bookkeeping. ## When to create a new entity Create a new entity when you need a separate ownership boundary for: * A new customer * A new legal entity or fund * A new business unit that should have its own bank connections * A separate reconciliation or access-control boundary in your product If the same business owns multiple bank connections, reuse the same entity across those connections. ## Contact emails Use `contactEmails` to tell Waycore who manages an entity's bank connections. Waycore uses these addresses to reach the right people when a connection has invalid configuration or needs attention. You can provide contact emails when creating an entity. To replace the list later, call `PATCH /v1/entities/{entityId}` with the full replacement list. Send an empty array to clear all contacts. ## Listing and filtering `GET /v1/entities` supports filtering by `externalEntityId`. Results are cursor-paginated and return the canonical entity records visible to your organization. ## Deleting an entity `DELETE /v1/entities/{entityId}` performs a hard delete of the entity plus its owned public connections and related data, including linked accounts and transactions. Important caveats: * Organization-managed default entities cannot be deleted. * You may receive `409 Conflict` while one of the entity's connections is syncing. * This is a destructive operation for the entity's full public data footprint. ## Endpoints ## Required scopes | Scope | Used by | | ---------------- | ---------------------- | | `entities:read` | List, get | | `entities:write` | Create, update, delete | # Commercial & Billing Source: https://docs.waycore.com/faq/commercial This section explains how Waycore is priced and how that pricing maps to real-world usage. The goal is not just to describe mechanics, but to clarify the economic model behind the service; what drives cost, how it scales, and how to reason about it as a long-term production system. ## Pricing model A delegated user is a single, persistent authenticated session to one bank portal on behalf of one entity. If your company has accounts at Chase and Bank of America, that is two delegated users. If you have accounts at two separate Chase entities (e.g., two different legal entities), that is also two delegated users. No. A delegated user refers to a portal login with access permissions, not to each individual bank account. If a single delegated user can access 50 accounts within one portal, that is billed as one delegated user. You are not charged separately for each of the 50 accounts. Because the operational unit is the **authenticated bank user session**, not each account. One delegated user can cover dozens of accounts, but still requires a single maintained connection, permission model, and MFA handling. Bank complexity, authentication type, and ongoing operational load. A simple email-MFA bank is not equivalent to an app-token or multi-step approval environment. Data aggregators provide best-effort, read-only access to retail and simple SMB accounts. They are limited to a fixed catalog of supported institutions, and do not specialize in commercial banking. They lack near real-time data, which is a structural requirement for any execution workflow, and they lack support for critical treasury features and transaction types. When connections break, developer support is often a ticket-based system that can take months to resolve. Waycore provides a single integration that works across **any bank**, **anywhere in the world**, so long as the institution supports delegated user access. New banks are onboarded on demand, typically within hours, without requiring a new integration. On top of that, Waycore delivers near real-time data, deterministic execution across complex commercial bank portals, native support for those treasury features, and a human-in-the-loop service layer that proactively maintains continuity when bank portals change. The relevant comparison is not against an aggregator's per-call pricing. It is against the fully-loaded cost of manual portal work, broken workflows, and the implementation drag that occurs when standard APIs fail to cover the commercial accounts your platform actually needs. See [What the alternative really costs](/pricing/cost-of-the-alternative). Standard portals use common authentication methods that are relatively straightforward to support and recover in operations, such as email OTP, SMS codes, phone-call verification, and app-based 2FA like Duo or Google Authenticator. Complex portals rely on authentication methods that create more operational overhead or tighter session constraints, such as RSA SecurID, mobile app soft tokens, device-bound approval flows, or other non-standard authentication and session controls. ## Volume discounts Yes. Pricing is designed to decline at scale, reflecting shared infrastructure and operational efficiencies across large deployments. Typically through tiered or marginal discounts as the number of active delegated users increases. Exact breakpoints depend on the partner and use case. Because usage drives real operational cost. At the same time, larger partners create efficiencies, so pricing should reward scale without breaking unit economics. Yes. Platform partners (e.g., ERPs, accounting firms) may have custom commercial structures, including volume tiers or bundled pricing. ## Commercial terms The platform fee covers access, tooling, and base support. Usage fees scale with active delegated users, which is the core unit of work. No. The sandbox is for testing. Production pricing reflects live-bank reliability and operations. Billing tracks active delegated users. If a user is deactivated, it is no longer billed. Typically yes for platform partners, to justify onboarding and support investment. Terms vary by agreement. *** ## Ready to get started? Discuss your specific bank coverage requirements, get a custom quote, or learn more about the Pioneer Program. Read the full API reference, explore the sandbox, and start building your integration today. # Compliance & Ops Source: https://docs.waycore.com/faq/compliance This section answers the main questions about how Waycore works and how it fits within bank and regulatory frameworks. ## Company & category Waycore is outsourced treasury at the scale and flexibility of software. We combine software with a controlled service layer so teams can get reliable access to balances, transactions, statements, and payment-maker workflows across commercial banks, including the many institutions and workflows that are hard to integrate directly. The right mental model is not “AI inside your bank accounts.” The right mental model is tech-enabled outsourced treasury with strong controls. The bank remains the sole custodian of funds, the sole processor of payment instructions, and the sole enforcer of transaction controls. It is outsourced treasury at the scale and flexibility of software. Waycore is not an Account Information Service Provider (AISP), Payment Initiation Service Provider (PISP), or any other category of regulated payment service provider under PSD2, the UK Payment Services Regulations 2017, or equivalent frameworks. We are not registered with the FCA, any EU national competent authority, or FinCEN, and **we are not required to be**. AISPs and PISPs access bank accounts through open banking APIs (the PSD2 "dedicated interface" or XS2A channel) using their own regulatory credentials. The bank does not choose to admit them. The regulator compels the bank to grant access. The AISP or PISP stands between the account holder and the bank as a licensed third party. Waycore does none of this. The end customer instructs their bank to create a dedicated delegated user inside the bank's own corporate portal, with permissions the customer defines and the bank enforces. This is the same model that has existed in corporate banking for decades: a company appointing an external bookkeeper, treasury bureau, or accounting firm to operate its bank accounts under a limited mandate. Waycore delivers this as programmable infrastructure rather than manual labour. The regulatory character of the arrangement does not change because the operator is software-assisted rather than purely human. In PSD2 terms, Waycore falls within the exclusion for technical service providers under Article 3(j) of Directive 2015/2366 and paragraph 2(j) of Schedule 1, Part 2 of the UK Payment Services Regulations 2017. These provisions exclude from the scope of payment services any service that supports the execution of payment transactions without the provider entering into possession of the funds at any point. No. Waycore is not a money transmitter, money services business (MSB), or any other category of regulated financial services provider under federal or state law. We are not registered with FinCEN as an MSB, we do not hold money transmitter licenses in any state, and **we are not required to**. Money transmission, as defined under the Bank Secrecy Act and FinCEN's implementing regulations at 31 CFR 1010.100(ff), requires the acceptance and transmission of currency or funds, or the maintenance of control over currency or funds. State money transmitter statutes, while varying in their exact language, follow the same core principle: the regulated activity is receiving, holding, or transmitting someone else's money. Waycore does none of this. At no point in the transaction lifecycle does Waycore receive, hold, control, or redirect customer funds. Funds never pass through any Waycore account, system, or intermediary. Every payment instruction that Waycore submits is executed by the customer's own bank, from the customer's own account, through the bank's own portal, using credentials the bank itself issued to a delegated user the customer created. ## Bank permissioning & terms of use Yes. Waycore is designed around the permissioning model banks already use: dedicated users, unique credentials, bank-enforced permissions, and auditability. This is not an exotic concept. Bank of America explicitly says businesses can allow “trusted employees or an accountant” to manage banking tasks, with unique IDs and varying levels of access, including payment permissions. Wells Fargo says businesses can review access added for an employee, bookkeeper, or accountant. Chase supports entitling users for third-party app access and managing exactly which accounts and data are shared. HSBC also provides formal third-party access processes for business accounts. Our [internal review](https://waycore.com/tearsheet) of 240+ bank terms across the US, UK, and EU found a spectrum: some banks explicitly permit automation, many do not explicitly prohibit it, and a small minority use restrictive language. Waycore’s operating model was designed for that reality: dedicated credentials, explicit customer authority, bank-native security, and a human-in-the-loop service layer where needed. No. Quite the opposite: the service is designed specifically to avoid the bad patterns that make banks uncomfortable. We do **not** ask customers to normalize shared credentials as the operating model. We use dedicated users, explicit authorization, bank-enforced permissions, and revocable access. That is materially closer to adding an authorized finance operator or accountant than to “scraping in the dark.” Banks like Bank of America, Wells Fargo, Chase, and HSBC already support versions of delegated or third-party access in exactly that spirit. Only in the same sense that you would let your bank know you are adding an accountant, treasury operator, or other authorized party to the account. In many cases, the bank is effectively informed through the access model itself: creating a dedicated user, granting entitlements, or applying for third-party access. That is already how major banks structure shared business access. No one can honestly promise that every bank’s portal policy or login flow will never change. That would be unserious. The stronger answer is this: the **durable direction** in banking is toward individualized access, entitlements, explicit consent, stronger authentication, and controlled third-party connectivity. FFIEC’s guidance is consistent with that. Chase already lets customers manage third-party app entitlements, review what data is being shared, and stop sharing later. HSBC’s open-banking materials are also built around explicit consent and authorized access. That means the durable part of the model is **permissioned access with controls**, not shared passwords or fragile workarounds. The exact mechanics may evolve; that is why the human-in-the-loop layer matters. ## Regulatory & legal posture Broadly, yes. Regulators do not prohibit a company from using an authorized third party to help operate treasury workflows. In the US, FFIEC guidance explicitly discusses authentication and access for **third parties, service accounts, applications, and devices**, which means the regulatory focus is on access control and risk management, not on banning third-party involvement. In the UK/EU, AIS and PIS are regulated categories under PSD2, but the FCA also recognizes that there are exclusions for technical service providers that simply provide IT support. ([ffiec.gov](http://ffiec.gov)) Waycore is technology plus services, not a money transmitter, and the core model is designed so it does not depend on becoming an AISP/PISP to function. We are in the process of finalizing outside-counsel review and written analysis. We should answer that directly, not pretend the memo already exists if it does not. Waycore never holds funds. We operate as a delegated user under your bank’s native controls. ## Market precedent You would not be first in the relevant sense. Businesses already add employees, bookkeepers, accountants, and other third parties to their bank access. Banks already support formal third-party access and third-party app connectivity. And large advisory firms openly offer managed treasury services as a category. What is newer here is not the idea that someone other than the CFO touches the bank. What is newer is combining that with software, long-tail bank coverage, and controlled human supervision. Yes. That distinction matters. Credential-sharing models typically rely on a user handing over the same credentials they use themselves, often with weak permissioning and poor auditability. Waycore’s model is based on dedicated access, scoped permissions, revocability, and explicit authority. That is much closer to how banks already expect business accounts to be operated when multiple people or systems need access. ## Security, controls & approvals No. We are not giving an autonomous model carte blanche inside your bank. Waycore uses software to assist with treasury operations inside the permissions you define, with a human-in-the-loop operating layer where needed. The framing should be: **software-enhanced treasury operations under customer-controlled authority**. No. You define the authority model at the portal level, and it is enforced by your bank. Where payment workflows are supported, Waycore handles maker-side workflow orchestration; approval remains with the customer or other bank-authorized approver. You do. Or whoever you have explicitly designated inside your banking approval chain. Through dedicated credentials, bank-enforced MFA, and bank-native permissioning. The point is not to work around bank security. The point is to operate inside it. Every session is tied to a dedicated user and a defined authority model. Access scope is explicit, actions are attributable, and approvals remain in the customer’s bank-controlled flow where applicable. Yes. That is core to the model. Banks like Bank of America, Wells Fargo, and Chase already support user-level access control, account-level permissions, and management of linked third-party access. Chase also lets customers review what data is shared and stop sharing it. No. At no point in the transaction lifecycle does Waycore receive, hold, control, or redirect customer funds. Funds never pass through any Waycore account, wallet, escrow, or intermediary. Every payment instruction that Waycore submits is executed by the customer's own bank, from the customer's own account, through the bank's own infrastructure. Waycore's role is limited to preparing and submitting the instruction inside the bank portal on the customer's behalf. Waycore processes customer data solely to provide the service. We do not sell, share, or use identifiable customer data for advertising, marketing, or model training. Our infrastructure is designed to align with SOC 2 controls and, where applicable, the GLBA Safeguards Rule. All data processing is governed by our Privacy Policy and, for EU and UK customers, a Data Processing Agreement that complies with GDPR requirements including approved transfer mechanisms for cross-border data flows. ## Operations & Human-In-The-Loop (HITL) This is exactly why the service includes a human-in-the-loop operating layer. If a portal changes, a human can work through the change and keep the service running while the software layer is updated. That is a feature, not a bug. It is how continuity is preserved in a messy real-world banking environment. On the customer side, very little beyond setting up the delegated user and occasionally helping if the bank suspends or re-challenges that user. Internally, human involvement appears where needed to maintain continuity, especially around non-standard MFA or changing portal behavior. The practical answer is that Waycore’s SLA is about continuity and responsiveness, not just a generic API uptime number. We support several refreshes per day by default and can refresh on demand in the right workflows. The reason the model works is that it does not fail open when a portal changes or an MFA flow gets messy. The exact SLA should be stated contractually per customer deployment. *** ## Ready to get started? Discuss your specific bank coverage requirements, get a custom quote, or learn more about the Pioneer Program. Read the full API reference, explore the sandbox, and start building your integration today. # Support & Coverage Source: https://docs.waycore.com/faq/support This section explains what Waycore supports and how it maintains reliability in real-world banking environments. The focus is not just on coverage, but on how that coverage performs under operational stress. ## Coverage Waycore supports a growing set of commercial banking environments. Coverage is expanding continuously, and additional banks can be added on demand where delegated access is available. Simple portals are typically brought live within **4–8 hours** from the moment access is enabled. Complex portals that are not currently supported are typically brought live within **48 hours**. Support depends on the specific portal and permission structure, but in most cases, a single delegated user can cover multiple accounts under the same entity. ## Reliability We handle it. Maintaining portal compatibility, including authentication changes and operational recovery, is our core engineering responsibility. Standard support includes baseline reliability commitments for healthy connections.\ Enhanced response commitments and custom reporting are available for larger partners under separate support terms. Data refreshes several times per day by default and can be triggered on demand depending on the workflow. Reliability is achieved through a combination of software and human-in-the-loop operations, ensuring continuity even when bank portals change or behave inconsistently. The customer's bank retains full authority over the delegated user profile at all times. If the bank restricts, suspends, or terminates access to the portal for any reason, Waycore's ability to operate on behalf of that customer ceases immediately. Waycore does not claim any right of access independent of the bank's own user management controls. This is disclosed to every customer in our Terms of Use, and customers acknowledge that bank-side restrictions may affect service availability. ## Auth Yes. Waycore supports common MFA methods (email, SMS, TOTP) and handles more complex flows (e.g., app-based authentication) through its operating layer. In most cases, Waycore handles recovery. Occasionally, the customer may need to assist (e.g., re-authentication or unblocking a user). ## Support model Support is built into the service. Waycore operates the connections and ensures they remain functional, rather than leaving customers to troubleshoot integrations themselves. Yes. SLAs focus on continuity and responsiveness, not just API uptime. Specific terms are defined per deployment. Both. Waycore monitors connections and addresses issues proactively, with reactive support as needed. *** ## Ready to get started? Discuss your specific bank coverage requirements, get a custom quote, or learn more about the Pioneer Program. Read the full API reference, explore the sandbox, and start building your integration today. # What is Waycore? Source: https://docs.waycore.com/faq/what-is-waycore Waycore helps finance teams manage commercial bank accounts at scale: balances, transactions, statements, and payment workflows across banks that are difficult to integrate directly. This page is intended for finance and operations teams evaluating Waycore. It covers the model, the access structure, and the key constraints. No prior knowledge of treasury software is assumed. Waycore is a software company that provides a **software-enabled outsourced treasury model.** We combine software automation with a controlled human service layer, using software where possible and human operations where needed. This is the same model that has existed in corporate banking for decades: a company appointing an external bookkeeper, treasury bureau, or accounting firm to operate its bank accounts under a limited mandate. Waycore delivers this as programmable infrastructure rather than strictly manual labour. Waycore is not a bank, a money transmitter, or a money services business. We are not an Account Information Service Provider (AISP) or a Payment Initiation Service Provider (PISP). We are not a custodian of funds and are not a bank replacement. At no point in the transaction lifecycle does Waycore receive, hold, control, or redirect customer funds. **Funds never pass through any Waycore account or intermediary.** The bank remains the sole custodian of funds, the sole processor of payment instructions, and the sole enforcer of transaction controls. Commercial bank workflows are fragmented and difficult to manage at scale because the banking landscape has no single universal API surface. Aggregators, bank APIs, file rails, and manual portals each solve parts of the problem, but none provide one programmable, permissioned, observable interface over the full commercial-bank workspace. Waycore exists to provide that canonical interface by operating on top of the bank-authorized workspace itself, with delegated access, human-in-the-loop continuity, and bank-native controls. Waycore is designed around the **permissioning model that banks already use**. The customer instructs their bank to create a dedicated delegated user. The customer defines the permissions. The bank enforces them. The customer can revoke access at any time. This means Waycore: * Does **not** log in as the primary user * Does **not** have unrestricted access to the account * Uses dedicated credentials issued to a delegated user (not shared passwords) Banks including Bank of America, Wells Fargo, Chase, and HSBC already support formal third-party and delegated access for business accounts in exactly this structure. Waycore operates strictly within the permissions granted by the customer and enforced by the bank. The service supports data access and payment-maker workflows under that model. Waycore operates through the customer’s authorized access path, using bank-native delegated permissions and standard MFA. We do not bypass authentication, impersonate unknown users, or modify bank systems. Where the bank requires human interaction, a supervised operator completes the workflow. Automation is used downstream to normalize, structure, validate, and deliver the customer’s own banking data into their approved business software. When payment workflows are in scope, Waycore handles maker-side orchestration only. **Approval of payments remains entirely with the customer** or their designated approver inside the bank's own system. Waycore does not autonomously control funds. Human oversight is maintained for edge cases: non-standard authentication, portal changes, or anything outside normal operating conditions. *** ## Want to go deeper? Waycore touches sensitive financial infrastructure, so we expect legal, security, and operational diligence. These pages are designed to make that review easier. SOC 2 progress, fintech insurance, data protection, and Vanta trust access. A terms-aware model for delegated access and bank-enforced controls. Learn how delegated users, permissions, approvals, audit trails, and human-in-the-loop escalation work in practice. # Authentication Source: https://docs.waycore.com/getting-started/auth Authentication uses opaque API keys passed as `Authorization: Bearer `. Keys are issued per organization, scoped to a specific environment (`live` or `test`), and carry the minimum permissions needed for your integration. There is no token exchange step. Include the API key directly on every request. Common scopes include: * `entities:read` and `entities:write` for entity management * `connections:read` for institutions and connection reads * `connections:write` for connection onboarding, credential updates, sync, and deletion * `accounts:read` for account data * `transactions:read` for historical browse and sync * `transfers:read` for transfer history and status reads * `transfers:write` for creating and retrying transfers * `webhooks:read` and `webhooks:write` for webhook registration management Keys are managed through the Waycore Console. To get access, contact us at [hello@waycore.com](mailto:hello@waycore.com). # Sandbox access Source: https://docs.waycore.com/getting-started/sandbox-access Waycore’s sandbox is designed for safe end-to-end integration testing using **test API keys**. The sandbox follows the same public API model as production, so you can build against the real connection, accounts, transactions, sync, and webhook flows without touching a real bank connection. Base URL: [https://api.waycore.com](https://api.waycore.com) Auth: test API keys (same auth flow as production) ## How the sandbox works When you use a test key, you can create and interact only with Waycore’s demo institutions. Resources created through that key live in the sandbox environment, including: * Connections * The accounts and transactions exposed through those connections * Sync cursors and sync events * Webhooks registered with the sandbox key This means you can build and validate your full integration flow against realistic-looking demo data without affecting any real institution or production webhook setup. ## Sandbox vs live Sandbox and live are strictly separated. * A **test key** can only create connections to demo institutions. * A **test key** cannot access or modify resources created in the live environment. * A **test key** cannot trigger or receive live webhook deliveries. * A **live key** cannot operate on sandbox-only demo connections. If you need to connect a real bank, you must use a live key. If you are using a test key, you should expect access to be limited to demo institutions and demo data only. Treat sandbox and live as separate environments that happen to share the same API surface. You can develop safely in sandbox first, then move the same integration pattern to live with real institutions and live credentials. ## Entities in sandbox Entities themselves are not split into separate sandbox and live copies. They remain organization-level resources. However, sandbox connection creation is intentionally more restrictive: * When using a **test key**, you can only create connections against your organization’s **default entity** * When using a **live key**, the normal entity model applies If your production integration uses multiple entities, assume that sandbox demo-bank connections will still belong to the default entity only. ## Typical sandbox flow 1. List entities and identify your organization’s default entity 2. Search sandbox institutions via `GET /v1/institutions` 3. Create or return a connection with `POST /v1/connections` 4. Mark setup complete and wait for the connection to become ready 5. Read accounts and transactions, exercise sync, and test webhook handling The sandbox contains demo institutions and deterministic transaction data so you can validate backfills, sync cursors, and webhook-driven updates safely. To get sandbox access or test credentials, contact us at [hello@waycore.com](mailto:hello@waycore.com). # Use with AI Source: https://docs.waycore.com/getting-started/use-with-ai Waycore docs are available in a curated LLM-friendly format at `/waycore-ai.yaml`. Use this when you want to give an AI assistant the current public documentation context for API implementation, integration planning, or support questions. Copy the current `/waycore-ai.yaml` bundle to your clipboard. # Your first API call Source: https://docs.waycore.com/getting-started/your-first-api-call Before you can read account and transaction data, you first need to set up a connection. The public API flow is: 1. Identify the owning entity 2. Choose a bank target with either an institution catalog record or a portal URL 3. Create or return a connection 4. Provide the delegated-user credentials 5. Mark setup complete 6. Wait for the connection to become `kind="ready"` 7. Read data or trigger a sync ```bash theme={null} API_KEY="way_live__" BASE_URL="https://api.waycore.com/v1" ENTITY_ID="11111111-2222-3333-4444-555555555555" INSTITUTION_ID="chase" CONNECTION_ID="conn_123" ``` ## 1. Find the owning entity Start by listing entities and choosing either the default org entity or a customer entity you created earlier. ```bash theme={null} curl -sS "$BASE_URL/entities?limit=10" \ -H "Authorization: Bearer $API_KEY" ``` ## 2. Choose the bank target If the bank is already in the public institution catalog, search by name, identifier, portal URL, or portal domain, then capture the `institutionId` you want to connect. A bank does not need to appear in `/v1/institutions` before you can start onboarding it. If it is not listed, use its HTTPS `portalUrl` when creating the connection. ```bash theme={null} curl -sS "$BASE_URL/institutions?query=chase" \ -H "Authorization: Bearer $API_KEY" ``` ## 3. Create or return a connection Create the connection using the chosen `entityId` plus either `institutionId` or `portalUrl`. The response returns a `ConnectionResource`, which may be a new `kind="setup"` connection or an existing connection returned directly. If the response is `kind="setup"`, you can use the returned `setup.instructions` immediately. The current email, username, phone number, and other setup details are included on that first create response. ```bash theme={null} curl -sS "$BASE_URL/connections" \ -X POST \ -H "Authorization: Bearer $API_KEY" \ -H "Content-Type: application/json" \ -d '{ "entityId": "'"$ENTITY_ID"'", "institutionId": "'"$INSTITUTION_ID"'" }' ``` ```bash theme={null} curl -sS "$BASE_URL/connections" \ -X POST \ -H "Authorization: Bearer $API_KEY" \ -H "Content-Type: application/json" \ -d '{ "entityId": "'"$ENTITY_ID"'", "portalUrl": "https://business.bank.example.com/login" }' ``` ## 4. Provide credentials Once the delegated user exists in the bank, submit the current working credentials. Include `password` when that bank requires one. ```bash theme={null} curl -sS "$BASE_URL/connections/$CONNECTION_ID/credentials" \ -X PUT \ -H "Authorization: Bearer $API_KEY" \ -H "Content-Type: application/json" \ -d '{ "bankUsername": "waycore.user", "bankCustomerId": "company-001", "password": "super-secret-password" }' ``` ## 5. Mark setup complete After the bank-side delegated-user setup is finished, notify Waycore so activation can continue. From there, Waycore completes activation and starts the initial historical backfill automatically. ```bash theme={null} curl -sS "$BASE_URL/connections/$CONNECTION_ID/setupCompletion" \ -X PUT \ -H "Authorization: Bearer $API_KEY" ``` ## 6. Wait for `kind="ready"` If the create call returned `kind="setup"`, poll the connection until it transitions to `kind="ready"`. Once the connection is ready, the normal steady-state status is `active`. ```bash theme={null} curl -sS "$BASE_URL/connections/$CONNECTION_ID" \ -H "Authorization: Bearer $API_KEY" ``` ## 7. Read data or queue a sync Once the connection is ready, you can read accounts and transactions immediately, or trigger a sync if you need fresh data right away. Manual sync triggers are subject to the connection cooldown described in [Connections](/connections). ```bash theme={null} curl -sS "$BASE_URL/accounts?connectionId=$CONNECTION_ID" \ -H "Authorization: Bearer $API_KEY" ``` ```bash theme={null} curl -sS "$BASE_URL/connections/$CONNECTION_ID/sync" \ -X PUT \ -H "Authorization: Bearer $API_KEY" ``` From there, use `GET /v1/transactions` for backfills and `GET /v1/transactions/sync` plus webhooks to keep your mirror current. # Institutions Source: https://docs.waycore.com/institutions Use catalog records when available, or start onboarding with a portal URL An **Institution** is a catalog record for a bank or banking platform Waycore already recognizes. It is not required to start onboarding a bank, and it is not a live connection. Use the institutions endpoints to discover the correct `institutionId` when a bank is already in the catalog. A bank does not need to appear in `/v1/institutions` before you can start onboarding it. If it is not listed, create the connection with `entityId` plus `portalUrl`; Waycore returns a setup-stage connection and delegated-user instructions while support is added. ## Institution vs connection | Object | What it represents | | --------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | **Institution** | A bank record in Waycore's public catalog, used when one is available. | | **Connection** | A live, entity-owned integration created with either an `institutionId` or a bank `portalUrl`, after delegated-user setup and activation. | In other words: institutions are a convenience for known banks, not a prerequisite for onboarding a new one. ## Connection input paths | Input path | When to use it | | ------------------------------- | ------------------------------------------------------------------------------------- | | `entityId` plus `institutionId` | Use when the bank appears in `GET /v1/institutions`. | | `entityId` plus `portalUrl` | Use when the bank is not listed yet, or when you are starting from a bank portal URL. | For catalog records, call `GET /v1/institutions`, search by institution name, identifier, portal URL, or portal domain, then use the returned `institutionId` in `POST /v1/connections`. For banks that are not listed, use the HTTPS bank `portalUrl` directly in `POST /v1/connections`. ## Key fields * **`institutionId`** — Stable Waycore identifier used when creating connections. * **`name`** — Display name for the bank or banking platform. * **`canonicalPortalUrl`** — Default HTTPS portal URL for the institution. * **`additionalPortalUrls`** — Other known HTTPS portal URLs that can be supplied when creating a connection. * **`alternativeNames`** — Other names by which the institution is commonly known. * **`logoUrl`** — URL of the institution's logo, when available. * **`setupGuideUrl`** — Link to Waycore's user-facing setup guide for this institution. * **`status`** — `live` if the institution is fully supported, or `pending` if it is in the catalog but not yet available for new connections. ## Searching `GET /v1/institutions` supports a `query` parameter for name, identifier, portal URL, or portal domain search. Results are cursor-paginated, so you can browse the full catalog or power a searchable picker in your product. Use `institutionId` when a catalog record fits the bank. Use `portalUrl` directly in the connection create call when the bank is unsupported, newly requested, or better identified by a specific portal URL. ## Endpoints ## Required scopes | Scope | Used by | | ------------------- | --------------------------------------------------------------- | | `connections:read` | List, get | | `connections:write` | Create a connection with the selected institution or portal URL | # Aggregators vs. Waycore Source: https://docs.waycore.com/intro/aggregators-vs-waycore For platforms and finance teams evaluating commercial-bank access, the important question is not only "which provider has a listed connection?" The important question is: can the workflow performed inside the bank portal be made programmable, observable, permissioned, and recoverable under bank-native controls? Waycore & aggregators solve different problems. Image ## Where aggregators work well Aggregators are genuinely good infrastructure for consumer fintech apps, SMB lending, and basic cash-flow dashboards. The aggregator model is a good choice when the integration requires read-only access, the target accounts are retail or simple SMB, and there is no requirement for payment execution or deterministic reliability. ## Where aggregators fail in commercial banking Our own first-hand experience trying to build real-time treasury applications on top of standard aggregators confirms these failure modes are systemic for commercial workflows: 1. **Geographic and institutional coverage:** Aggregators maintain a fixed catalog of supported institutions, weighted heavily toward US retail and SMB accounts. Adding a bank outside that catalog requires a new integration, which may take months or never happen. 2. **No near real-time data:** Aggregators batch and delay data. For execution workflows like payments, sweeps, and approval chains, you need to know the current state of an account before you act on it. Aggregators cannot reliably deliver this. 3. **Commercial portal coverage:** Aggregators are optimized for consumer accounts. An aggregator's dashboard may list a major institution like Chase or Morgan Stanley as "supported," but attempting to pull reliable data from their commercial portals is often a terrible experience. 4. **Missing commercial features:** Because they do not specialize in commercial banking, aggregators completely lack support for core treasury features. 5. **No execution:** Aggregators are read-only data pipes. They cannot reliably support commercial payment workflows like staged transfers, approval chains, or bulk payroll uploads. 6. **Poor developer support:** When a bank updates its portal and an aggregator connection breaks, resolution can take months. The developer experience is notoriously poor, with no human fallback to maintain continuity. ## Comparison for integrators | Dimension | Waycore | Aggregators | | :----------------------------- | :------------------------------------------------------------------- | :------------------------------------------------ | | **Core function** | Read + write treasury infrastructure | Read-only data aggregation | | **Target market** | Enterprise ERPs, treasury platforms | Consumer apps, basic fintech | | **Geographic coverage** | Any bank worldwide with delegated access; on demand, typically hours | Fixed catalog; new banks require new integrations | | **Data freshness** | Near real-time as standard | Batched or delayed; not suitable for execution | | **Commercial portal coverage** | Deep, demand-led; any portal with delegated access | Uneven to weak; dashboard claims often mislead | | **Commercial features** | Native support for sweeps, shadow accounts, NAT files | Basic data only | | **Execution capability** | Payments, approvals, sweeps, bulk uploads | None, or limited consumer transfers | | **Reliability model** | HITL fallback; human operators maintain continuity | Best-effort; breaks on portal changes | | **Developer support** | Managed recovery; proactive exception handling | Ticket-based; often months to resolve | # Core concepts Source: https://docs.waycore.com/intro/core-concepts > Waycore is built around a small set of structural primitives.\ > If you understand these, you understand the system. *** ## Delegated User A **delegated user** is a bank-native login created by your customer inside their commercial bank. This is **functionally identical to hiring an outsourced treasury clerk**. Waycore operates strictly within the permissions granted by the account owner. The nomenclature can vary across banks, but you will normally see this feature appears as **user**, **sub-user,** **authorized user, portal user, operator, delegate**. It is not: * A shared credential * A consumer OAuth token It is a real user identity inside the bank’s permission model. Permissions are explicitly scoped: * Read-only access * Transfer initiation (optional) * Approval authority (optional) Waycore operates exclusively through this delegated identity. **Implication:**\ The bank controls the permission surface. Waycore does not (and cannot) bypass it. *** ## Entity An **entity** is the business that owns data and connections in the public API. It gives you a stable ownership boundary for: * Connections * Accounts * Transactions * Your own internal customer or fund mappings In practice, entities let you model customer businesses, subsidiaries, SPVs, or your own operating company in a way that stays consistent across institutions. *** ## Institution An **institution** is a bank or fintech record Waycore already recognizes in the public catalog. An institution object represents: * The bank, banking platform, or fintech * A stable `institutionId` * Default and additional portal URLs when known * A searchable discovery record you can use when one is available It does **not** represent a live connection by itself, and it is not required before onboarding starts. Banks that are not in the catalog can still be onboarded through a raw `portalUrl` on the connection create call. *** ## Connection A **connection** is the live, entity-owned integration with a bank target identified by either an `institutionId` or a bank `portalUrl`. Connections are created in stages: * `kind="setup"` while delegated-user onboarding is still in progress * `kind="ready"` once the connection is activated and able to sync The public API integrates first around this connection lifecycle, then around the accounts and transactions discovered through it. *** ## Connection Lifecycle Public connection states include: * `draft`: The connection is created, but onboarding inputs are still incomplete. * `pendingActivation`: Bank-side setup is complete and Waycore is validating and activating the connection. * `active`: Syncing normally. * `reauthRequired`: Bank authentication requires re-authentication before sync can continue. * `errored`: A recoverable issue is preventing sync. Waycore will address and retry automatically. * `invalidConfig`: Connection configuration is invalid and needs correction before normal operation can resume. * `paused`: Syncing has been intentionally suspended by the Waycore team, usually during a new version release or an active bug investigation. API read endpoints continue to work as expected during this period. * `revoked`: Access has been removed. No further syncs will occur. These states make delegated-user onboarding and ongoing bank health explicit, rather than hiding them behind a single "connected" flag. *** ## Transfer A **transfer** is a public API payment object that represents a requested movement of funds through a connected bank account. Transfers support internal account movements and external payment rails such as ACH, wire, SWIFT, FedNow, RTP, SEPA, and local rails, subject to API access, institution capabilities, and the delegated user's bank-side permissions. > **Note:** All external transfers require end-user approval in the bank portal. Waycore initiates the bank-side flow, then the end user completes approval at the bank. Internal transfer approval requirements depend on the bank, account setup, and delegated-user permissions. *** ## Webhook Event A **webhook event** is an operational signal emitted by the public API when subscribed events occur. Current public producers include: * Connection status changes * Transaction sync availability * Explicit `test` deliveries Additional event types are reserved for future public producers. Use webhooks to trigger follow-up work and monitor connection health. For transaction reconciliation, use `transactions.sync_available` as a prompt to call `GET /v1/transactions/sync`. *** ## Audit Trail Every action is written to an immutable audit log. The audit trail includes: * Timestamp * Institution * Delegated user identity * Action performed * Result * Metadata This enables: * Compliance reporting * Operational debugging * Post-facto review *** ## Human-in-the-Loop (HITL) When automation cannot proceed (e.g., hardware MFA, unexpected bank UI), the execution enters a controlled human intervention path. HITL actions: * Are permission-bound * Are logged * Emit state updates * Do not bypass policy *** ## Design Philosophy Waycore is opinionated: * Bank permissions are the root authority. * Every action is observable. * State is explicit. * Failure modes are surfaced, not hidden. * Human-in-the-loop as a fallback for banks that require it. # How it works Source: https://docs.waycore.com/intro/how-it-works Waycore turns a commercial bank portal into a programmable surface area using **entity-aware ownership**, **delegated user access**, and **observable state transitions**. We act as an end-user's authorised representative, operating under a delegated user, at the portal level, to automate treasury workflows under human supervision.