Document verification

import requests
from polymarket_auth import PolymarketClient  # canonical client from /connect#authentication

pmx = PolymarketClient()

BASE_URL = "https://api.preprod.polymarketexchange.com"  # prod: https://api.prod.polymarketexchange.com
EXTERNAL_ID = "u-8f21c4a9"  # your own user key. Max 49 characters.

# VERIFY: prefill endpoint paths are not published. Get both from your integration lead.
OTP_SEND_PATH = ""    # step 2: phone + date of birth -> code sent by SMS
OTP_VERIFY_PATH = ""  # step 3: phone + code -> prefilled PII

# VERIFY: request field names for these two bodies are not published.
OTP_SEND_BODY = {}    # phone number and date of birth
OTP_VERIFY_BODY = {}  # phone number and the code the user typed

def map_prefill_to_start(prefilled):
    # VERIFY: response field names on the prefill response, and their mapping onto
    # the POST /v1/kyc/start payload.
    return {}

def post(path, body):
    if not path:
        raise SystemExit("prefill path is not configured — see the warning on this page")
    r = requests.post(
        f"{BASE_URL}{path}",
        headers={"Authorization": f"Bearer {pmx.access_token()}", "Content-Type": "application/json"},
        json=body,
        timeout=30,
    )
    if r.status_code != 200:
        raise SystemExit(f"POST {path} -> HTTP {r.status_code}: {r.text}")
    return r.json()

post(OTP_SEND_PATH, OTP_SEND_BODY)          # one send per user action, never in a loop
prefilled = post(OTP_VERIFY_PATH, OTP_VERIFY_BODY)

start = post("/v1/kyc/start", {
    "external_id": EXTERNAL_ID,
    "docv_eligible": True,   # omit this and review cases take 1-2 business days
    **map_prefill_to_start(prefilled),
})
print("telemetry:", start.get("decision"), start.get("status"), start.get("subStatus"))
# Handle all four outcomes exactly as on /kyc#start-a-verification.

import { PolymarketClient } from "./polymarketAuth"; // canonical client from /connect#authentication

const pmx = new PolymarketClient();

const BASE_URL = "https://api.preprod.polymarketexchange.com"; // prod: https://api.prod.polymarketexchange.com
const EXTERNAL_ID = "u-8f21c4a9"; // your own user key. Max 49 characters.

// VERIFY: prefill endpoint paths are not published. Get both from your integration lead.
const OTP_SEND_PATH = "";   // step 2: phone + date of birth -> code sent by SMS
const OTP_VERIFY_PATH = ""; // step 3: phone + code -> prefilled PII

// VERIFY: request field names for these two bodies are not published.
const OTP_SEND_BODY: Record<string, unknown> = {};
const OTP_VERIFY_BODY: Record<string, unknown> = {};

// VERIFY: response field names on the prefill response and their mapping onto /v1/kyc/start.
const mapPrefillToStart = (prefilled: Record<string, unknown>): Record<string, unknown> => ({});

async function post(path: string, body: unknown) {
  if (!path) throw new Error("prefill path is not configured — see the warning on this page");
  const res = await fetch(`${BASE_URL}${path}`, {
    method: "POST",
    headers: {
      authorization: `Bearer ${await pmx.accessToken()}`,
      "content-type": "application/json",
    },
    body: JSON.stringify(body),
  });
  if (res.status !== 200) throw new Error(`POST ${path} -> HTTP ${res.status}: ${await res.text()}`);
  return res.json();
}

await post(OTP_SEND_PATH, OTP_SEND_BODY); // one send per user action, never in a loop
const prefilled = await post(OTP_VERIFY_PATH, OTP_VERIFY_BODY);

const start = await post("/v1/kyc/start", {
  external_id: EXTERNAL_ID,
  docv_eligible: true, // omit this and review cases take 1-2 business days
  ...mapPrefillToStart(prefilled),
});
console.log("telemetry:", start.decision, start.status, start.subStatus);
// Handle all four outcomes exactly as on /kyc#start-a-verification.

set -euo pipefail

BASE_URL="https://api.preprod.polymarketexchange.com"   # prod: https://api.prod.polymarketexchange.com
EXTERNAL_ID="u-8f21c4a9"                                 # your own user key. Max 49 characters.
TOKEN="$(./token.sh)"                                    # canonical token script from /connect#authentication

# VERIFY: prefill endpoint paths are not published. Get both from your integration lead.
OTP_SEND_PATH=""
OTP_VERIFY_PATH=""

post() { # post <path> <json-file> <out-file>
  [ -n "$1" ] || { echo "prefill path is not configured — see the warning on this page"; exit 1; }
  HTTP="$(curl -sS -o "$3" -w '%{http_code}' \
    -X POST "${BASE_URL}$1" \
    -H "Authorization: Bearer ${TOKEN}" \
    -H "Content-Type: application/json" \
    --data @"$2")"
  [ "${HTTP}" = "200" ] || { echo "POST $1 -> HTTP ${HTTP}"; cat "$3"; exit 1; }
}

# VERIFY: request field names for the OTP send and OTP verify bodies are not published.
echo '{}' > /tmp/otp-send.json
echo '{}' > /tmp/otp-verify.json

post "${OTP_SEND_PATH}"   /tmp/otp-send.json   /tmp/otp-send-resp.json
post "${OTP_VERIFY_PATH}" /tmp/otp-verify.json /tmp/prefilled.json

# VERIFY: mapping from the prefill response onto the /v1/kyc/start payload.
jq --arg id "${EXTERNAL_ID}" '{external_id: $id, docv_eligible: true}' /tmp/prefilled.json > /tmp/kyc-start.json

post "/v1/kyc/start" /tmp/kyc-start.json /tmp/kyc-resp.json
jq -r '"telemetry: \(.decision) \(.status) \(.subStatus)"' /tmp/kyc-resp.json
# Handle all four outcomes exactly as on /kyc#start-a-verification.

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"time"

	pmauth "example.com/yourfirm/pmauth" // canonical client from /connect#authentication
)

const (
	baseURL    = "https://api.preprod.polymarketexchange.com" // prod: https://api.prod.polymarketexchange.com
	externalID = "u-8f21c4a9"                                 // your own user key. Max 49 characters.

	// VERIFY: prefill endpoint paths are not published. Get both from your integration lead.
	otpSendPath   = "" // step 2: phone + date of birth -> code sent by SMS
	otpVerifyPath = "" // step 3: phone + code -> prefilled PII
)

// One auth client for the life of the process: it caches the token and
// re-mints at expires_in minus 30 s.
var pm = pmauth.New()

func post(path string, body map[string]any) (map[string]any, error) {
	if path == "" {
		return nil, fmt.Errorf("prefill path is not configured — see the warning on this page")
	}
	raw, err := json.Marshal(body)
	if err != nil {
		return nil, err
	}
	token, err := pm.AccessToken()
	if err != nil {
		return nil, err
	}
	req, err := http.NewRequest(http.MethodPost, baseURL+path, bytes.NewReader(raw))
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")

	res, err := (&http.Client{Timeout: 30 * time.Second}).Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	out, _ := io.ReadAll(res.Body)
	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("POST %s -> HTTP %d: %s", path, res.StatusCode, out)
	}
	var parsed map[string]any
	return parsed, json.Unmarshal(out, &parsed)
}

// VERIFY: response field names on the prefill response and their mapping onto /v1/kyc/start.
func mapPrefillToStart(prefilled map[string]any) map[string]any { return map[string]any{} }

func main() {
	// VERIFY: request field names for these two bodies are not published.
	if _, err := post(otpSendPath, map[string]any{}); err != nil { // one send per user action
		panic(err)
	}
	prefilled, err := post(otpVerifyPath, map[string]any{})
	if err != nil {
		panic(err)
	}

	start := map[string]any{
		"external_id":   externalID,
		"docv_eligible": true, // omit this and review cases take 1-2 business days
	}
	for k, v := range mapPrefillToStart(prefilled) {
		start[k] = v
	}
	resp, err := post("/v1/kyc/start", start)
	if err != nil {
		panic(err)
	}
	fmt.Println("telemetry:", resp["decision"], resp["status"], resp["subStatus"])
	// Handle all four outcomes exactly as on /kyc#start-a-verification.
}