activate_trial
ChatGPTSave a payment method and activate the 7-day free trial with $10 credit (Bynn POST /v1/users/activate-trial). When to use: once the user has completed Stripe card setup client-side and you have a succeeded setup_intent_id and a payment_method_id. This attaches the card as the org's default, switches to the chosen plan on a 7-day trial (no immediate charge), and grants $10 of trial credit. Only allowed when the org is currently on the 'Trial' plan. Rate-limited (5/min). Requires: a dashboard access token (JWT) on the connection. Returns: {success: true, message, credit_amount: "$10.00", plan, trial_ends_at (ISO 8601)}. Errors: 400 (org not on the 'Trial' plan, SetupIntent not 'succeeded', or a Stripe error), 401 (missing/invalid token), 500 (unexpected activation failure).
add_dossier_note
ChatGPTAdd an admin note to a dossier (Bynn POST /v1/autodoc/dossiers/:dossier_token/notes). When to use: to record a review comment on a dossier. The note is authored by the dashboard user behind the JWT; the server stamps the author and organization. Requires: dashboard token (JWT). Returns: 201 with the created note (same serialized shape as list_dossier_notes items). Errors: 401 (auth), 404 (no such dossier), 422 (content over 2000 chars or invalid).
add_passkey
ChatGPTBegin adding a passkey to the authenticated user's account: get WebAuthn creation options (Bynn POST /v1/users/passkeys/add). When to use: to START registering a new passkey for the current user. This returns the WebAuthn PublicKeyCredentialCreationOptions plus a passkey_token; a browser client must then call navigator.credentials.create(...) with those options and complete the ceremony out-of-band. NOTE: this tool only issues the options — the verification/finish step is not exposed here. Rate-limited (10/min). Requires: a dashboard access token (JWT) on the connection. Returns: {options (WebAuthn creation options JSON), passkey_token}. The challenge is valid for 5 minutes. Errors: 400 (failed to create passkey options), 401 (missing/invalid token).
approve_approval
ChatGPTApprove a pending HITL approval (Bynn POST /v1/autodoc/approvals/:token/approve). When to use: to resolve a paused workflow approval with the 'approved' handle — this resumes the workflow down the approved branch. Only pending approvals on a dossier still awaiting approval can be resolved; a concurrent resolution returns 409. Requires: dashboard token (JWT). Returns: {token, status: 'approved', resolutionHandle: 'approved', resolvedAt, resolvedByEmail, comment}. Errors: 401 (auth), 404 (no such approval), 409 (already resolved, or dossier no longer awaiting approval), 422 (comment over 500 chars).
attach_dossier_tag
ChatGPTAttach an organization tag to a dossier (Bynn POST /v1/autodoc/dossiers/:dossier_token/organization_tags). When to use: to label a dossier with an existing org tag (create tags with create_organization_tag). Idempotent — attaching an already-attached tag is a no-op. Requires: dashboard token (JWT). Returns: {token, color, name, dossiersCount} for the tag. Errors: 401 (auth), 404 (dossier or tag not found in your organization).
cancel_billing_plan
ChatGPTSchedule cancellation of the current subscription (Bynn POST /v1/billing/cancel_plan). When to use: to cancel a paid plan. The plan stays active (and billing continues) until the end of the billing period unless immediate is true; the cancellation can be reversed by changing plan again before it takes effect (can_reactivate: true). Restrictions that return 400: no active subscription; already scheduled for cancellation; Trial plans cannot be cancelled; and a plan created today cannot be cancelled until the next day ("still being set up"). Requires: a dashboard access token (JWT) on the connection. Returns: {success, message, cancellation_date, cancellation_date_formatted, current_plan, billing_continues_until, can_reactivate}. Errors: 401 (auth); 400 (no subscription, already scheduled, trial plan, same-day cancellation, or cancellation failed).
cancel_session
ChatGPTCancel / abort a session (Bynn DELETE /v1/sessions/:session_id). When to use: when the applicant chooses to abort the flow, or when consent is refused. After cancellation get_session/get_session_preflight return 404/410. Requires: no API key — the session_id in the path is the credential. Returns: {status: "cancelled"}. Errors: 404 (invalid session).
change_billing_plan
ChatGPTChange the organization's subscription plan (Bynn POST /v1/billing/change_plan). When to use: to upgrade or downgrade. Preconditions: the org must already have a valid payment method AND a complete billing address — otherwise this returns 400 with requires_payment_method: true or requires_billing_address: true (add a card via create_setup_intent + confirm_payment_method, and set the address via update_company_details first). Call list_billing_plans first to confirm the target is a valid move. Requires: a dashboard access token (JWT) on the connection. Returns: {success, message, new_plan, plan_name, billing_cycle, effective_date, billable_days, current_balance, monthly_fee, monthly_commitment, monthly_commitment_pro_rate, due_today, confirmation_sent_to, is_queued_downgrade} (monetary fields are in dollars). Upgrades apply now; downgrades are queued until effective_date. Errors: 401 (auth); 400 (missing payment method / billing address, invalid or Enterprise plan, or the plan change failed).
check_age
ChatGPTEstimate the age of faces in an image (age verification / minor detection). Runs the age-detection moderation model (Bynn POST /v1/moderation/infer). Use this to estimate a person's age from a photo — e.g. age-gating or detecting minors. For an attached/uploaded image use the image file param; a URL uses image_url. Synchronous. Requires: a Bynn access token (dashboard JWT) or an API key on the connection. Returns: {success, data: {num_faces, image_size: {width, height}, faces: [ { age (estimate), from_age, to_age (range), is_minor, challenge_25 (looks under 25), sex, sex_code, confidence, uncertainty, bbox: {x1, y1, x2, y2} } ]}}. An empty faces list (num_faces 0) means no face was detected. Errors: 401 (auth), 402 (insufficient balance), 403 (model needs a higher plan), 404 (model not found), 422 (missing/invalid image).
check_email_verification
ChatGPTComplete email verification with the code (Bynn PATCH /v1/sessions/:session_id/email_verification). When to use: after start_email_verification, submit the code the applicant received. Note: after too many wrong attempts the step is marked failed but still returns {status: "accepted"} so the flow can continue. Re-poll get_session_preflight after. Requires: no API key — the session_id in the path is the credential. Returns: {status: "accepted"}. Errors: 404 (invalid session, or wrong code — invalid_code_retry).
check_phone_verification
ChatGPTComplete phone verification with the SMS code (Bynn PATCH /v1/sessions/:session_id/phone_verification). When to use: after start_phone_verification, submit the code the applicant received. Note: after too many wrong attempts the step is marked failed but still returns {status: "accepted"} so the flow can continue. Re-poll get_session_preflight after. Requires: no API key — the session_id in the path is the credential. Returns: {status: "accepted"}. Errors: 404 (invalid session, or wrong code — invalid_code_retry).
complete_age_verification_liveness
ChatGPTFinalize a liveness capture (Bynn GET /v1/age_verification/liveness/:age_verification_id/complete). When to use: STEP 3 of the liveness flow, after the browser SDK has finished the live face capture (i.e. after start_age_verification_liveness). This pulls the liveness results from AWS Rekognition and runs the age/face analysis, storing it on the session. Once this succeeds, call get_age_verification_result(age_verification_id, ...) to read the age estimate. Requires: no API key — the age_verification_id in the path is the credential (client-side/session call). Returns: {verification: "completed", status} where status is the liveness capture status (e.g. created, succeeded, failed, expired). Errors: 400 (no reference image — the capture was not actually performed), 404 (session not found, expired, or no liveness session present for this id).
complete_liveness
ChatGPTComplete a face-liveness capture (Bynn POST /v1/sessions/:session_id/liveness/complete). When to use: AFTER the liveness capture SDK finishes (following start_liveness), to fetch the result and tell whether it succeeded or must be re-run. Then re-poll get_session_preflight. Requires: no API key — the session_id in the path is the credential. Returns: {verification: "completed", status} where status is the lowercased liveness result (e.g. "succeeded" | "failed"). Errors: 400 (could not complete liveness), 404 (invalid session, or no liveness session was started — call start_liveness first).
confirm_payment_method
ChatGPTSave the confirmed card as the default payment method (Bynn POST /v1/billing/confirm_payment_method). When to use: STEP 2 of adding a card, after the client-side Stripe.js confirms the SetupIntent from create_setup_intent. This attaches the PaymentMethod to the Stripe customer, sets it as default, and stores card + billing-address details on the org (and, where a payment mandate is required, e.g. India, creates the Stripe subscription). Precondition: the SetupIntent must have status 'succeeded' — otherwise 400. Requires: a dashboard access token (JWT) on the connection. Returns: {success, payment_method: {id, card_brand, last4, exp_month, exp_year, cardholder_name, is_default, created_at, billing_address}}. Errors: 401 (auth); 400 (SetupIntent not succeeded, or Stripe error type: "stripe_error"); 500 (failed to save).
create_age_verification_session
ChatGPTCreate a new liveness age-verification session (Bynn POST /v1/age_verification/liveness). When to use: this is STEP 1 of the higher-security liveness flow. It opens a session and records the user's consent. Next call start_age_verification_liveness(session_id) to obtain the temporary AWS Rekognition credentials the browser SDK needs to run the live face capture. (For a quick, lower-security check with no liveness, use verify_age_from_selfie instead.) Requires: a Public API key on the connection. Billable: consumes one liveness verification credit; a 402 insufficient_balance error means the org must top up. Returns: {session_id} — the session token. Pass this same value as the session_id / age_verification_id argument to every later step of the flow. Errors: 400 (could not start liveness), 401 (missing/invalid public key), 402 (insufficient balance).
create_document_collection
ChatGPTCreate a document collection (Bynn POST /v1/autodoc/collections). When to use: to define a new reusable set of document requirements that a workflow's upload node can reference. Use list_document_types first to pick valid documentType identifiers. Requires: dashboard token (JWT). Returns: 201 with the created collection (same shape as get_document_collection). Errors: 401 (auth), 400 (a document has more than 50 OCR fields), 422 (validation — invalid document type, missing required requirement fields, etc.).
create_face_collection
ChatGPTCreate a new face collection (Bynn POST /v1/face-collections). When to use: FIRST step of any face workflow. A collection groups enrolled faces so you can later search/identify against them. Do this before enroll_face or search_faces. Requires: a Private API key OR a dashboard token on the connection. Returns: {collection_id (fc_...), name, description, face_count, created_at}. - Pass collection_id to enroll_face, search_faces, and delete_face_collection. Errors: 401 (missing/invalid auth), 422 (validation, e.g. missing name), 429 (rate limit: 30/min).
create_fraud_agent
ChatGPTCreate a fraud-analysis agent / operator (Bynn POST /v1/reasoning/agents/fraud-analysis). When to use: to build a specialized tool agent that an orchestrator can call. The new agent is active and uses your org's default LLM. Assign it to orchestrators now via orchestratorIds, or later via create_orchestrator/update_orchestrator. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the full operator object (token, name, toolType, description, systemPrompt, priority, capabilities, status, ...). Save the token. Errors: 401 (auth), 403 (an orchestratorIds orchestrator not found in your org), 422 (validation), 429 (rate limited).
create_invitation
ChatGPTSend an AutoDoc invitation by email or SMS (Bynn POST /v1/autodoc/invitations). When to use: to invite a recipient to start a workflow. The recipient gets a link (https://start.auto-doc.ai/<workflow_token>?invitation_token=<adi_...>) that opens the visitor app and links the resulting dossier back to this invitation. Delivery is async: status advances pending -> sent -> delivered -> opened -> started. Links expire after 30 days. NOT idempotent — repeated calls create new invitations (send a unique reference and check list_invitations first if you need de-duplication). Billable: one send credit per invitation (test keys are not billed). Requires: a private API key (private_...) OR a dashboard token (JWT). Returns: 201 with the invitation entity (token adi_..., status, recipient, workflow, reference, timestamps). Errors: 400 (invalid request), 401 (auth), 402 (insufficient balance), 404 (workflow not found), 422 (validation — bad recipient/channel), 429 (rate limit / daily cap).
create_moderation_inference
ChatGPTRun a moderation / AI-detection inference (Bynn POST /v1/moderation/infer). When to use: to moderate or analyze a single piece of content with a named model. First choose a model api_name via list_all_moderation_models / get_moderation_model, then supply the input that matches the model's TYPE: - text model -> content - image model -> image_url OR base64_image (or base64_pdf for vlm-ocr) - video model -> video_url OR base64_video (wanted-person-detection also accepts image_urls/base64_images batches — do not mix video and images) - audio model -> audio_url OR base64_audio This runs SYNCHRONOUSLY: the result is returned inline (no polling needed). Requires: a dashboard token (JWT) or a private API key on the connection. Billable — charges one credit per inference (video/audio billed per minute, PDF/batch per page/ image). Test API keys skip billing and return mock results. Returns (InferenceEntity): inference_id (e.g. inf_abc123), model_id, model_name, moderation_type (image|video|audio|text), status (pending|processing|completed|failed), result (the model's output object), input_url, response_time_ms, duration_seconds, billable_quantity, cost (e.g. $0.00010), created_at, completed_at, and error_message if it failed. Errors: 401 (missing/invalid credential), 402 (insufficient_balance — top up), 403 (plan_upgrade_required — model needs a higher plan), 422 (invalid/unknown model, missing or too-large input, e.g. content_required, image_input_required, image_too_large, too_many_images), 500 (inference/billing error — auto-refunded).
create_orchestrator
ChatGPTCreate an orchestrator (coordinator) agent (Bynn POST /v1/reasoning/agents/orchestrators). When to use: to build a coordinator that runs reasoning jobs over documents. Create your fraud-analysis agents first (create_fraud_agent) so you can pass their tokens in assignedAgentIds. The new orchestrator is active and uses your org's default LLM. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the full orchestrator object (token, name, description, systemPrompt, coordinationStrategy, assigned agents, status, ...). Save the token. Errors: 401 (auth), 403 (an assignedAgentIds operator not found in your org), 422 (a documentContentTypes value already assigned to another orchestrator, or other validation), 429 (rate limited).
create_organization_tag
ChatGPTCreate an organization tag (Bynn POST /v1/autodoc/organization_tags). When to use: to define a new reusable dossier label. Max 100 tags per organization. Requires: dashboard token (JWT). Returns: 201 with {token, color, name, dossiersCount: 0}. Errors: 401 (auth), 400 (name over 50 chars), 422 (invalid color or tag limit reached).
create_reasoning_job
ChatGPTQueue an ASYNCHRONOUS fraud-reasoning job for a document (Bynn POST /v1/reasoning/jobs). When to use: to run an orchestrator over a document without blocking. This returns immediately with a job token; poll get_reasoning_job(id) until status is completed or failed. For an inline/blocking run instead, use test_orchestrator. Prefer orchestratorId when you want a specific coordinator. Requires: a dashboard token (JWT). Rate limit: 10/min. Consumes LLM tokens on execution. Returns: {id (job token), status, triggerType, documentId, documentName, orchestratorId, orchestratorName, createdAt, message}. Errors: 401 (auth), 404 (document not found in your org), 422 (no active orchestrator available to run), 429 (rate limited).
create_session
ChatGPTCreate a new identity-verification session (Bynn POST /v1/sessions). When to use: to START a KYC verification for an applicant. This is the ONLY session tool that needs a credential — a Public API key. All later tools use the returned session_id instead. Give the applicant the returned url (or QR code) to run the hosted flow, or drive it yourself with the other tools in this module. Requires: a Public API key on the connection. Billable: consumes one KYC verification credit per non-test session (test/sandbox keys are free). Returns: {session_id, dossier_id, url, qr_base64_png, branding{...}, websocket_url}. - session_id is the session token you pass to every other tool here. - url is the hosted verification page for the applicant. - branding carries the org's name, colors, logos and consent/terms/privacy links. Errors: 401 (missing/invalid public key), 402 (insufficient_balance — no active plan; top up or use sandbox keys), 404 (invalid/deleted KYC level).
create_setup_intent
ChatGPTCreate a Stripe SetupIntent to collect a payment method (Bynn POST /v1/billing/create_setup_intent). When to use: STEP 1 of adding or replacing a card. Creates (or reuses) the org's Stripe customer and returns a client_secret your client-side Stripe.js confirms the card against. After the customer completes card entry, call confirm_payment_method with the resulting setup_intent_id and payment_method_id to save it (STEP 2). Requires: a dashboard access token (JWT) on the connection. Returns: {client_secret, setup_intent_id, customer_id, success}. Errors: 401 (auth); 400 (Stripe error, type: "stripe_error"); 500 (setup failed).
create_website
ChatGPTCreate a new age-verification website configuration (Bynn POST /v1/websites). When to use: to register a new website/app that will host a Bynn age gate. Only name, domain, and age_restriction are required; every other field is optional and, if omitted, takes the server default noted in its description. Only the arguments you pass are sent. Look up enabled_countries codes with list_countries first. Requires: a dashboard token (JWT) or private API key on the connection. Rate limit: 10 requests/minute. Returns: the created website object (same shape as get_website), including its new id and asset_id to use in later calls. Errors: 401 (missing/invalid token), 422 (validation error — e.g. bad age_restriction value, missing required field, or invalid domain; the message lists the offending fields).
create_workflow
ChatGPTCreate a workflow (Bynn POST /v1/autodoc/workflows). When to use: to define a new visitor journey. NOTE: the server always saves a new workflow with status: 'active' regardless of any status you set. Supports an Idempotency-Key on the wire (not exposed here) for safe retries. Requires: dashboard token (JWT). Returns: 201 with the created workflow (same shape as get_workflow). Errors: 401 (auth), 422 (validation).
delete_document
ChatGPTDelete a document submission (Bynn DELETE /v1/documents/:id). When to use: to purge a previously submitted document. Idempotent — deleting an already-deleted document still succeeds. After deletion, get_document returns 404. Requires: a Private API key on the connection. Returns: {submission_id, document_id, status: "deleted", deleted_at}. Errors: 401 (missing/invalid key), 404 (no such document in this organization).
delete_document_collection
ChatGPTDelete a document collection (soft delete) (Bynn DELETE /v1/autodoc/collections/:id). When to use: to retire a collection. This soft-deletes the collection and all of its document requirements. Returns an empty body on success (204 No Content). Requires: dashboard token (JWT). Returns: {} on success. Errors: 401 (auth), 404 (no such collection).
delete_face
ChatGPTDelete a single enrolled face from a collection (Bynn DELETE /v1/face-collections/:collection_token/faces/:face_token). When to use: to remove one enrolled face. IRREVERSIBLE — the face embedding is permanently deleted. To delete the whole collection, use delete_face_collection. Requires: a Private API key OR a dashboard token on the connection. Returns: {success: true}. Errors: 401 (missing/invalid auth), 404 (collection or face not found), 429 (rate limit: 30/min).
delete_face_collection
ChatGPTDelete a face collection and ALL its enrolled faces (Bynn DELETE /v1/face-collections/:token). When to use: to permanently remove a collection. IRREVERSIBLE — every face embedding inside it is destroyed too. To remove a single face instead, use delete_face. Requires: a Private API key OR a dashboard token on the connection. Returns: {success: true}. Errors: 401 (missing/invalid auth), 404 (no such collection in this organization), 429 (rate limit: 10/min).
delete_fraud_agent
ChatGPTDelete a fraud-analysis agent / operator (Bynn DELETE /v1/reasoning/agents/fraud-analysis/:id). When to use: to permanently remove an operator. Its orchestrator assignments are removed automatically. Blocked if it is assigned to any orchestrator that currently has queued or running reasoning jobs. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {id, name, message}. Errors: 401 (auth), 404 (no such agent), 422 (assigned to an orchestrator with active jobs — the error lists those orchestrators), 429 (rate limited).
delete_invitation
ChatGPTCancel (hard-delete) a pending AutoDoc invitation (Bynn DELETE /v1/autodoc/invitations/:token). When to use: to cancel an invitation that has not been sent yet. Only invitations in 'pending' status can be cancelled; anything already sent or beyond returns 422. Returns an empty body (204 No Content). Requires: dashboard token (JWT). Returns: {} on success. Errors: 401 (auth), 404 (not found), 422 (invitation is not pending).
delete_orchestrator
ChatGPTDelete an orchestrator agent (Bynn DELETE /v1/reasoning/agents/orchestrators/:id). When to use: to permanently remove an orchestrator and its associated reasoning jobs. Blocked while it has queued or running jobs — wait for them to finish (poll list_reasoning_jobs) before deleting. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {id, name, message}. Errors: 401 (auth), 404 (no such orchestrator), 422 (has active queued/running reasoning jobs), 429 (rate limited).
delete_organization_tag
ChatGPTDelete an organization tag (Bynn DELETE /v1/autodoc/organization_tags/:id). When to use: to remove a tag entirely. This cascades — the tag is detached from every dossier that carried it. Returns an empty body (204 No Content). Requires: dashboard token (JWT). Returns: {} on success. Errors: 401 (auth), 404 (no such tag).
delete_passkey
ChatGPTDelete one of the authenticated user's passkeys (Bynn DELETE /v1/users/passkeys/:id). When to use: to remove a specific passkey (found via list_passkeys). Blocked if it is the user's ONLY authentication method (i.e. their last passkey and they have no email/password login). Rate-limited (10/min). Requires: a dashboard access token (JWT) on the connection. Returns: {success: true, message, remaining_passkeys (int)}. Errors: 401 (missing/invalid token), 404 (no passkey with that id/token for this user), 422 (cannot delete the only remaining authentication method, or delete failed).
delete_website
ChatGPTPermanently delete an age-verification website configuration (Bynn DELETE /v1/websites/:id). When to use: to remove a website/app entirely. This is irreversible — the age gate stops working for that domain. Requires: a dashboard token (JWT) or private API key on the connection. Rate limit: 10 requests/minute. Returns: {success: true, message, deleted_id, deleted_asset_id}. Errors: 401 (missing/invalid token), 404 (no such website in this organization), 422 (delete failed).
delete_workflow
ChatGPTDelete a workflow (soft delete) (Bynn DELETE /v1/autodoc/workflows/:id). Requires: dashboard token (JWT). Returns: {message: "Workflow deleted successfully"}. Errors: 401 (auth), 404 (no such workflow), 422 (delete failed).
describe_api
ChatGPTReturn the Bynn REST API's OpenAPI 3.0 specification (from /openapi.json). When to use: to discover the FULL Bynn API — every path, method, parameter, request body, and response schema — including endpoints or fields not wrapped as MCP tools here. Use it to understand a field, find an endpoint, or answer "what can the Bynn API do?". No authentication required. Returns: the raw OpenAPI 3.0 document (openapi, info, paths, components, ...). On failure returns {error: true, message: ...}.
describe_cli
ChatGPTReturn install, auth, and usage instructions for the Bynn CLI (bynn). When to use: when you are an agent running on the user's machine (Claude Code, Cursor, a terminal) and need Bynn against LOCAL files or scripts — e.g. bynn submit ./statement.pdf (full document-fraud analysis) or bynn ai-generated ./photo.png — files this hosted server cannot read. Also to answer "how do I install or use the Bynn CLI?". No authentication required. Returns: a static structured guide — install (Homebrew, Scoop, direct download), auth (interactive login, non-interactive options, key prefixes), commands (structure, meta commands, API coverage and gaps), agent_usage (flags, output contract, worked examples), and when_to_prefer_cli_over_mcp.
detach_dossier_tag
ChatGPTDetach an organization tag from a dossier (Bynn DELETE /v1/autodoc/dossiers/:dossier_token/organization_tags/:tag_token). When to use: to remove a tag label from a dossier. Idempotent — detaching a tag that isn't attached still succeeds. Returns an empty body (204 No Content). Requires: dashboard token (JWT). Returns: {} on success. Errors: 401 (auth), 404 (dossier or tag not found in your organization).
detect_ai_generated_image
ChatGPTCheck whether an image is AI-generated or a real photo. Runs the ai-generated-image moderation model (Bynn POST /v1/moderation/infer). Use this to tell whether a single image was produced or edited by a generative/AI model versus captured authentically. Runs synchronously and returns the result immediately. HOW TO SUPPLY THE IMAGE (pick one): • The user ATTACHED/uploaded an image -> ALWAYS call with the image file parameter. Just include it; the host fills it with the attachment ({download_url,...}) and the server fetches and analyzes it. Do NOT base64-encode the attachment yourself and do NOT pass a sandbox/client path. If your host cannot fill the parameter, the tool simply falls back to an upload card (see below) — including image is never wrong. • The user gave a URL -> call with image_url. • A file path THIS server can read (self-hosted MCP) -> file_path. • base64_image also works but avoid it for large images (it bloats the conversation). If the result comes back with needs_image (the host didn't forward the attachment), the rendered card contains a drag-and-drop uploader: tell the user to drop the image into the card and it will be checked directly — do not retry with self-made base64 or file paths. Requires: a Bynn access token (dashboard JWT) or an API key on the connection. Returns: {inference_id, model_id, model_name, moderation_type: "image", status, response_time_ms, created_at, completed_at, result: { ai_probability (0-1), is_ai_generated (bool — the verdict), uncertain (bool), source, top_generator: {name, probability} — the generator most likely used, e.g. midjourney/flux_1, generators: [{name, probability}], c2pa_signer, detection_mode }}. Read result.is_ai_generated for the yes/no and result.ai_probability for confidence. (Convenience wrapper over create_moderation_inference with model="ai-generated-image"; use that tool with a different model for other checks.) Errors: 401 (auth), 402 (insufficient balance), 403 (model needs a higher plan), 404 (model not found), 422 (missing/invalid image).
download_dossier_zip
ChatGPTPackage a dossier's documents + variables into a ZIP (Bynn POST /v1/autodoc/dossiers/:id/download_zip). When to use: to export a whole dossier — all uploaded documents plus a data.json of the workflow variables — as a single ZIP. This also flips the dossier's download_status to 'downloaded' as a side effect. Heavily rate limited (3 requests/min per org). IMPORTANT: the response body is the raw binary ZIP, NOT JSON — this tool surfaces it under a raw key rather than structured fields. Limits: max 100 documents, 50 MB per file, 500 MB total. Requires: dashboard token (JWT). Returns: {raw: <zip bytes as text>} on success. Errors: 401 (auth), 404 (no such dossier), 400 (too many docs / file or total size over limit), 500 (packaging failed).
download_invoice
ChatGPTDownload an invoice as a PDF (Bynn GET /v1/billing/invoices/:id/download). When to use: to fetch the PDF receipt for a specific invoice from list_invoices. Only succeeded/paid invoices can be downloaded. The response is a binary PDF (Content-Type application/pdf), so this JSON client returns it under a raw field rather than a parsed object — prefer the hosted_invoice_url / pdf_url from list_invoices when you just need a link to hand to the user. Requires: a dashboard access token (JWT) on the connection. Returns: the raw PDF bytes (as {"raw": ...} when not JSON-decodable). Errors: 401 (auth); 403 (invoice not payable/available for download); 404 (no such invoice for this organization).
duplicate_workflow
ChatGPTDuplicate a workflow (Bynn POST /v1/autodoc/workflows/:id/duplicate). When to use: to clone an existing workflow as a starting point for a new one. Creates a brand-new workflow (with its own id/token) copying the source's definition. Requires: dashboard token (JWT). Returns: the newly created workflow (same shape as get_workflow). Errors: 401 (auth), 404 (no such workflow), 422 (duplication failed).
enroll_face
ChatGPTEnroll a single face into a collection (Bynn POST /v1/face-collections/:token/enroll). When to use: to add a known reference face to a collection so it can later be matched by search_faces. The image MUST contain EXACTLY ONE face — zero or multiple faces are rejected. Create the collection first with create_face_collection. Requires: a Private API key OR a dashboard token on the connection. Returns: {face_id (face_...), name, external_id, category, metadata, created_at}. - Keep face_id to later remove this face with delete_face. Errors: 400 (no face detected, or multiple faces detected in the image), 401 (missing/invalid auth), 404 (collection not found), 422 (validation: no image input, image/metadata too large, or extraction failed), 429 (rate limit: 30/min).
generate_fraud_agent_prompt
ChatGPTDraft a fraud-analysis agent system prompt with AI (Bynn POST /v1/reasoning/agents/fraud-analysis/generate-prompt). When to use: before create_fraud_agent, to auto-generate a system prompt, a suggested name, and a short description from a tool type + description. Nothing is persisted — feed the returned prompt into create_fraud_agent(prompt=...). Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {prompt, agentName, shortDescription}. Errors: 401 (auth), 422 (validation), 429 (rate limited).
generate_orchestrator_prompt
ChatGPTDraft an orchestrator system prompt with AI (Bynn POST /v1/reasoning/agents/orchestrators/generate-prompt). When to use: before create_orchestrator, to auto-generate a good system prompt, a suggested name, and a short description from a plain description. Nothing is persisted — feed the returned prompt into create_orchestrator(prompt=...). Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {prompt, agentName, shortDescription}. Errors: 401 (auth), 422 (validation), 429 (rate limited).
get_age_verification_result
ChatGPTRead the result of a liveness age-verification session (Bynn GET /v1/age_verification/liveness/:age_verification_id). When to use: STEP 4 (final) of the liveness flow, after complete_age_verification_liveness has succeeded. Returns the age estimate, the pass/underage decision for the chosen model, and the liveness verdict. Requires: a Private API key on the connection. Returns (key fields): unique_id (your identifier for the user), is_adult (bool), verification_status (pass|underage|unknown|pending|error), age_verification_model, confidence (high|moderate|low), age_estimated (int), age_range: {low, high}, face: {glasses, predicted_gender}, liveness: {status (verified|not_verified| not_evaluated), confidence}, image_saved, biometrics_saved, evaluated_at, data_destroyed_at. Errors: 401 (missing/invalid private key), 404 (invalid session), 482 (no age-verification data — liveness not completed — or more than one face), 483 (no face detected), 484 (could not estimate age).
get_age_verification_status
ChatGPTRe-check a prior age-verification result server-side (Bynn GET /v1/agemin/check/status/:session_token). When to use: run this on your BACKEND after a verification completes to confirm the result and detect any frontend tampering with the age/verdict. It reads the stored session verdict WITHOUT exposing the person's actual estimated age (privacy-preserving). Do NOT call this from the frontend — it requires your private key. Input: the session_token you received from verify_age_with_selfie / verify_age_with_email. Requires: a Private API key on the connection. Not billable. Returns: {status: "ok", reference (your reference_id), timestamp (session created_at), result: {session_token, age_threshold, confidence, verification_status (pass|underage), is_adult, is_of_age, passed (bool), face_confidence, domain, asset_token}}. Errors: 401 (missing/invalid key), 404 invalid_session (no session with that token in your organization).
get_agent
ChatGPTGet a single agent (orchestrator or operator) by token (Bynn GET /v1/reasoning/agents/:id). When to use: to fetch full details of one agent when you have its token but don't know whether it is an orchestrator or a fraud-analysis agent. The response is formatted for whichever type matches. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the full orchestrator or operator object. Errors: 401 (auth), 404 (no agent with that token in your org), 429 (rate limited).
get_agent_stats
ChatGPTGet aggregate agent statistics for your organization (Bynn GET /v1/reasoning/agents/stats). When to use: for a quick org-wide summary across orchestrators and operators. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {activeAgents, totalAgents, avgTaskTime, errorCount, successRate, tasksCompletedToday, tasksInQueue}. Errors: 401 (auth), 429 (rate limited).
get_api_key
ChatGPTRetrieve the FULL, unmasked value of an existing API key (Bynn GET /v1/api_keys/:id). When to use: when you need the actual key string for a key you already know the id of (from list_api_keys). Unlike list_api_keys, the key field here holds the complete secret — handle it carefully and never log it. Requires: a dashboard access token (JWT) on the connection. Returns: a single key object {id, name, key (FULL value), key_type, is_test, created_at, expires_at, last_used_at, stats}. Errors: 401 (missing/invalid token), 403 (your role may not access API keys), 404 (no key with this id in your organization), 429 (rate limited — max 10/min).
get_autodoc_dashboard_stats
ChatGPTGet aggregated AutoDoc dashboard statistics (Bynn GET /v1/autodoc/dashboard/stats). When to use: to power an overview screen — KPI counts, a daily dossier series, and recent activity for your organization. Cached ~60s server-side. Requires: dashboard token (JWT). Returns: {counts: {approved, rejected, needsAttention, hitlPending, thisMonth, total}, monthlySeries: [{date, approved, rejected, needsAttention}], recentActivity: [{type, dossierToken, name, status, createdAt}]}. Errors: 401 (auth).
get_billing_info
ChatGPTGet the full billing snapshot for the organization (Bynn GET /v1/billing/info). When to use: the one-stop call to read everything about the org's billing at once — current plan (name, price, feature limits, can_upgrade/can_downgrade), saved payment method (brand, last4, expiry, billing address), company/invoicing details, prepaid current_balance/ledger_balance, current_usage for the period (per-service counts, unit prices, unbilled total, usage trend), next_billing_date, recharge_settings (auto top-up thresholds), and any scheduled subscription change (downgrade/cancel). For a lighter, usage-only view use get_current_usage; for plan options use list_billing_plans. Requires: a dashboard access token (JWT) on the connection. Returns: a billing_info object with current_plan, payment_method (null if none), company_details, current_usage, current_balance, ledger_balance, next_billing_date, recharge_settings, and subscription. Errors: 401 (missing/invalid token), 422 (date_range_too_large if range > 90 days, or invalid_date_range if end_date precedes start_date).
get_current_usage
ChatGPTGet the current billing period's unbilled usage (Bynn GET /v1/billing/current_usage). When to use: to check how much has accrued this month before it is invoiced. Lighter than get_billing_info — returns only usage, not plan/payment/company data. Requires: a dashboard access token (JWT) on the connection. Returns: {billing_period_start, billing_period_end, unbilled_events, total_unbilled_amount, estimated_invoice_date, usage_trend: {percentage_change, direction}}. unbilled_events contains only services with non-zero usage this period (e.g. selfie_age_estimation, email_age_estimation, liveness_sdk, vpn_check, country_lookup), each with count, unit_price, total_cost, event_type, and display_name. Errors: 401 (missing/invalid token).
get_current_user
ChatGPTGet the authenticated user, their organization, and quick account stats (Bynn GET /v1/users/me). When to use: to identify who the current connection belongs to, read the org's plan/name, or show at-a-glance verification stats. This is the natural first call to confirm the connection is authenticated and to fetch the org token used by other account flows. Requires: a dashboard access token (JWT) on the connection. Returns: - user: {id (e.g. user_xyz...), token, email, name, intercom_jwt, createdAt} - organization: {token, name, plan (e.g. "free"), created_at (unix), show_onboarding_survey (bool), show_offer (bool)} show_onboarding_survey is true until submit_onboarding_survey marks it complete. - stats: {totalVerifications, monthlyVerifications, successRate (0-100), activeApiKeys} — age-verification session counts for the org. Errors: 401 (missing/invalid token), 404 (user not found for the token).
get_document
ChatGPTRetrieve a document submission and its forensic analysis result (Bynn GET /v1/documents/:id). When to use: after submit_document, poll this to get the analysis. Analysis is async — status is pending until it finishes, then analyzed (or error). Poll about every 3 minutes until status is analyzed (rate limit 500/min per org). Requires: a Private API key on the connection. Returns (key fields): status (pending|analyzed|error), analysis_risk_status (pending|trusted|low|medium|high|fraud|rejected), analysis_risk_score (0-100), document_content_type, AI-generation signals (ai_generated_score, ai_deepfake_score), detailed findings (image_manipulation, tampering_results, address_validation, ...), risk_tags, signed original_file_url/media, and your reference_id. Errors: 401 (missing/invalid key), 404 (no such document in this organization; deleted documents also return 404).
get_document_collection
ChatGPTGet one document collection and its requirements (Bynn GET /v1/autodoc/collections/:id). Requires: dashboard token (JWT). Returns: {id, name, description, status, documents: [{name, documentType, documentTypeLabel, mandatory, allowMultiple, requestSides, ...ai/ocr/fraud flags...}], createdAt, updatedAt, totalRequired, totalOptional}. Errors: 401 (auth), 404 (no such collection in your organization).
get_dossier
ChatGPTGet one dossier with progress and workflow variables (Bynn GET /v1/autodoc/dossiers/:id). When to use: to inspect a single recipient's run — collected form variables, progress through the workflow nodes, case status, and tags. Use list_dossier_documents for the uploaded files and list_dossier_notes for the audit timeline. Requires: dashboard token (JWT). Returns: {id, name, workflowId, workflowName, workflowStatus, status, downloadStatus, customerIdentification, variables (form field values), progress: {totalNodes, completedNodes, currentNodeId, percentage}, documentsCollected, documentsRequired, tags, createdAt, updatedAt, completedAt}. Errors: 401 (auth), 404 (no such dossier in your organization).
get_dossier_form_fields
ChatGPTList form-field names available across your active workflows (Bynn GET /v1/autodoc/dossiers/form_fields). When to use: before calling list_dossiers with variable_filters, to discover which form-input field names exist and how to reference them. Fields used by only one workflow (or where all workflows agree on label/type) come back as workflowScope: 'shared'; colliding names come back as multiple workflowScope: 'scoped' entries, each with a workflowToken — pass that as wf_<token>:<name> in variable_filters to disambiguate. Requires: dashboard token (JWT). Returns: {data: [{name, label, type, legacyName, workflowScope ('shared'|'scoped'), workflowToken, workflows: [{token, name}], usageCount}]}, most-used first. Errors: 401 (auth).
get_invitation
ChatGPTGet a single AutoDoc invitation (Bynn GET /v1/autodoc/invitations/:token). When to use: to poll one invitation's lifecycle status after creating it. Requires: a private API key (private_...) OR a dashboard token (JWT). Returns: the invitation entity (token, status, channel, recipient, reference, workflow, linked dossier token, timestamps). Errors: 401 (auth), 404 (no such invitation in your organization).
get_moderation_dashboard_stats
ChatGPTGet moderation dashboard statistics for your organization (Bynn GET /v1/moderation/dashboard/stats). When to use: to show an overview of moderation usage — totals, a 30-day activity timeline, most-used models, and recent inferences. Requires: a dashboard token (JWT) on the connection. Returns: {total_inferences, monthly_inferences, monthly_activity: [{date, image_count, video_count, audio_count, text_count}], top_models: [{model_name, model_id, moderation_type, count, percentage}], recent_activity: [{id, status, message, website_name, country_code, time_ago}]}. Errors: 401 (missing/invalid dashboard token).
get_moderation_inference
ChatGPTRetrieve a past moderation inference by its id (Bynn GET /v1/moderation/inference/:token). When to use: to re-read the result/status of an inference you created earlier (results are also returned inline by create_moderation_inference, so this is mainly for lookup). Requires: a dashboard token (JWT) or a private API key on the connection. Returns (InferenceEntity): same shape as create_moderation_inference — inference_id, model_id, model_name, moderation_type, status, result, response_time_ms, cost, created_at, completed_at, and error_message when failed. Errors: 401 (missing/invalid credential), 404 (no such inference in your organization).
get_moderation_model
ChatGPTGet one moderation model with full documentation (Bynn GET /v1/moderation/models/:api_name). When to use: after finding an api_name in a list tool, call this to read that model's complete details before running it — including the input_schema/output_schema, example_request/example_response, supported formats, pricing, and rich HTML documentation. Requires: nothing (public, cached ~1 hour). Returns (ModerationModelEntity): id, api_name, name, description, category, moderation_type, accuracy, avg_response_time_ms, pricing, all_plans_pricing, supported_formats, max_file_size_mb, tags, input_schema, output_schema, example_request, example_response, require_plan, sample_content, version, documentation_image_url, and documentation (HTML). Errors: 404 (model not found, inactive, or hidden), 500 (failed to fetch model).
get_pending_approval_count
ChatGPTGet the count of pending HITL approvals (Bynn GET /v1/autodoc/approvals/pending_count). When to use: for a sidebar badge — how many workflow approvals are waiting for an admin decision in your organization. Requires: dashboard token (JWT). Returns: {count: N}. Errors: 401 (auth).
get_reasoning_job
ChatGPTGet a reasoning job's status and full results (Bynn GET /v1/reasoning/jobs/:id). When to use: after create_reasoning_job, poll this until status is completed (or failed/cancelled); it is queued/running until then. When complete it carries the fraud decision (fraud score, decision, confidence, reasoning, red flags, evidence) and the orchestrator/operator conversation detail. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the full job detail object (status, document + orchestrator info, results, conversation, timing/token usage). Errors: 401 (auth), 404 (no such job in your org), 429 (rate limited).
get_session
ChatGPTShow information about an open session (Bynn GET /v1/sessions/:session_id). When to use: to re-read a session's hosted url, branding, and websocket_url (e.g. to re-display the flow). For the next verification STEP use get_session_preflight instead. Requires: no API key — the session_id in the path is the credential. Returns: {session_id, url, qr_base64_png, branding{...}, websocket_url}. Errors: 404 (invalid session — unknown or already closed), 410 (session canceled or consent not given).
get_session_preflight
ChatGPTGet the next verification step for a session (Bynn GET /v1/sessions/:session_id/preflight). When to use: this is the FLOW DRIVER. Poll it after each completed action to learn what the applicant must do next (e.g. capture ID document, do liveness, verify phone). Consent must already be given (give_session_consent) or this returns 451. Requires: no API key — the session_id in the path is the credential. Returns: a preflight object describing the current/next step and overall progress. Errors: 404 (invalid session), 410 (session canceled or consent not given), 451 (no consent yet — call give_session_consent first).
get_stripe_config
ChatGPTGet Stripe client-side configuration (Bynn GET /v1/billing/stripe_config). When to use: before building a Stripe payment/card UI. Returns the publishable key and feature flags needed to initialize Stripe.js / Payment Element on the client. This is a prerequisite context call for the create_setup_intent -> confirm_payment_method flow. Requires: a dashboard access token (JWT) on the connection. Returns: {public_key, api_version, country, currency, features: {setup_intents, payment_element, card_element, three_d_secure}}. Errors: 401 (missing/invalid token).
get_website
ChatGPTGet one age-verification website by ID (Bynn GET /v1/websites/:id). When to use: to read a single website's full configuration and stats before updating it or wiring up its age gate. Requires: a dashboard token (JWT) or private API key on the connection. Returns: one website object (same fields as list_websites): id, asset_id, name, domain, age_restriction, the url_* URLs, branding fields, sensitivity, is_paused, enabled_countries, the feature flags, cookie_storage_duration, total_verifications, success_rate, created_at, updated_at. Errors: 401 (missing/invalid token), 404 (no such website in this organization).
get_workflow
ChatGPTGet a single workflow (Bynn GET /v1/autodoc/workflows/:id). Requires: dashboard token (JWT). Returns: {id, name, description, status, nodes, edges, settings, token, createdAt, updatedAt}. Errors: 401 (auth), 404 (no such workflow in your organization).
give_session_consent
ChatGPTRecord the applicant's consent decision (Bynn PATCH /v1/sessions/:session_id/consent). When to use: BEFORE any verification step — get_session_preflight returns 451 until consent is given. Pass gives_consent=true to proceed; gives_consent=false cancels the session (same effect as cancel_session). Requires: no API key — the session_id in the path is the credential. Returns: {status: "success"}. Errors: 404 (invalid session).
list_agent_categories
ChatGPTList the available agent category options (Bynn GET /v1/reasoning/agents/categories). When to use: to get valid categories values for create_orchestrator / create_fraud_agent and for filtering the public marketplace. Static catalog. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [{id, name, description}], meta: {totalCategories}} — e.g. fraud_detection, compliance, kyc, aml, transaction_analysis, identity_verification, document_verification, risk_assessment, pattern_recognition, anomaly_detection, data_enrichment, reporting. Errors: 401 (auth), 429 (rate limited).
list_agent_ratings
ChatGPTList ratings and rating summary for a public agent (Bynn GET /v1/reasoning/agents/:token/ratings). When to use: to read community reviews of an agent, most recent first, plus the aggregate rating distribution. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [{rating, comment, userName, createdAt}], pagination, summary: {averageRating, ratingCount, distribution: {5,4,3,2,1}}}. Errors: 400 (invalid agentType), 401 (auth), 404 (agent not found), 429 (rate limited).
list_all_moderation_models
ChatGPTList ALL public moderation models across every type (Bynn GET /v1/moderation/models/all). When to use: the primary catalog browser — returns every active model (image, video, audio, text) grouped by category, with public pricing for all plan tiers. Use it to discover a model's api_name before calling create_moderation_inference, then call get_moderation_model(api_name) for that model's full docs and input/output schema. Requires: nothing (public, cached ~1 hour). Returns: an array of categories, each {name, description, icon, models: [...]} where each model has id, api_name, name, description, category, moderation_type, accuracy, avg_response_time_ms, pricing, all_plans_pricing, supported_formats, max_file_size_mb, tags, require_plan, version, and more. Errors: 500 (failed to fetch models).
list_api_keys
ChatGPTList all API keys for the authenticated organization (Bynn GET /v1/api_keys). When to use: to see the organization's private and public API keys (live and test), their types, creation/expiration timestamps, and usage stats. This is the inventory view — the returned key values are MASKED. To read a full key value, call get_api_key(id); to mint a fresh key value, call rotate_api_key. Requires: a dashboard access token (JWT) on the connection. Returns: a JSON ARRAY of key objects (most recent first), each {id: "apikey_<token>", name, key (masked), key_type: private|public, is_test, created_at, expires_at, last_used_at, stats}. Errors: 401 (missing/invalid token), 403 (your role may not access API keys), 429 (rate limited — max 30/min).
list_approvals
ChatGPTList human-in-the-loop workflow approvals (Bynn GET /v1/autodoc/approvals). When to use: to work the approval queue. Defaults to pending only, oldest first (arrival order). Look up an approval's token (apr_...) here, then call approve_approval / reject_approval. Requires: dashboard token (JWT). Returns: {data: [{token (apr_...), status, dossierToken, dossierName, workflowToken, workflowName, nodeId, nodeLabel, approverEmail, resolvedByEmail, resolutionHandle, comment, requestedAt, resolvedAt, timeoutAt}], pagination: {total, totalPages, page, perPage}}. Errors: 401 (auth).
list_audio_moderation_models
ChatGPTList AUDIO moderation models grouped by category (Bynn GET /v1/moderation/models/audio). When to use: to see the audio models available to your organization (with org-specific pricing). For the full public catalog use list_all_moderation_models. Requires: a dashboard token (JWT) on the connection. Returns: an array of categories {name, description, icon, models: [...]}. Errors: 401 (missing/invalid dashboard token).
list_billing_plans
ChatGPTList all available subscription plans with pricing and features (Bynn GET /v1/billing/plans). When to use: before change_billing_plan, to show the org its options and see which plan is_current. Plans returned: Trial, Core, Compliance, Forensic, Enterprise. Requires: a dashboard access token (JWT) on the connection. Returns: an array of plan objects, each with id, name, display_name, badge, price_monthly/price_yearly/savings_yearly (Enterprise is null — contact sales), optional per-unit pricing (price_per_verification, price_per_liveness), features, limits (a value of -1 means unlimited/pay-per-use, 0 means not included), support_level, data_retention_days, custom_branding, webhooks_enabled, is_current, can_upgrade, can_downgrade. Errors: 401 (missing/invalid token).
list_countries
ChatGPTList all countries with codes and attributes (Bynn GET /v1/countries). When to use: to populate or validate the enabled_countries argument of create_website/update_website, or to look up a country's ISO codes, EU-VAT status, and sanctions flags. This is a public endpoint — no credential is required. Requires: nothing (public). Returns: an array of country objects, each with id, name, code (ISO alpha-2), alpha2, alpha3, emoji_flag, eu_vat (bool), sanctions (bool), and sanctions_business (bool), ordered by name. Errors: none expected under normal use.
list_document_collections
ChatGPTList document collections for your organization (Bynn GET /v1/autodoc/collections). When to use: to browse the reusable document-requirement sets a workflow can attach. A collection defines which documents (passport, proof of address, etc.) a visitor is asked to upload and the per-document AI/OCR/fraud settings. Requires: dashboard token (JWT). Returns: an array of collection objects, newest first, each with {id (col_...), name, description, status, documents: [...requirements...], createdAt, updatedAt, totalRequired, totalOptional}. Errors: 401 (auth).
list_document_content_types
ChatGPTList document content types and which are already claimed (Bynn GET /v1/reasoning/document-content-types). When to use: before creating/updating an orchestrator with documentContentTypes. Each content type may be routed to only ONE active orchestrator, so this tells you which numeric type values are still free. Pass those value integers to create_orchestrator / update_orchestrator. Requires: a dashboard token (JWT) on the connection. Rate limit: 30/min. Returns: {data: [{value (int), name, label}], assignedTypes: [int, ...]} where assignedTypes are the values already assigned to other active orchestrators. Errors: 401 (missing/invalid token), 429 (rate limited).
list_document_types
ChatGPTList the document types available for collection requirements (Bynn GET /v1/autodoc/document_types). When to use: before create_document_collection / update_document_collection, to get the valid documentType identifiers and their display labels (passport, id_card, drivers_license, proof_of_address, bank_statement, invoice, etc.). Requires: dashboard token (JWT). Returns: the catalog of supported document types (identifier + label per entry). Errors: 401 (auth).
list_documents
ChatGPTList and search your document submissions (Bynn GET /v1/documents). When to use: to browse or search previously submitted documents, e.g. to find a document_id/submission_id to pass to get_document. Returns a lightweight summary per document (not the full forensic analysis — use get_document for that). Requires: a Private API key on the connection. Returns: {documents: [{submission_id, document_id, name, reference_id, status, analysis_risk_status, analysis_risk_score, document_content_type, created_at}], page, per_page, total, total_pages}, most recent first. Errors: 401 (missing/invalid key).
list_dossier_documents
ChatGPTList the documents uploaded to a dossier (Bynn GET /v1/autodoc/dossiers/:id/documents). When to use: to see each file the recipient submitted, its detected type, and its fraud analysis outcome. File URLs are short-lived signed links (expire in ~5 minutes). Requires: dashboard token (JWT). Returns: {documents: [{id, name, documentType (pdf|image), documentContentType (passport, invoice, ...), analysisStatus (pending|trusted|low|medium|high|fraud), riskScore, fileUrl, thumbnailUrl, previewUrl, createdAt, analyzedAt}]}, newest first. Errors: 401 (auth), 404 (no such dossier).
list_dossier_notes
ChatGPTList a dossier's notes / audit timeline (Bynn GET /v1/autodoc/dossiers/:dossier_token/notes). When to use: to read the admin-facing timeline for a dossier — both manually added notes and the auto-generated approve/reject audit entries. Task rows are excluded; newest first. Requires: dashboard token (JWT). Returns: {data: [{...serialized note: id/token, content, note_type, importance_level, author, created_at, ...}]}. Errors: 401 (auth), 404 (no such dossier).
list_dossiers
ChatGPTList and filter AutoDoc dossiers (Bynn GET /v1/autodoc/dossiers). When to use: to find recipients' runs of your workflows — to triage the review queue, look up a dossier_... token, or filter by tags/form-field values. Only workflow-backed dossiers appear here. Requires: dashboard token (JWT). Returns: {data: [{id (dossier_...), name, workflowId, workflowName, workflowStatus, status, downloadStatus, documentsCollected, documentsRequired, tags, hasNotes, createdAt, updatedAt, completedAt}], pagination: {total, totalPages, page, perPage}}, newest-updated first. If some variable_filters were ignored, a filterWarnings array is also returned. Errors: 401 (auth).
list_face_collections
ChatGPTList your organization's face collections (Bynn GET /v1/face-collections). When to use: to browse existing collections or find a collection_id to enroll into or search. Ordered by most recently created first. Each item includes its face_count. Requires: a Private API key OR a dashboard token on the connection. Returns: an array of {collection_id (fc_...), name, description, face_count, created_at}. Errors: 401 (missing/invalid auth), 429 (rate limit: 30/min).
list_fraud_agents
ChatGPTList YOUR organization's fraud-analysis agents / operators (Bynn GET /v1/reasoning/agents/fraud-analysis). When to use: to enumerate the operators you own (not the public marketplace — use list_public_fraud_agents for that), optionally filtered by tool type or status. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [operator objects], pagination, stats: {activeAgents, totalAgents, avgTaskTime, errorCount, successRate, tasksCompletedToday, tasksInQueue}}. Errors: 401 (auth), 429 (rate limited).
list_image_moderation_models
ChatGPTList IMAGE moderation models grouped by category (Bynn GET /v1/moderation/models/image). When to use: to see the image models available to your organization (with your org-specific pricing/response times). For the full public catalog across all types use list_all_moderation_models; for one model's full docs use get_moderation_model. Requires: a dashboard token (JWT) on the connection. Returns: an array of categories {name, description, icon, models: [...]}; see list_all_moderation_models for the per-model fields. Errors: 401 (missing/invalid dashboard token).
list_inference_history
ChatGPTList the organization's AI inference / verification request history (Bynn GET /v1/billing/history). When to use: to review billable inference requests with their cost/usage, filtered by model type, status, and date. Uses offset/limit pagination with a has_more flag. Requires: a dashboard access token (JWT) on the connection. Returns: {inferences: [ ... per-inference records incl. model, status, timing, and associated billable usage/price ... ], pagination: {limit, offset, has_more}}, newest first. Errors: 401 (auth); 422 (invalid_date_range — range exceeds 90 days, or start_date is after end_date).
list_invitation_locales
ChatGPTList supported invitation locales (Bynn GET /v1/autodoc/invitations/locales). When to use: before create_invitation, to get the valid locale codes for the recipient-facing email/SMS content. Requires: a private API key (private_...) OR a dashboard token (JWT). Returns: {data: [{code, name}]} — code is what you send as locale. Errors: 401 (auth).
list_invitations
ChatGPTList AutoDoc invitations (Bynn GET /v1/autodoc/invitations). When to use: to browse invitations you've sent, or to de-duplicate before creating a new one (filter by reference). Filters combine with AND; newest first. Requires: a private API key (private_...) OR a dashboard token (JWT). Returns: {data: [{token (adi_...), workflowToken, workflowName, channel, recipient, reference, status, errorMessage, expiresAt, sentAt, startedAt, completedAt, rejectedAt, dossierToken, deliveryAttempts, createdAt}], pagination: {total, totalPages, page, perPage}}. Errors: 400 (search under 3 chars), 401 (auth).
list_invoices
ChatGPTList the organization's invoices, most recent first (Bynn GET /v1/billing/invoices). When to use: to browse billing history and find an invoice id (format inv_...) to pass to download_invoice. Total counts are returned via X-Total / X-Total-Pages / X-Page / X-Per-Page response headers. Requires: a dashboard access token (JWT) on the connection. Returns: an array of invoice objects: {id, invoice_number, status, amount_total, amount_paid, amount_due, currency, billing_period_start, billing_period_end, issue_date, due_date, paid_at, line_items, payment_method_last4, pdf_url, hosted_invoice_url}. Errors: 401 (missing/invalid token).
list_orchestrators
ChatGPTList YOUR organization's orchestrator agents (Bynn GET /v1/reasoning/agents/orchestrators). When to use: to enumerate the orchestrators you own (not the public marketplace — use list_public_orchestrators for that). Returns each orchestrator's details plus org-wide reasoning stats. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [orchestrator objects], pagination, stats: {activeAgents, totalAgents, avgTaskTime, errorCount, successRate, tasksCompletedToday, tasksInQueue}}. Errors: 401 (auth), 429 (rate limited).
list_organization_tags
ChatGPTList your organization's dossier tags (Bynn GET /v1/autodoc/organization_tags). When to use: to see the reusable labels available to attach to dossiers, with how many dossiers currently carry each. Requires: dashboard token (JWT). Returns: an array of {token (orgtag_...), color, name, dossiersCount}, ordered by color then name. Errors: 401 (auth).
list_passkeys
ChatGPTList the authenticated user's registered passkeys (Bynn GET /v1/users/passkeys). When to use: to show the user's active WebAuthn passkeys, e.g. before deleting one. Returns only active passkeys, most-recently-used first. Rate-limited (30/min). Requires: a dashboard access token (JWT) on the connection. Returns: a list of passkeys, each {id, label, display_name, token, webauthn_id, created_at, last_used_at, device_info}. Pass a passkey's id or token to delete_passkey. Errors: 401 (missing/invalid token).
list_public_fraud_agents
ChatGPTBrowse public fraud-analysis agent templates from the global community (Bynn GET /v1/reasoning/agents/public/fraud-analysis). When to use: to discover shareable operators others published. Grab a result's token and pass it as sourceAgentToken to create_fraud_agent to import a copy. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [{token, name, toolType, description, systemPrompt, icon, iconColor, priority, capabilities, categories, usageCount, averageRating, ratingCount, creator, createdAt}], pagination, meta.availableFilters}. Errors: 401 (auth), 429 (rate limited).
list_public_orchestrators
ChatGPTBrowse public orchestrator templates from the global community (Bynn GET /v1/reasoning/agents/public/orchestrators). When to use: to discover shareable orchestrators others published. Grab a result's token and pass it as sourceAgentToken to create_orchestrator to import a copy into your org. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [{token, name, description, systemPrompt, icon, color, coordinationStrategy, categories, usageCount, averageRating, ratingCount, creator, createdAt}], pagination, meta.availableFilters}. Errors: 401 (auth), 429 (rate limited).
list_reasoning_jobs
ChatGPTList reasoning jobs with filters and org-wide stats (Bynn GET /v1/reasoning/jobs). When to use: to browse or search past/running reasoning jobs, e.g. to find a job token for get_reasoning_job, or to check how many are queued/running. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {data: [job summaries], pagination: {currentPage, totalPages, totalItems, perPage}, stats: {totalJobs, completedJobs, failedJobs, runningJobs, queuedJobs, successRate}}, most recent first. Errors: 401 (auth), 429 (rate limited).
list_text_moderation_models
ChatGPTList TEXT moderation models grouped by category (Bynn GET /v1/moderation/models/text). When to use: to see the text models available to your organization (with org-specific pricing). For the full public catalog use list_all_moderation_models. Requires: a dashboard token (JWT) on the connection. Returns: an array of categories {name, description, icon, models: [...]}. Errors: 401 (missing/invalid dashboard token).
list_verifications
ChatGPTBrowse the age-verification history for the organization (Bynn GET /v1/verifications). When to use: to audit end-user age checks — see who passed/failed, by which method (biometric, email, or ID document), on which website, and from where. Supports pagination and filtering by status, website, country, date range, and verification ID. Requires: a dashboard token (JWT) or private API key on the connection. Rate limit: 30 requests/minute. Returns: {data: [verification], pagination: {total, total_pages, page, per_page}}. Each verification has id, verification_id, website_id, website_name, asset_id, timestamp, age_restriction, passed, confidence, verification_status, face_confidence, status, country, ip_country_code, age_verification_method, and for ID-document checks error_code/document_type/issuing_country, plus device_type, processing_time, error_message, anonymized ip_address, and user_agent. Errors: 401 (missing/invalid token).
list_video_moderation_models
ChatGPTList VIDEO moderation models grouped by category (Bynn GET /v1/moderation/models/video). When to use: to see the video models available to your organization (with org-specific pricing). For the full public catalog use list_all_moderation_models. Requires: a dashboard token (JWT) on the connection. Returns: an array of categories {name, description, icon, models: [...]}. Errors: 401 (missing/invalid dashboard token).
list_websites
ChatGPTList every age-verification website for the authenticated organization (Bynn GET /v1/websites). When to use: to enumerate your configured age-gate websites/apps and get each one's id (needed by get_website, update_website, delete_website, pause_website, and as the website_id filter for list_verifications). Returns the full config plus rollup stats per website; no pagination. Requires: a dashboard token (JWT) or private API key on the connection. Returns: an array of website objects, each with id, asset_id, name, domain, age_restriction, the url_* redirect/consent URLs, branding (url_icon, url_logo, brand_color, brand_accent_color), sensitivity, is_paused, enabled_countries, feature flags (allow_search_engine_bypass, strong_api_security, email_verification_enabled, liveness_enabled, identity_document_verification_enabled), cookie_storage_duration, total_verifications, success_rate, created_at, updated_at. Errors: 401 (missing/invalid token).
list_workflows
ChatGPTList workflows for your organization (Bynn GET /v1/autodoc/workflows). When to use: to browse the AutoDoc workflows (visitor journeys). A workflow's token is what you pass to create_invitation (as wf_<token>) and what a visitor link opens. Requires: dashboard token (JWT). Returns: an array of workflow objects, newest first, each with {id (wf_...), name, description, status, nodes, edges, settings, token, createdAt, updatedAt}. Errors: 401 (auth).
pause_website
ChatGPTPause or resume age verification for a website (Bynn POST /v1/websites/:id/pause). When to use: to quickly toggle the age gate on/off without touching any other setting. Set is_paused=True to stop verifying end users, False to resume. Requires: a dashboard token (JWT) or private API key on the connection. Rate limit: 30 requests/minute. Returns: the updated website object (same shape as get_website) with the new is_paused value. Errors: 401 (missing/invalid token), 404 (no such website in this organization), 422 (update failed).
public_moderation_inference
ChatGPTRun a FREE public AI-detection inference — no credential required (Bynn POST /v1/moderation/public-infer). When to use: quick demo/AI-detection without an account. Restricted to a small set of detection models (see model); content-moderation models are NOT available here — use create_moderation_inference for those. Heavily rate-limited by IP (2 per day by default; 10 per hour for recognized partner brands). Runs synchronously. Requires: nothing (public). Browser callers are CORS-restricted to allowed origins. Returns: {model_id, model_name, moderation_type, status: "completed", result, response_time_ms}. Errors: 403 (cors_error — origin not allowed; minor_rejected — e.g. beauty scoring refused for a minor), 422 (invalid_model — model not in the allowed list, or missing/invalid/too-large input; invalid_url — blocked/unresolvable URL), 429 (rate_limit_exceeded — create an account to continue), 500 (inference error).
publish_agent
ChatGPTPublish one of your agents to the public community marketplace (Bynn POST /v1/reasoning/agents/:token/publish). When to use: to make an orchestrator or operator you own discoverable (and importable) by others. Sets its access level to 'public'. Requires: a dashboard token (JWT). Rate limit: 10/min. Returns: {success, message, data: {token, accessLevel: "public", name}}. Errors: 400 (invalid agentType), 401 (auth), 404 (agent not found in your org), 422 (already public), 429 (rate limited).
rate_agent
ChatGPTRate a public agent 1-5 stars (Bynn POST /v1/reasoning/agents/:token/rate). When to use: to leave (or update) your rating of a PUBLIC community agent. If you have already rated it, your existing rating is updated instead of duplicated. Requires: a dashboard token (JWT). Rate limit: 3/min. Returns: {success, message, data: {averageRating, ratingCount}}. Errors: 400 (invalid agentType), 401 (auth), 403 (agent is not public), 404 (agent not found), 422 (validation), 429 (rate limited).
reject_approval
ChatGPTReject a pending HITL approval (Bynn POST /v1/autodoc/approvals/:token/reject). When to use: to resolve a paused workflow approval with the 'rejected' handle — this resumes the workflow down the rejected branch. Only pending approvals on a dossier still awaiting approval can be resolved; a concurrent resolution returns 409. Requires: dashboard token (JWT). Returns: {token, status: 'rejected', resolutionHandle: 'rejected', resolvedAt, resolvedByEmail, comment}. Errors: 401 (auth), 404 (no such approval), 409 (already resolved, or dossier no longer awaiting approval), 422 (comment over 500 chars).
reorder_orchestrator_agents
ChatGPTReorder the fraud-analysis agents assigned to an orchestrator (Bynn PUT /v1/reasoning/agents/orchestrators/:id/reorder). When to use: to change the execution priority/order of an orchestrator's operators without re-assigning them. Does not add or remove agents — use update_orchestrator (assignedAgentIds) for that. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: {id, name, assignedAgents: [{id, name, toolType, toolTypeLabel, priority, status, utilization, efficiency}], message}. Errors: 400 (an id in agentIds is not assigned to this orchestrator), 401 (auth), 404 (orchestrator not found), 429 (rate limited).
report_public_data
ChatGPTReport incorrect data in the authenticated user's public profile (Bynn POST /v1/users/me/report). When to use: when the user wants to flag that information shown on their public profile is wrong. This files a report for Bynn to review; it does not itself change any data. Heavily rate-limited (10 reports per hour) to prevent abuse. Requires: a dashboard access token (JWT) on the connection. Returns: {success: true, message} acknowledging the report. Errors: 401 (missing/invalid token), 404 (user not found), 422 (description blank or longer than 1000 characters), 429 (hourly limit hit).
resend_invitation
ChatGPTResend an AutoDoc invitation (Bynn POST /v1/autodoc/invitations/:token/resend). When to use: when a recipient never received the original and asks for another copy. Only invitations currently in 'sent' status can be resent; it flips status back to 'pending' and re-fires delivery. Limits: max 10 total send attempts per invitation, and a 3-minute cooldown between sends. Expired invitations cannot be resent — create a new one. Billable at the normal send rate (test keys not billed). Requires: a private API key (private_...) OR a dashboard token (JWT). Returns: 200 with the updated invitation entity. Errors: 401 (auth), 402 (insufficient balance), 404 (not found), 422 (not resendable — wrong status, expired, or max attempts reached), 429 (cooldown active or rate limit).
rotate_api_key
ChatGPTRotate (regenerate) an API key for the authenticated organization (Bynn POST /v1/api_keys/rotate). When to use: to replace a compromised or aging key with a freshly generated one. Specify key_type (private/public) and is_test (test vs live). By default the previous key stays valid for 12 hours; pass immediate=True to revoke it at once. Update your integrations with the new key value before the grace period ends. Requires: a dashboard access token (JWT) on the connection. Returns: the NEW key object with its key field holding the FULL value (returned only on rotation) — {id, name, key (FULL value), key_type, is_test, created_at, expires_at, last_used_at, stats}. Save it now; you can re-read it later with get_api_key(id). Errors: 401 (missing/invalid token), 403 (your role may not rotate keys), 422 (invalid key_type — must be 'private' or 'public'), 429 (rate limited — max 5 rotations/hour), 500 (rotation failed).
search_faces
ChatGPTSearch a collection for faces similar to a probe image (Bynn POST /v1/face-collections/:token/search). When to use: 1:N identification — given one probe photo, find enrolled faces that match. If the probe contains multiple faces, the largest/first detected face is used. Results are ordered by similarity (lowest distance first). Enroll faces first with enroll_face. Requires: a Private API key OR a dashboard token on the connection. Returns: an array of matches, each {face_id (face_...), name, external_id, distance (cosine, lower = more similar), similarity (1 - distance), metadata}. Empty array if nothing is within the threshold. Errors: 400 (no face detected in the probe image), 401 (missing/invalid auth), 404 (collection not found), 422 (validation: no image input / image too large / extraction failed), 429 (rate limit: 30/min).
send_session_sms
ChatGPTSMS the applicant a link to continue on their phone (Bynn POST /v1/sessions/:session_id/send_sms). When to use: the "device switch" hand-off — send a mobile-code link so the applicant can finish the flow (e.g. camera capture) on their phone instead of desktop. Rate limited to a few sends per session. Requires: no API key — the session_id in the path is the credential. Returns: {status: "success"}. Errors: 400 (invalid phone number or SMS could not be sent), 404 (invalid session), 429 (too many SMS attempts for this session).
start_age_verification_liveness
ChatGPTStart the liveness capture for a session (Bynn PATCH /v1/age_verification/liveness/:session_id). When to use: STEP 2 of the liveness flow, after create_age_verification_session. This provisions short-lived AWS Rekognition credentials that the client-side browser SDK uses to run the real-time face-liveness capture. Each session may be started only once. After the browser finishes the capture, call complete_age_verification_liveness(session_id). Requires: no API key — the session_id in the path is the credential (this is a client-side/session call). It must be an open age-verification session that has not already been processed. Returns: {age_verification_id, liveness_session: {session_id (AWS Rekognition session id), credentials: {id, access_key, token}, server_time (ms epoch)}}. Feed these credentials and session id to the AWS Rekognition FaceLivenessDetector on the frontend. Errors: 400 (not an age-verification session / could not start liveness), 401 (session already processed), 404 (invalid or expired session).
start_email_verification
ChatGPTStart email verification by emailing a code (Bynn POST /v1/sessions/:session_id/email_verification). When to use: to begin the email-verification step — sends a 6-digit code to the given address. Then collect the code and call check_email_verification. Requires: no API key — the session_id in the path is the credential. Returns: {status: "sent"}. Errors: 400 (invalid email address), 404 (invalid session/entity), 422 (rejected), 429 (too many attempts).
start_liveness
ChatGPTStart a face-liveness capture (Bynn POST /v1/sessions/:session_id/liveness/start). When to use: when get_session_preflight asks for a liveness step. This returns the temporary credentials the client-side liveness capture SDK needs. After the SDK finishes, call complete_liveness to fetch the result. Requires: no API key — the session_id in the path is the credential. Returns: {liveness_session: {session_id, credentials: {id, access_key, token}, server_time}} — feed these to the liveness SDK. Errors: 400 (could not start liveness), 404 (invalid session/organization).
start_phone_verification
ChatGPTStart phone verification by texting a code (Bynn POST /v1/sessions/:session_id/phone_verification). When to use: to begin the phone-verification step — sends a 6-digit SMS code to the applicant. Then collect the code and call check_phone_verification. Requires: no API key — the session_id in the path is the credential. Returns: {status: "sent"}. Errors: 400 (invalid phone number), 404 (invalid session/entity, or missing country_code for a non-international number), 422 (rejected), 429 (too many SMS attempts).
submit_address_verification
ChatGPTUpload a proof-of-address document (Bynn POST /v1/sessions/:session_id/address_verification). When to use: for the proof-of-address step. Combines document scanning with optional GPS and cellular-network data for multi-layered address verification. Analyzed asynchronously; re-poll get_session_preflight afterward. You MUST provide either document_base64_strict or file_path. Requires: no API key — the session_id in the path is the credential. Returns: {status: "analyzing"}. Errors: 400 (bad request), 404 (invalid session/entity), 415 (unsupported media type — allowed: jpeg, jpg, png, pdf), 422 (rejected).
submit_document
ChatGPTSubmit a document for full fraud / authenticity analysis (Bynn POST /v1/documents). When to use: to check whether a document is genuine or fraudulent — runs the complete forensic pipeline (forgery-template matching, tampering & manipulation, font/consistency, signature validation, deepfake + AI-generation, MRZ/barcode/QR, EXIF, address validation, classification, risk scoring) on an ID/passport, bank statement, invoice, contract, etc. This is the heavyweight document-fraud detector — for a quick "is this image AI-generated?" on any image, use detect_ai_generated_image instead. Analysis is ASYNCHRONOUS — this returns immediately with a submission_id. To see whether it's done, poll get_document(submission_id) about every 3 minutes until status becomes analyzed (or error); it is pending until then. Don't poll faster. Requires: a Bynn access token (dashboard JWT) or private key on the connection. Billable: consumes one analysis credit per non-test submission (402 insufficient_balance means top up). Returns: {submission_id, document_id, status: "received", jwt}. - submission_id (e.g. document_UBCG4a...) and document_id (e.g. 5PGACUU2E) can BOTH be passed to get_document / delete_document. Errors: 401 (missing/invalid key), 402 (insufficient balance), 413 (document > 64 MB), 415 (unsupported type — only jpg/jpeg/png/pdf).
submit_funds_verification
ChatGPTUpload a proof-of-funds document (Bynn POST /v1/sessions/:session_id/funds_verification). When to use: for the proof-of-funds step (e.g. bank statement). Analyzed asynchronously; re-poll get_session_preflight afterward. You MUST provide either document_base64_strict or file_path. Requires: no API key — the session_id in the path is the credential. Returns: {status: "analyzing"}. Errors: 400 (bad request), 404 (invalid session/entity), 415 (unsupported media type — allowed: jpeg, jpg, png, pdf), 422 (rejected).
submit_nfc_data
ChatGPTSubmit NFC-scanned identity-document data to a verification session (Bynn POST /v1/nfc). When to use: after a mobile device has read an identity document's NFC chip (passport / national eID), call this to hand the chip payload — authentication status, personal data, per-data-group hashes, raw data groups, the chip face image and (optionally) the document-signer certificate — to the verification session named by session_id. The server verifies chip/PACE/passive authentication and the data-group hashes against the SOD. This is the NFC step of a verification flow; it is distinct from the document-image forensic tools (submit_document). Requires: NO API key or dashboard token — this is a session-token endpoint. Identify the session with the session_id parameter (the session token). Rate limit: 5 requests per minute per session. Note on nested objects: authentication_status, certificate_info, hash_verification and location_data are JSON objects whose inner keys must be sent in the exact camelCase spelling documented on each parameter (e.g. chipAuth, dg1Hash, documentSignerCertificate). Returns: on success, liveness-session start info to continue the flow — age_verification_id and a liveness_session object {session_id, credentials: {id, access_key, token}, server_time}. Errors: 400 (invalid NFC data), 404 (invalid/unknown session), 422 (NFC data validation failed), 429 (rate limit — more than 5 requests/minute for this session).
submit_onboarding_survey
ChatGPTSave the current user's organization onboarding survey (Bynn POST /v1/users/onboarding-survey). When to use: to record onboarding answers for the authenticated user's organization (shown when get_current_user returns organization.show_onboarding_survey == true). All fields are optional — send only what you have. Setting completed=true marks the survey done. Provided business_name, website, and country also update the org's profile/billing fields as a side effect. Requires: a dashboard access token (JWT) on the connection. Rate-limited (10/min). Returns: {success: true, message} on save. Errors: 401 (missing/invalid token), 422 (organization failed to save / validation).
test_orchestrator
ChatGPTRun an orchestrator SYNCHRONOUSLY against an existing document (Bynn POST /v1/reasoning/agents/:id/test). When to use: to try out an orchestrator immediately and get the fraud decision inline (this blocks until the LLM run completes) — as opposed to create_reasoning_job, which runs asynchronously. The target document must already be submitted AND analyzed (status analyzed) via the documents tools. Requires: a dashboard token (JWT). Rate limit: 30/min. Consumes LLM tokens. Returns on success: {success: true, orchestrator, document, execution: {jobId, status, durationSeconds, totalTokens, ...}, results: {fraudScore, decision, confidence, reasoning, redFlags, evidence}, operatorActivity, conversationSummary}. On an LLM/runtime failure it still returns HTTP 200 with {success: false, error: {message, type}, ...}. Errors: 401 (auth), 404 (orchestrator not found, or no analyzed document found), 429 (rate limited).
topup_balance
ChatGPTAdd prepaid funds to the account balance via the saved card (Bynn POST /v1/billing/topup). When to use: to charge the org's default payment method and credit the prepaid balance (the balance that per-use verification charges are drawn from). Precondition: a payment method must be on file (otherwise 400) — add one with create_setup_intent + confirm_payment_method first. Requires: a dashboard access token (JWT) on the connection. Returns: {success, message, new_balance, ledger_balance, amount_added, timestamp} (balances in dollars). Errors: 401 (auth); 400 (no payment method on file); 402 (payment/charge failed, insufficient balance on the card); 429 (too many payment attempts — retry in ~10 min); 500 (payment processing error).
unpublish_agent
ChatGPTRemove one of your agents from the public marketplace (Bynn POST /v1/reasoning/agents/:token/unpublish). When to use: to make a previously published agent private again. Sets access level to 'private'. Existing imported copies made by others are unaffected (importCount reports how many were made). Requires: a dashboard token (JWT). Rate limit: 10/min. Returns: {success, message, data: {token, accessLevel: "private", name, importCount}}. Errors: 400 (invalid agentType), 401 (auth), 404 (agent not found in your org), 422 (already private), 429 (rate limited).
update_company_details
ChatGPTUpdate the organization's company / invoicing details (Bynn PUT /v1/billing/company_details). When to use: to set the invoicing identity (name, billing email, VAT ID, address) — a complete billing address is a precondition for change_billing_plan. All fields are optional; only the fields you pass are changed. Passing an empty string clears a field. Requires: a dashboard access token (JWT) on the connection. Returns: the updated company_details object: {company_name, billing_email, vat_id, phone, website, purchase_order_number, notes, address: {line1, line2, city, state, postal_code, country, country_id}, updated_at}. Errors: 401 (auth); 422 (Failed to update company details with model validation errors).
update_document_collection
ChatGPTUpdate a document collection and (optionally) its requirements (Bynn PUT /v1/autodoc/collections/:id). When to use: to rename, re-describe, change the status of, or edit the requirement list of a collection. Note the replace-semantics on documents above. Requires: dashboard token (JWT). Returns: the updated collection (same shape as get_document_collection). Errors: 401 (auth), 404 (no such collection), 400 (a document has >50 OCR fields), 422 (validation).
update_dossier
ChatGPTRename a dossier (Bynn PUT /v1/autodoc/dossiers/:id). When to use: to set a human-friendly name on a dossier. name is the only editable field. Requires: dashboard token (JWT). Returns: {id, name, updatedAt}. Errors: 401 (auth), 404 (no such dossier), 400 (name empty or >255 chars).
update_fraud_agent
ChatGPTUpdate a fraud-analysis agent / operator (Bynn PUT /v1/reasoning/agents/fraud-analysis/:id). When to use: to change an operator's prompt, tool type, capabilities, priority, or orchestrator assignments. Only the fields you pass are changed. Passing orchestratorIds replaces the whole assignment list. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the updated operator object. Errors: 401 (auth), 404 (no such agent in your org), 422 (validation), 429 (rate limited).
update_orchestrator
ChatGPTUpdate an orchestrator agent (Bynn PUT /v1/reasoning/agents/orchestrators/:id). When to use: to change an orchestrator's prompt, strategy, assigned operators, or content-type routing. Only the fields you pass are changed. Passing assignedAgentIds replaces the whole assignment list. Requires: a dashboard token (JWT). Rate limit: 30/min. Returns: the updated orchestrator object. Errors: 401 (auth), 404 (no such orchestrator in your org), 422 (a documentContentTypes value already assigned elsewhere, or validation), 429 (rate limited).
update_organization_tag
ChatGPTUpdate an organization tag's color and/or name (Bynn PUT /v1/autodoc/organization_tags/:id). Requires: dashboard token (JWT). Returns: {token, color, name, dossiersCount}. Errors: 401 (auth), 404 (no such tag), 400 (name over 50 chars), 422 (invalid color).
update_session
ChatGPTUpdate an open session's applicant details (Bynn POST /v1/sessions/:session_id). When to use: to set/correct the applicant's name, phone, email, identifier, or locale after create_session. Only the fields you pass are changed. Requires: no API key — the session_id in the path is the credential. Returns: {status: "success"}. Errors: 400 (invalid phone or email format — the message may suggest a corrected email domain), 404 (invalid session).
update_website
ChatGPTUpdate an existing age-verification website configuration (Bynn PUT /v1/websites/:id). When to use: to change any field on a website. This is a partial update — only the arguments you pass are modified; omitted fields are left untouched. Passing enabled_countries REPLACES the full set of enabled countries. Requires: a dashboard token (JWT) or private API key on the connection. Rate limit: 30 requests/minute. Returns: the updated website object (same shape as get_website). Errors: 401 (missing/invalid token), 404 (no such website in this organization), 422 (validation error — e.g. bad age_restriction value).
update_workflow
ChatGPTUpdate a workflow (Bynn PUT /v1/autodoc/workflows/:id). When to use: to edit a workflow's name/description, node graph, or UI settings. NOTE: the server always resets status to 'active' on save. Requires: dashboard token (JWT). Returns: the updated workflow (same shape as get_workflow). Errors: 401 (auth), 404 (no such workflow), 422 (validation).
upload_session_media
ChatGPTUpload captured media to a session (Bynn POST /v1/sessions/:session_id/media). When to use: to submit ID-document images, selfies, or capture video for a session when get_session_preflight asks for a document/selfie step. Media is analyzed asynchronously; re-poll get_session_preflight afterward. Requires: no API key — the session_id in the path is the credential. Returns: {status: "success"}. Errors: 400 (bad request / invalid watermark), 404 (invalid session), 415 (unsupported media type — allowed: jpeg, jpg, png, pdf, mp4, webm).
validate_vat_number
ChatGPTValidate an EU VAT number via an external lookup (Bynn POST /v1/billing/validate_vat). When to use: before saving vat_id via update_company_details, to confirm the VAT number is real and (optionally) fetch the registered company name/address. Requires: a dashboard access token (JWT) on the connection. Returns: on success {valid: true, vat_number, company_name, company_address, country_code, message}; on failure {valid: false, error} (empty input, bad format, invalid number, or lookup unavailable). Note: this endpoint reports validation outcomes in the body with HTTP 200 rather than error codes. Errors: 401 (missing/invalid token).
verify_age_from_selfie
ChatGPTEstimate age from a single selfie, without liveness (Bynn POST /v1/age_verification/selfie). When to use: for a quick, one-shot age check when you already have a selfie and consent. This is LESS SECURE than the liveness flow — it cannot prove the person is physically present and is vulnerable to spoofing/deepfakes. For fraud resistance or regulatory compliance, use the liveness flow instead (create_age_verification_session -> start_age_verification_liveness -> complete_age_verification_liveness -> get_age_verification_result). Provide exactly one of image_base64_strict or image_url. Requires: a Private API key on the connection. Billable: consumes one age verification credit; 402 insufficient_balance means the org must top up. Returns (key fields): is_adult (bool), verification_status (pass|underage| unknown), age_verification_model, confidence (high|moderate|low), age_estimated (int), age_range: {low, high}, face: {bounding_box, predicted_gender}, liveness: {status: "not_evaluated"}, image_saved, biometrics_saved, evaluated_at, data_destroyed_at. Errors: 400 (invalid_request_error — could not decode the image), 401 (missing/invalid private key), 402 (insufficient balance), 481 (processing error), 482 (more than one face found), 483 (no face detected), 484 (could not estimate age).
verify_age_with_email
ChatGPTEstimate a person's minimum age from their email address (Bynn POST /v1/agemin/check/email). When to use: for a passive, no-user-interaction age signal. It analyzes privacy-preserving activity signals to estimate how long the email address has been active, then adds a base age assumption (typically 13 years) to derive a minimum age. Because it depends on available activity signals, it can be inconclusive; treat it as a low-friction pre-check rather than a strong proof of age. This call is synchronous. Input: pass email and asset_id; optionally reference_id for your own tracking. Requires: a Private API key on the connection. Billable: consumes one email age-estimation credit per call (a 402 insufficient_balance error means top up). Returns: {status: "ok", timestamp, result: {session_token, age_threshold, confidence (high|moderate|low), verification_status (pass|underage|unknown), is_adult, is_of_age, passed (bool), domain, asset_token}}. Save session_token to re-verify later via get_age_verification_status. Errors: 400 invalid_request_error (invalid email format), 401 (missing/invalid key), 402 insufficient_balance, 403 website_paused (the asset is paused), 404 asset_not_found / invalid_organization, 484 could_not_estimate_age (no usable signals for this email).
verify_age_with_selfie
ChatGPTEstimate a person's age from a single selfie image (Bynn POST /v1/agemin/check/selfie). When to use: for a quick, server-side age estimate when you already hold a selfie and consent. This is the LESS secure method — it does NOT confirm the user is physically present and does NOT detect deepfakes or injection/spoofing attacks. For higher assurance prefer the hosted liveness session flow (Agemin Sessions), which confirms real-time presence. This call is synchronous: it returns the estimation result immediately. Input: pass asset_id plus exactly one image source (image_base64_strict OR image_url). Optionally pass reference_id for your own tracking. Requires: a Private API key on the connection. Billable: consumes one selfie age-estimation credit per call (a 402 insufficient_balance error means top up). Returns: {status: "ok", timestamp, result: {session_token, age_threshold, confidence (high|moderate|low), verification_status (pass|underage), is_adult, is_of_age, passed (bool), face_confidence (0-100), domain, asset_token}}. Save session_token to re-verify later via get_age_verification_status. Errors: 400 invalid_request_error (missing/undecodable image or bad params), 401 (missing/invalid key), 402 insufficient_balance, 403 website_paused (the asset is paused), 404 asset_not_found / invalid_organization, 481 processing_error, 482 multiple_faces, 483 no_face (no/low-confidence/ too-small face), 484 could_not_estimate_age.
