Verify a proof

curl --request POST \
  --url https://api.usewarp.net/v1/zk/proofs/{proofId}/verify \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "proof": {
    "pi_a": [
      "<string>"
    ],
    "pi_b": [
      [
        "<string>"
      ]
    ],
    "pi_c": [
      "<string>"
    ],
    "protocol": "groth16",
    "curve": "bn128"
  },
  "public_signals": [
    "<string>"
  ],
  "nonce": "<string>",
  "onchain": false
}
'

import requests

url = "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify"

payload = {
    "proof": {
        "pi_a": ["<string>"],
        "pi_b": [["<string>"]],
        "pi_c": ["<string>"],
        "protocol": "groth16",
        "curve": "bn128"
    },
    "public_signals": ["<string>"],
    "nonce": "<string>",
    "onchain": False
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    proof: {
      pi_a: ['<string>'],
      pi_b: [['<string>']],
      pi_c: ['<string>'],
      protocol: 'groth16',
      curve: 'bn128'
    },
    public_signals: ['<string>'],
    nonce: '<string>',
    onchain: false
  })
};

fetch('https://api.usewarp.net/v1/zk/proofs/{proofId}/verify', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'proof' => [
        'pi_a' => [
                '<string>'
        ],
        'pi_b' => [
                [
                                '<string>'
                ]
        ],
        'pi_c' => [
                '<string>'
        ],
        'protocol' => 'groth16',
        'curve' => 'bn128'
    ],
    'public_signals' => [
        '<string>'
    ],
    'nonce' => '<string>',
    'onchain' => false
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify"

	payload := strings.NewReader("{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.usewarp.net/v1/zk/proofs/{proofId}/verify")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.usewarp.net/v1/zk/proofs/{proofId}/verify")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}"

response = http.request(request)
puts response.read_body

{
  "valid": true,
  "proof_id": "<string>",
  "checks": {
    "offchain": true,
    "onchain": {
      "chain_id": 123,
      "contract_address": "<string>",
      "result": true
    },
    "nonce": "ok",
    "policy": "ok",
    "nullifier": "ok"
  },
  "verified_at": "2023-11-07T05:31:56Z",
  "receipt": "<string>"
}

{
  "error": {
    "code": "invalid_request",
    "message": "amount_usd: Number must be greater than 0"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid API key"
  }
}

{
  "error": {
    "code": "not_found",
    "message": "Resource not found"
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "<string>"
  }
}

{
  "error": {
    "code": "rate_limited",
    "message": "Too many requests. Retry after the window resets."
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "<string>"
  }
}

ZK verification

Verify a proof

Verifies a Groth16 proof off-chain against the proof’s stored verification key. With onchain: true, also calls verifyProof on the proof’s deployed verifier contract (allow-listed chains only). Enforces the proof’s policies: value rules, a nonce signal (kind: "nonce") that must equal the supplied nonce, and a nullifier signal (kind: "nullifier") that can only be accepted once per proof. Attestation circuits also declare kind: "project_ref" (must equal the stored value) and kind: "registry_nonce" (enforced by the on-chain registry). A malformed policy fails closed (policy: "invalid_policy", valid: false). Returns a signed receipt (compact JWS, EdDSA) that you can verify with the keys from the JWKS endpoint. Only the owning project’s secret key can verify its proofs.

POST

proofs

{proofId}

verify

Verify a proof

curl --request POST \
  --url https://api.usewarp.net/v1/zk/proofs/{proofId}/verify \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "proof": {
    "pi_a": [
      "<string>"
    ],
    "pi_b": [
      [
        "<string>"
      ]
    ],
    "pi_c": [
      "<string>"
    ],
    "protocol": "groth16",
    "curve": "bn128"
  },
  "public_signals": [
    "<string>"
  ],
  "nonce": "<string>",
  "onchain": false
}
'

import requests

url = "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify"

payload = {
    "proof": {
        "pi_a": ["<string>"],
        "pi_b": [["<string>"]],
        "pi_c": ["<string>"],
        "protocol": "groth16",
        "curve": "bn128"
    },
    "public_signals": ["<string>"],
    "nonce": "<string>",
    "onchain": False
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: JSON.stringify({
    proof: {
      pi_a: ['<string>'],
      pi_b: [['<string>']],
      pi_c: ['<string>'],
      protocol: 'groth16',
      curve: 'bn128'
    },
    public_signals: ['<string>'],
    nonce: '<string>',
    onchain: false
  })
};

fetch('https://api.usewarp.net/v1/zk/proofs/{proofId}/verify', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'proof' => [
        'pi_a' => [
                '<string>'
        ],
        'pi_b' => [
                [
                                '<string>'
                ]
        ],
        'pi_c' => [
                '<string>'
        ],
        'protocol' => 'groth16',
        'curve' => 'bn128'
    ],
    'public_signals' => [
        '<string>'
    ],
    'nonce' => '<string>',
    'onchain' => false
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.usewarp.net/v1/zk/proofs/{proofId}/verify"

	payload := strings.NewReader("{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.usewarp.net/v1/zk/proofs/{proofId}/verify")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}")
  .asString();

require 'uri'
require 'net/http'

url = URI("https://api.usewarp.net/v1/zk/proofs/{proofId}/verify")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"proof\": {\n    \"pi_a\": [\n      \"<string>\"\n    ],\n    \"pi_b\": [\n      [\n        \"<string>\"\n      ]\n    ],\n    \"pi_c\": [\n      \"<string>\"\n    ],\n    \"protocol\": \"groth16\",\n    \"curve\": \"bn128\"\n  },\n  \"public_signals\": [\n    \"<string>\"\n  ],\n  \"nonce\": \"<string>\",\n  \"onchain\": false\n}"

response = http.request(request)
puts response.read_body

{
  "valid": true,
  "proof_id": "<string>",
  "checks": {
    "offchain": true,
    "onchain": {
      "chain_id": 123,
      "contract_address": "<string>",
      "result": true
    },
    "nonce": "ok",
    "policy": "ok",
    "nullifier": "ok"
  },
  "verified_at": "2023-11-07T05:31:56Z",
  "receipt": "<string>"
}

{
  "error": {
    "code": "invalid_request",
    "message": "amount_usd: Number must be greater than 0"
  }
}

{
  "error": {
    "code": "unauthorized",
    "message": "Invalid API key"
  }
}

{
  "error": {
    "code": "not_found",
    "message": "Resource not found"
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "<string>"
  }
}

{
  "error": {
    "code": "rate_limited",
    "message": "Too many requests. Retry after the window resets."
  }
}

{
  "error": {
    "code": "invalid_request",
    "message": "<string>"
  }
}

Authorizations

Authorization

string

header

required

Your project secret key: sk_test_... (testnet) or sk_live_... (mainnet). Use it only on your server.

Path Parameters

proofId

string

required

ZK proof ID from the Warp Platform.

Body

application/json

proof

object

required

Proof object as produced by snarkjs groth16.fullProve.

Show child attributes

public_signals

string[]

required

Public signals as decimal strings. The count must match the circuit and each value must be below the BN254 scalar field modulus.

nonce

string

Decimal nonce from the create-nonce endpoint. Required when the proof declares a nonce signal; it must equal that public signal. Otherwise optional: it is consumed but reported as unbound, because the proof itself does not commit to it.

Pattern: ^[0-9]{1,78}$

onchain

boolean

default:false

Also call verifyProof on the deployed verifier contract.

Response

Verification result

valid

boolean

proof_id

string

checks

object

Show child attributes

verified_at

string<date-time>

receipt

string

Compact JWS (EdDSA, Ed25519, typ: warp-verify-receipt+jws) over a ZkReceiptClaims payload. Verify the signature with the JWKS endpoint, then check aud, exp, nonce and nonce_bound, and remember jti if you need single-use receipts.

Overview

Checkout sessions

ZK verification

Attestations

Health

Verify a proof

Authorizations

Path Parameters

Body

Response