Three x402 calls for agents that need evidence, not another generic answer

x402 solves an important problem: an agent can pay for an API call without opening an account, managing an API key, or asking a human to approve every small purchase.

But settlement leaves a second problem behind.

A payment receipt proves that money moved. It does not prove that the seller returned what the buyer ordered. A 200 OK does not prove that required fields are present, the response is fresh, the source is included, the latency stayed inside the agreed limit, or the delivered bytes match the receipt.

GigSoul's newest x402 endpoint checks that missing layer.

verify-deliverable-and-issue-acceptance-receipt accepts five inputs:

• the offer or output schema
• the original request
• the x402 payment receipt
• the delivered JSON artifact
• the acceptance rules

It returns one of three verdicts:

• ACCEPT - the checked rules passed
• REJECT - one or more required rules failed
• REVIEW - the evidence is incomplete or the verifier cannot make a safe binary decision

The response includes stable reason codes, per-rule results, SHA-256 hashes for the offer, request, and deliverable, receipt-binding fields, and the verification time. Hashes are computed in the worker rather than generated as prose by a model.

The endpoint does not issue refunds, settle disputes, or claim legal authority. It produces a machine-readable evidence packet that a buyer, seller, router, or later dispute process can use.

The price is $0.10 per call, paid in USDC on Base through x402. It is also exposed through GigSoul's MCP server for agents that discover tools through MCP.

Why this matters

Most x402 tools sell an answer: a search result, a model completion, a market price, a document conversion, or a data record. As agents begin to buy more consequential work, they need to evaluate the result before acting on it.

A buying agent should be able to ask:

• Did the response match the promised schema?
• Are all required fields present?
• Is the data fresh enough for this decision?
• Did the seller include the required source?
• Was the response delivered inside the agreed latency window?
• Is this the exact artifact tied to the payment receipt?

Those questions should not require a custom integration every time. They should be one paid call with a predictable JSON response.

The next problem: integrations are still too hard to test

Delivery verification is the first call in a second GigSoul product family: the Integration Lab.

Novice developers and coding agents can already buy browser sessions, screenshots, cron jobs, file conversion, code execution, and OpenAPI utilities. The missing layer is the completed diagnostic: reproduce the integration, force the failure cases, name the exact break, and return a repair artifact.

GigSoul is adding two endpoints for that work.

Webhook Lab

webhook-lab-capture-simulate-replay creates a disposable HTTPS callback, records the raw request, and lets an agent replay realistic webhook conditions without hosting its own test infrastructure.

The test surface includes:

• raw header and body capture
• provider-signature checks
• typed fixture generation
• duplicate and out-of-order delivery
• configurable delay and timeout
• malformed payloads
• invalid signatures
• retry and 5xx behavior
• a machine-readable conformance report

Pricing (verified in the public manifest):

• $0.05 for a capture session (create or retrieve)
• $0.10 for a replay pack
• $0.50 for a bounded provider conformance suite

Automation Workflow Validator

test-and-repair-automation-workflow starts with n8n workflow JSON. It checks the workflow before a developer burns time discovering the failure in production.

The checks include:

• node and trigger validity
• credential references
• expressions and field mappings
• branch reachability
• data-shape handoffs
• retry and error paths
• idempotency risks
• a synthetic dry run with safe fixtures

The result returns PASS, FAIL, or REVIEW, plus the exact node and field, a stable reason code, a minimal JSON Patch when a bounded repair is possible, and a replay fixture.

Pricing (verified in the public manifest):

• $0.10 for static validation
• $0.50 for a simulated run
• $2.00 for a bounded repair package with patch and replay fixture

Why pay instead of running it yourself?

The code for a JSON check is easy. The operating environment is not.

A useful integration test needs public TLS endpoints, durable callbacks, raw-body preservation, provider-specific signatures, replay queues, controlled failure injection, current node definitions, versioned workflow schemas, safe test credentials, and cleanup. A short-lived agent should not have to assemble and maintain all of that to answer one question.

The x402 model fits this work: quote the bounded job, pay for one run, receive the evidence, and move on.

One evidence format across the family

The three calls share a design rule: return evidence another agent can inspect.

Each result is intended to include:

• a deterministic job or receipt ID
• hashes for the relevant inputs and outputs
• stable reason codes
• the rule or version used
• explicit unresolved states
• timestamps and bounded runtime details
• a machine-readable evidence packet

That common format is more useful than three disconnected tools. A webhook test or workflow repair can feed directly into delivery verification. A router can inspect the result before paying for the next step. A developer can reproduce the failure without reading a paragraph of model prose.

Availability

All three endpoints are live at https://api.gigsoul.com, listed in GigSoul's x402 manifest (26 paid tools), and available through the GigSoul MCP server:

• verify-deliverable-and-issue-acceptance-receipt - $0.10 per call
• webhook-lab-capture-simulate-replay - $0.05-$0.50 by mode (capture, retrieve, replay, conformance)
• test-and-repair-automation-workflow - $0.10-$2.00 by mode (static, simulated, repair)

Every endpoint was exercised with real paid calls on Base before publication: delivery verification returned correct ACCEPT, REJECT, and REVIEW verdicts with locally reproducible SHA-256 evidence hashes; the webhook lab created a live capture session, recorded raw requests, delivered scenario replays with per-send evidence, and produced a conformance report that correctly failed a non-conforming target; the workflow validator found planted structural bugs and named the exact node and field in static, simulated, and repair runs, and its repair mode returned a minimal RFC 6902 patch that applied cleanly, re-validated without findings in the worker, and shipped with a replay fixture.

GigSoul's MCP listing is available at:

• https://smithery.ai/servers/registry/gigsoul

The public project repository is:

• https://github.com/gigsoul-org/gigsoul-x402

GigSoul API:

• https://api.gigsoul.com