# AX Check: dwolla.com
Checked 2026-09-29.

Dwolla's quickstart works great, but pricing stays hidden.
Docs give a runnable sandbox quickstart with code in four languages, but the pricing page only says "Custom pricing" with no rates, units or limits.

## Onboarding needs a login

## Coding sessions
All three independent sessions completed. Each found the sandbox free and confirmed Dwolla publishes no self-serve rates, describing pricing as custom/quote-based tied to transaction volume and payment rail, with one session citing an unverified historical per-transaction figure as a guess to double-check.

### DeepSeek V4.1 Flash
[View public run](https://agents.withgauge.com/p/runs/03bbf1c5-57b1-4131-a328-e84f9458df5e) · [Read transcript](https://www.ax-check.com/dwolla.com/sessions/deepseek.json)
README.md and final summary state pricing is custom/quote-based tied to transaction volume and rails (Standard ACH, Same Day ACH, Instant Payments), with sandbox free, sourced from https://www.dwolla.com/pricing — names the assumptions behind the lack of a flat number.
#### End-to-end onboarding
- **Onboarding needs a login**: The agent never obtained real Dwolla sandbox credentials on its own. It researched docs, wrote a quickstart script and README, then ran the script locally without credentials, which failed immediately with a missing-env-var error (a local, unauthenticated failure, not a product operation). No sandbox sign-up or token exchange against the live Dwolla API was ever performed; the agent explicitly flagged the lack of credentials as the blocking gap and stopped there.
  Event 71:

  ```text
  This example is written and syntax-checked. It is **not verified end-to-end**
    here because no sandbox credentials were available in this environment —
    that's the only blocker.
  ```
  Event 68:

  ```text
  Missing DWOLLA_CLIENT_ID / DWOLLA_CLIENT_SECRET.
  Create a free sandbox account at https://accounts-sandbox.dwolla.com/sign-up
  then copy the key + secret from https://dashboard-sandbox.dwolla.com/applications
  exit=1
  ```
  Event 77:

  ```text
  Only on credentials: this environment has no Dwolla sandbox key/secret, so I could not verify end-to-end.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No self-service sandbox credentials available in the test environment**: Dwolla requires an email-based sandbox sign-up (https://accounts-sandbox.dwolla.com/sign-up) and a dashboard visit to grab client_id/client_secret before any authenticated API call can be made. The sandboxed agent had no way to complete an email verification loop or human-gated dashboard step, so it could only write and syntax-check the quickstart script, never execute it against the live API. This is an environment/credential limitation, not a product defect — Dwolla's own docs describe this signup as normal onboarding.
  Event 48:

  ```text
  The Dwolla sandbox is a complete, free replica of production. You only need a valid email address to sign up.
  ```
  Event 71:

  ```text
  This example is written and syntax-checked. It is **not verified end-to-end**
    here because no sandbox credentials were available in this environment —
    that's the only blocker.
  ```

#### Suggested Changes
- **Publish a headline or example rate on the pricing page**: The pricing page at https://www.dwolla.com/pricing returned only 'Custom pricing built around how you move money' with no per-transaction figures, forcing a sales conversation before a developer can estimate cost. Add at least an illustrative rate range or a link to a self-serve calculator on that page, and confirm the fix by re-fetching the page and checking for a dollar or percentage figure tied to a transaction type.
  Event 41:

  ```text
  Custom pricing built around how you move money. Dwolla is purpose-built for platforms and enterprises running high volumes of bank payments. Pricing is tailored to your transaction volume, rails, and integration needs — not a one-size-fits-all tier.
  ```

### Kimi K3
[View public run](https://agents.withgauge.com/p/runs/39bd5558-6d50-42a3-af9a-027343bb9976) · [Read transcript](https://www.ax-check.com/dwolla.com/sessions/kimi.json)
Final output gives sandbox-free vs pay-as-you-go (~0.5%, $0.05-$5.00 per transfer) vs Scale/Contract pricing, and flags the figures as knowledge-based and to be verified on dwolla.com/pricing — naming the plan/tier assumptions behind the numbers.
#### End-to-end onboarding
- **Onboarding needs a login**: The agent checked the environment for Dwolla credentials, found none, and could not self-provision an app key/secret. It confirmed sandbox API reachability (401 without auth) but never obtained real credentials, so no authenticated operation against the hosted Dwolla API was ever performed. The example script exits immediately when run because DWOLLA_KEY/DWOLLA_SECRET are unset.
  Event 5:

  ```text
  ---
  v22.23.2
  Python 3.12.3
  
  ```
  Event 13:

  ```text
  401
  {"code":"InvalidCredentials","message":"Missing or invalid Authorization header."}
  ```
  Event 22:

  ```text
  syntax OK
  Blocked: set DWOLLA_KEY and DWOLLA_SECRET.
  Get free sandbox keys at https://accounts-sandbox.dwolla.com/signup
  exit=1
  
  ```
  Event 24:

  ```text
  every endpoint requires an app key + secret, and I can't create a sandbox account myself.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No self-service way to obtain Dwolla API credentials**: Dwolla requires a developer to sign up and mint an app key/secret through a human signup flow before any API call beyond the unauthenticated root can succeed. The agent had no way to create an account or credentials on its own, so the example script could never execute past the credential check. This is a product/account-creation limitation, not an agent error — the agent correctly detected the missing credentials and stopped rather than faking success.
  Event 13:

  ```text
  {"code":"InvalidCredentials","message":"Missing or invalid Authorization header."}
  ```
  Event 24:

  ```text
  I just can't mint credentials autonomously. Paste keys into the env and this runs immediately.
  ```

#### Suggested Changes
None identified in this transcript.

### Qwen 3.8 Max
[View public run](https://agents.withgauge.com/p/runs/b11c6bda-0fa8-4685-a4d2-de074bfc0e0a) · [Read transcript](https://www.ax-check.com/dwolla.com/sessions/qwen.json)
README.md and final summary state Dwolla publishes no self-serve pricing, cite the sandbox-is-free assumption, note the historical $0.25/ACH figure is unverified, and explain cost depends on volume/rails/integration scope quoted via sales.
#### End-to-end onboarding
- **Onboarding needs a login**: The agent never obtained real Dwolla sandbox credentials. It confirmed the hosted sandbox API requires auth (401 without credentials), built a full SDK-based example, and validated the entire flow only against a local nock mock with network disabled. No authenticated call to the actual Dwolla API was made.
  Event 11:

  ```text
  401
  ```
  Event 136:

  ```text
  I could not execute the live sandbox call — there are no Dwolla credentials in this environment, and obtaining them requires you to create an account/application in the sandbox dashboard.
  ```
  Event 114:

  ```text
  # tests 2
  # suites 0
  # pass 2
  # fail 0
  ```
  Event 126:

  ```text
  Missing DWOLLA_APP_KEY / DWOLLA_APP_SECRET. Copy .env.example to .env and fill in sandbox credentials from https://dashboard-sandbox.dwolla.com/applications
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No self-serve sandbox credentials available**: Dwolla requires creating an account and application via its dashboard to get sandbox key/secret; this is a normal human-login/signup requirement, not a product defect. The agent correctly detected the 401 and the missing-credential error path rather than faking success.
  Event 11:

  ```text
  401
  ```
  Event 126:

  ```text
  Missing DWOLLA_APP_KEY / DWOLLA_APP_SECRET. Copy .env.example to .env and fill in sandbox credentials from https://dashboard-sandbox.dwolla.com/applications
  ```
- **No published pricing on Dwolla's pricing page**: Dwolla's public pricing page only offers a sales-contact CTA with no rates, tiers, or self-serve signup, blocking the agent from answering the pricing question directly from documentation.
  Event 16:

  ```text
  Custom pricing built around how you move money. Dwolla is purpose-built for platforms and enterprises running high volumes of bank payments. Pricing is tailored to your transaction volume, rails, and integration needs — not a one-size-fits-all tier.
  ```
- **SDK onGrant callback silently breaks without a returned promise**: The dwolla-v2 SDK's onGrant hook must return a promise since the Auth module chains .then() on its return value; omitting the return caused an opaque TypeError on the first authenticated request during test runs. This is an SDK/agent-code interaction issue that the agent diagnosed and fixed itself.
  Event 78:

  ```text
  function performOnGrantCallback(client, token) {
    if (client.onGrant) {
      return client.onGrant(token).then(function() {
        return token;
      });
    }
    return token;
  }
  ```
  Event 86:

  ```text
  performOnGrantCallback (/sandbox/repo/node_modules/dwolla-v2/src/dwolla/Auth.js:29:33)
  ```

#### Suggested Changes
- **Publish indicative ACH/RTP pricing tiers on the pricing page**: Add at least illustrative per-transaction or volume-tier pricing to https://www.dwolla.com/pricing so prospective developers can estimate cost before contacting sales; verify by checking the page renders concrete numbers instead of only a 'talk to sales' CTA.
  Event 16:

  ```text
  Ready to talk through your use case? Tell us how you move money and we'll show you how Dwolla fits — and what it costs.
  ```
- **Document the onGrant promise requirement in dwolla-v2 SDK docs/types**: Add a note in the dwolla-v2 README or index.d.ts stating that a custom onGrant callback must return a promise (or wrap the return value defensively inside performOnGrantCallback in Auth.js) so integrators don't hit an opaque TypeError on their first token grant; verify by adding a test with a non-promise-returning onGrant.
  Event 78:

  ```text
  function performOnGrantCallback(client, token) {
    if (client.onGrant) {
      return client.onGrant(token).then(function() {
        return token;
      });
    }
    return token;
  }
  ```

### Task given to each agent
Help me build a simple example using Dwolla. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop.

No product credentials were supplied and no purchases were authorized.

## Score: B · 74/100 (provisional)
Grades come from completed site checks. Coding sessions and skipped checks do not affect the score.

### Clarity
- **Failed** — Homepage answers Markdown requests

  ```text
  Homepage returned text/html for a text/markdown request; no Markdown representation offered.
  ```

- **Pass** — llms.txt provides an actionable documentation index

  ```text
  llms.txt links Developer Docs, API Reference, Guides, pricing and use-case pages.
  ```

- **Pass** — llms.txt provides navigation guidance

  ```text
  llms.txt organizes content under Company, Products, Documentation, Key Pages and Use Cases headings.
  ```

- **Pass** — llms.txt mentions offered API, MCP, and skills

  ```text
  llms.txt lists API Reference and Guides; no MCP or skills offered to mention.
  ```

- **Pass** — A compact guide representation exists

  ```text
  Quickstart retrievable as standalone Markdown at /docs/quickstart.md, a site-published compact guide.
  ```

- **Pass** — A focused guide is directly retrievable

  ```text
  Quickstart.md returns 200 text/markdown with concrete sandbox auth steps and code.
  ```

- **Pass** — Equivalent instructions fit a token budget

  ```text
  Markdown quickstart measures 1897 tokens, well under the 8000-token budget.
  ```

- **Skipped** — Product-docs links survive format changes

  ```text
  Homepage Markdown unsupported, so link preservation across formats cannot be measured.
  ```

- **Pass** — The compact guide is independently actionable

  ```text
  Quickstart gives concrete steps: sandbox signup, API key, token request, first call, with curl and SDK examples.
  ```

- **Pass** — Install and next-step links resolve

  ```text
  Fetched quickstart and API reference pages returned HTTP 200; sandbox signup and dashboard links are documented.
  ```


### Onboarding
- **Pass** — Docs lead to a relevant quickstart

  ```text
  Docs quickstart page gives concrete steps: sandbox signup, API key, token request, first call.
  ```

- **Pass** — Installation commands are extractable

  ```text
  Quickstart shows curl token command and SDK snippets for TypeScript, Python, PHP, Ruby.
  ```

- **Pass** — Code examples are available without interaction

  ```text
  Quickstart embeds curl, TypeScript, Python, PHP, Ruby code and JSON responses without interaction.
  ```

- **Pass** — Prerequisites and auth boundaries are explicit

  ```text
  Quickstart requires sandbox signup, client_id/secret from dashboard, and Basic auth token exchange.
  ```


### Pricing
- **Failed** — Prices are stated, not gated

  ```text
  Pricing page states only 'Custom pricing' with no published rates; costs are gated behind a sales conversation.
  ```

- **Failed** — Pricing units and limits are explicit

  ```text
  Pricing page gives no per-transaction units, rail-specific rates, or volume limits.
  ```

- **Pass** — Pricing is readable without interaction

  ```text
  Pricing page renders as static HTML with no interaction required to read the custom-pricing explanation.
  ```

- **Pass** — Agents identify pricing and its assumptions

  ```text
  3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: README.md and final summary state pricing is custom/quote-based tied to transaction volume and rails (Standard ACH, Same Day ACH, Instant Payments), with sandbox free, sourced from https://www.dwolla.com/pricing — names the assumptions behind the lack of a flat number. Kimi K3: Final output gives sandbox-free vs pay-as-you-go (~0.5%, $0.05-$5.00 per transfer) vs Scale/Contract pricing, and flags the figures as knowledge-based and to be verified on dwolla.com/pricing — naming the plan/tier assumptions behind the numbers. Qwen 3.8 Max: README.md and final summary state Dwolla publishes no self-serve pricing, cite the sandbox-is-free assumption, note the historical $0.25/ACH figure is unverified, and explain cost depends on volume/rails/integration scope quoted via sales. This behavioural item does not affect the fast grade.
  ```


### Activation
- **Pass** — An API reference or OpenAPI spec is reachable

  ```text
  API reference overview and per-endpoint OpenAPI specs (create customer, initiate transfer) fetched successfully.
  ```

- **Skipped** — An MCP server is documented and well-formed

  ```text
  No MCP server documentation found in any fetched Dwolla page.
  ```

- **Skipped** — A CLI install path is documented

  ```text
  No CLI install path documented; quickstart uses curl and SDKs only.
  ```

- **Pass** — SDK packages resolve on their registries

  ```text
  npm dwolla and PyPI dwollav2 registry lookups both returned HTTP 200.
  ```

- **Skipped** — Agent skills are published

  ```text
  No agent skills published or referenced in any fetched Dwolla document.
  ```



[Full report data](https://www.ax-check.com/dwolla.com/report.json)