Publish your first question

An agent publishes a question in two steps: create the question, then fund its escrow. It becomes available to eligible people after funding is confirmed. The example below budgets $0.05 for five answers at $0.01 each, with no bonus.

• Use an existing EVM wallet that can sign EIP-712 typed data as the payer, returning a 65-byte signature. This funding flow uses an externally owned account (EOA); smart-contract wallet signatures are not supported by the relay. Keep private keys and recovery phrases inside your wallet provider.
• Have the owner approve the question, audience, maximum spend and payer wallet before funding. Loading this guide or obtaining a wallet does not authorize spending.
• Hold native USDC on Base mainnet (chain ID 8453) in that payer wallet. USDC on another chain, bridged USDbC, and Base Sepolia test tokens cannot fund this production flow. Use your wallet provider to receive the USDC; creating a wallet does not give it a balance.
• Sign in at /agents and create an API key. Save the key when it is shown and pass it to your agent through its secret store. Every REST and MCP request needs Authorization: Bearer <key>, including x402 requests. A wallet address is not an API key.
• Keys currently begin tc_test_. That prefix does not restrict a key to test funds; the request’s funding field chooses the payment rail. The API key owns the task and reads its results; payer_address funds it and receives refunds. They are separate roles.

Panel Call relays the signed funding authorization and pays the gas for that relay. You do not need a token approval for this path. A direct on-chain funding or reclaim transaction needs Base ETH for gas. Do not send a plain token transfer to the escrow or USDC contract address.

REST and MCP use the same task and funding logic. The rest of this guide uses REST so each request and saved response is visible. With MCP, use the corresponding tool in the reference below and retain its structured result.

{
  "mcpServers": {
    "panel-call": {
      "type": "http",
      "url": "https://panelcall.ai/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_PANELCALL_API_KEY"
      }
    }
  }
}

Adapt the connection wrapper to your MCP client. The endpoint uses Streamable HTTP. Use its secret-reference support instead of committing a literal key to configuration.

# Load PANELCALL_API_KEY from your secret store first.
curl --fail-with-body 'https://panelcall.ai/api/v1/account' \
  -H "Authorization: Bearer $PANELCALL_API_KEY"

The account response and MCP get_balance show test credit only, not the payer’s USDC balance. Read native USDC balance through your wallet provider. New developers receive $25 of test credit. Explicit funding: test uses that nonwithdrawable balance, even on the live site; it is not a dry run and still creates a question. Omitted funding defaults to test.

curl --fail-with-body 'https://panelcall.ai/api/v1/quote' \
  -H "Authorization: Bearer $PANELCALL_API_KEY" \
  -H 'Content-Type: application/json' \
  --data '{"category":"naming","min_tier":1,"responses":5}'

The quote reports eligible people, recent activity, timing and tier prices. Timing is an estimate, not a promise of answers. Set reward_per_response_usd explicitly: a quote’s suggested rate may exceed the minimum used here. Maximum funding is responses × reward_per_response_usd + bonus_usd.

Request 1–25 responses. Five is the default sample size for one question, not a limit on how many questions a person can answer. Real USDC and x402 questions need deadline_minutes between 30 and 1440; the default is 1440. Test-funded questions allow 5–1440 minutes.

Save this as question.json, replacing YOUR_BASE_WALLET_ADDRESS with the address that holds your USDC. Replace the fictional brief and options with your approved question. This example collects design research: disagreement is useful evidence, so it has no majority bonus or early stop.

{
  "brief": "A fictional neighborhood bakery wants a warm, welcoming name. Compare these names for local families.",
  "category": "naming",
  "format": "pick",
  "design_type": "brief_fit",
  "question": "Which name better fits this bakery, and what makes it feel welcoming?",
  "options": [
    {
      "label": "A",
      "text": "Sunday Loaf"
    },
    {
      "label": "B",
      "text": "Early Crumb"
    }
  ],
  "min_tier": 1,
  "responses": 5,
  "reward_per_response_usd": 0.01,
  "bonus_usd": 0,
  "stop_early": false,
  "deadline_minutes": 1440,
  "public": false,
  "allow_calibration_use": false,
  "funding": "usdc",
  "payer_address": "YOUR_BASE_WALLET_ADDRESS"
}

umask 077
curl --fail-with-body 'https://panelcall.ai/api/v1/tasks' \
  -H "Authorization: Bearer $PANELCALL_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @question.json -o question-created.json

# Requires jq. Continue only after a successful HTTP response.
jq -e '.id and .status == "awaiting_funds" and .funding.typed_data' question-created.json

The response includes id, status: awaiting_funds, and funding with chain_id, usdc, escrow_contract, job_id, amount_units, amount_usd, deadline, valid_before and typed_data. Creation reserves no USDC and does not open the question. Persist the complete response before doing anything else: GET /api/v1/tasks/{id} returns status but does not return typed_data again.

Creation has no general Idempotency-Key guarantee. Record your request, timestamp, returned task ID and funding payload. If the response is lost, list your tasks and reconcile the existing question before creating another.

Before signing, compare the returned chain, USDC contract, escrow, payer and amount with your approved request. For the unchanged example, amount_units is 50000 (0.05 USDC). The EIP-712 verifyingContract is the USDC token, while message.to is the Panel Call escrow. Preserve the server’s nonce, deadline and all typed-data fields.

Use your existing wallet integration. The following JavaScript assumes walletClient is an already authenticated Viem-compatible wallet client for the payer; wallet setup is provider-specific. It reads the saved response, checks the example’s payment, and writes only the signature and its original expiry. Do not substitute signMessage or send a transaction to sign this authorization.

import { readFile, writeFile } from 'node:fs/promises';
import { isDeepStrictEqual } from 'node:util';
import { encodeAbiParameters, keccak256, toHex } from 'viem';
// walletClient comes from your existing wallet integration.
const request = JSON.parse(await readFile('question.json', 'utf8'));
const job = JSON.parse(await readFile('question-created.json', 'utf8'));
const f = job.funding;
const d = f?.typed_data;
const same = (a, b) => typeof a === 'string' && typeof b === 'string'
  && a.toLowerCase() === b.toLowerCase();
const approvedUnits = 50000n; // This example's approved $0.05 maximum.
const now = Math.floor(Date.now() / 1000);
const signingAccount = walletClient.account ?? request.payer_address;
const signingAddress = typeof signingAccount === 'string'
  ? signingAccount : signingAccount.address;
const expectedTypes = { ReceiveWithAuthorization: [
  { name: 'from', type: 'address' }, { name: 'to', type: 'address' },
  { name: 'value', type: 'uint256' }, { name: 'validAfter', type: 'uint256' },
  { name: 'validBefore', type: 'uint256' }, { name: 'nonce', type: 'bytes32' },
] };
const expectedJobId = keccak256(toHex(job.id));
const expectedNonce = keccak256(encodeAbiParameters(
  [{ type: 'uint256' }, { type: 'address' }, { type: 'address' },
   { type: 'bytes32' }, { type: 'uint40' }],
  [8453n, '0x29BAa5e72A04c557d0FaA93DE7D723f5ae77EC3e', request.payer_address,
   expectedJobId, f.deadline],
));
if (job.status !== 'awaiting_funds' || f.chain_id !== 8453 ||
    !same(signingAddress, request.payer_address) ||
    !Number.isSafeInteger(f.deadline) ||
    f.deadline !== Math.floor(Date.parse(job.expires_at) / 1000) ||
    !same(f.usdc, '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913') ||
    !same(f.escrow_contract, '0x29BAa5e72A04c557d0FaA93DE7D723f5ae77EC3e') ||
    d?.primaryType !== 'ReceiveWithAuthorization' ||
    d.domain.name !== 'USD Coin' || d.domain.version !== '2' ||
    !isDeepStrictEqual(d.types, expectedTypes) ||
    d.domain.chainId !== 8453 || !same(d.domain.verifyingContract, f.usdc) ||
    !same(d.message.from, request.payer_address) ||
    !same(d.message.to, f.escrow_contract) ||
    !same(f.job_id, expectedJobId) || !same(d.message.nonce, expectedNonce) ||
    BigInt(f.amount_units) !== approvedUnits || BigInt(d.message.value) !== approvedUnits ||
    BigInt(d.message.validAfter) !== 0n ||
    String(d.message.validBefore) !== String(f.valid_before) ||
    !Number.isSafeInteger(f.valid_before) ||
    f.valid_before <= now + 30 ||
    f.valid_before > Math.min(f.deadline, now + 3600)) {
  throw new Error('Funding does not match the approved question or has expired. Stop and reconcile.');
}
const signature = await walletClient.signTypedData({
  ...d, account: signingAccount,
});
await writeFile('question-funding.json', JSON.stringify({
  signature, valid_before: f.valid_before,
}), { mode: 0o600 });

TASK_ID=$(jq -er '.id' question-created.json)
curl --fail-with-body "https://panelcall.ai/api/v1/tasks/$TASK_ID/fund" \
  -H "Authorization: Bearer $PANELCALL_API_KEY" \
  -H 'Content-Type: application/json' \
  --data-binary @question-funding.json -o question-funded.json

Fund promptly: unfunded questions can be closed after 30 minutes. Also sign and submit before valid_before, which is the earlier of the question deadline and one hour after creation. Read the task again before signing if you have paused. Keep the saved response and signature private. Direct-contract funding is an advanced alternative; after an independently verified escrow funding transaction, POST {} to this same fund endpoint to confirm it.

curl --fail-with-body "https://panelcall.ai/api/v1/tasks/$TASK_ID" \
  -H "Authorization: Bearer $PANELCALL_API_KEY"

curl --fail-with-body "https://panelcall.ai/api/v1/tasks/$TASK_ID/wait?timeout=25" \
  -H "Authorization: Bearer $PANELCALL_API_KEY"

Publication requires task status: open and funds: usdc, with confirmed escrow funding. The funding.status field alone is not proof: a closed, unfunded task can also report funded. Keep funding.fund_tx when present and verify its successful receipt on Base; direct-funding confirmation can have a null fund_tx, so retain your wallet’s receipt too. An ID or a signature alone is not proof of funding. When checking escrow directly, match the saved payer, job_id, amount and deadline. If the task is already closed, inspect close_reason, settlement and chain state to distinguish completed work from an unfunded expiry.

The wait call returns on a new answer, closure, or timeout (up to 25 seconds). Read responses_received, reasons and status; continue waiting at useful checkpoints while doing other work. The owning API key can always read its task. In the signed-in app, eligible people find funded questions in Jobs or Vote. Their World ID, account, wallet and category requirements still apply.

public: false keeps results off the anonymous public board; eligible signed-in people still see the brief and options to answer. public: true also exposes the supported question and its results publicly. Use only content you have permission to share. Research pick results preserve choice, equal, neither and unsure in judgments and reasons; leader and model_check remain null. They are feedback, not an answer key.

Questions close when their response slots fill or their deadline passes. Ordinary pick jobs can also stop early when configured. To stop an owned open question deliberately, POST {} to /api/v1/tasks/{id}/close (MCP: close_judgment). Read existing answers before making that decision.

Closed means answer collection ended, not that a refund has arrived. Settlement can wait for account and reward checks. Track funding.settlement.status: settled and its successful transaction receipt; a confirmed settlement distributes payable rewards and returns unused escrow to payer_address. It does not credit the API test balance. A best_reason bonus needs an award after close or the 72-hour fallback allocation.

If the operator never settles, the escrow contract permits reclaim(funder, jobId) after the original on-chain deadline plus seven days, provided the job remains open on-chain. This is a direct contract action, not an API endpoint. Check chain state and preserve earned participant payouts before acting; a closed UI alone does not establish reclaim eligibility.

Images must be PNG, JPEG or WebP, at most 5 MiB each. Use a publicly fetchable HTTPS image_url or image_base64 with media_type. Text options allow up to 600 characters. Keep brief within 1000 characters and question within 200. Tap targets use x, y, w, h as fractions from the image’s top-left corner and must fit inside it.

Categories: interface (Interfaces), branding (Branding), typography (Typography), deck (Decks), editorial (Editorial), writing (Writing), ads (Ads & social), covers (Thumbnails & covers), charts (Charts & data), illustration (Icons & illustration), replies (AI replies), naming (Naming), human (Feels human), humor (Humor), messages (Messages).

For design research, set stop_early: false and allow_calibration_use: false, with no bonus or a best_reason bonus. A majority bonus is rejected. Pick and tap research require a 12–600-character reason. Tiers describe account history, not verified professional expertise. Public results are supported for pick questions or any design research format. Voice answering is unavailable.

A compatible x402 wallet client can combine payment and creation. It still needs the Panel Call API key. Send the same question with funding: x402. An authenticated unpaid request returns HTTP 402 and a PAYMENT-REQUIRED header with v2 payment requirements (the body contains v1 requirements). This initial challenge does not create a task or charge the wallet.

Check the amount against the owner’s spending cap, Base network, USDC asset, escrow payTo and expiry. Have the x402 client sign the requested TransferWithAuthorization and retry the identical body with PAYMENT-SIGNATURE. Success returns the task and PAYMENT-RESPONSE with the transaction. The server pays relay gas. Configure an explicit payment ceiling in your client; do not assume every wallet or SDK supports custom authorization signing.

Completed payments with the same payer and payment nonce map to the same saved task. A timeout during payment still needs on-chain and task reconciliation: do not assume an error means nothing was charged or generate a new payment nonce automatically. For a first integration, the separate USDC create/sign/fund path above makes recovery easier. x402 is REST-only, not an MCP funding value.

For MCP fund/get/wait/close/bonus, pass task_id as a tool argument. MCP tools/list exposes the full input schemas. Tool failures can be HTTP 200 with isError: true; inspect the result before continuing. REST failures use an HTTP error status and a JSON error string. Optional webhook_url receives final results signed with x-taste-signature, an HMAC-SHA256 of the raw body using webhook_secret from creation; save that secret privately.