> ## Documentation Index
> Fetch the complete documentation index at: https://docs.neus.network/llms.txt
> Use this file to discover all available pages before exploring further.

# Phase 1: build the standard signing string

> Raw HTTP verification uses a strict two-phase handshake. First send the exact verification body here, sign the returned signerString, then submit the same body plus signature to POST /api/v1/verification.



## OpenAPI

````yaml /openapi/public-api.json post /api/v1/verification/standardize
openapi: 3.0.3
info:
  title: NEUS API — Public Integrator API
  version: 1.0.0
  description: >-
    Public HTTP API for NEUS integrators.


    Recommended integration order (simplest first):

    1. Browser — VerifyGate widget or hosted verify at
    https://neus.network/verify (wallet, passkey, and OAuth handled by NEUS).

    2. JavaScript — `@neus/sdk` `client.verify()` signs and submits for
    signature-based verifiers; use VerifyGate for hosted/interactive verifiers.

    3. Server gate checks — `GET /api/v1/proofs/check` with `gateId` or criteria
    before granting access.

    4. Raw HTTP — two-phase signing below only when you cannot use the SDK or
    hosted flows.


    Raw HTTP verification uses POST /api/v1/verification/standardize → sign
    signerString → POST /api/v1/verification with the same body plus signature.
    Session-authenticated callers may skip the signature when a valid session is
    present.


    Use your deployment base URL (for example https://api.neus.network). Some
    verifiers require pro access. Administrative endpoints are not included in
    this specification.
  license:
    name: Business Source License 1.1
    url: https://mariadb.com/bsl11/
servers:
  - url: https://api.neus.network
    description: Production API
security: []
paths:
  /api/v1/verification/standardize:
    post:
      tags:
        - Verification
      summary: 'Phase 1: build the standard signing string'
      description: >-
        Raw HTTP verification uses a strict two-phase handshake. First send the
        exact verification body here, sign the returned signerString, then
        submit the same body plus signature to POST /api/v1/verification.
      operationId: buildSigningString
      parameters: []
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/StandardizeRequest'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardizeResponse'
        '400':
          description: Invalid request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    StandardizeRequest:
      type: object
      description: >-
        Phase 1 of the raw HTTP verification handshake. Send the exact JSON body
        you intend to submit for verification. The returned signerString is the
        only valid message to sign for that body.
      required:
        - walletAddress
        - verifierIds
        - data
        - signedTimestamp
      properties:
        walletAddress:
          type: string
          description: >-
            Signer wallet address. Must be the same wallet that signs the
            returned signerString and the same walletAddress later submitted to
            POST /api/v1/verification.
        verifierIds:
          type: array
          items:
            type: string
            enum:
              - ownership-basic
              - ownership-social
              - ownership-pseudonym
              - ownership-dns-txt
              - ownership-org-oauth
              - contract-ownership
              - proof-of-human
              - nft-ownership
              - token-holding
              - wallet-risk
              - wallet-link
              - ai-content-moderation
              - agent-identity
              - agent-delegation
          minItems: 1
        data:
          oneOf:
            - type: object
            - type: string
        signedTimestamp:
          type: number
          description: >-
            Unix ms timestamp that becomes part of the signerString. For raw
            HTTP, reuse this exact value unchanged when later submitting POST
            /api/v1/verification.
        chainId:
          type: integer
          description: >-
            Advanced/optional. EVM signing-context hint; auto-resolved to the
            protocol hub chain when omitted. Not required for standard
            integrations. For non-EVM, use chain (CAIP-2) instead. For
            chain-specific asset claims (NFT, token, contract), set chainId
            inside verifier data, not here.
        chain:
          type: string
          description: >-
            CAIP-2 chain identifier for non-EVM wallets (e.g. solana:mainnet).
            EVM wallets do not need this field; the protocol resolves hub
            context automatically.
        signatureMethod:
          type: string
      additionalProperties: true
    StandardizeResponse:
      type: object
      description: >-
        Phase 1 response for raw HTTP verification. Sign data.signerString
        exactly as returned, then submit the same request body plus signature to
        POST /api/v1/verification.
      required:
        - success
        - data
      properties:
        success:
          type: boolean
          enum:
            - true
        data:
          type: object
          required:
            - signerString
            - bodyPreview
          properties:
            signerString:
              type: string
              description: >-
                Exact UTF-8 message to sign for the standardized request body.
                Do not hand-build or modify this string.
            bodyPreview:
              type: object
              description: >-
                Normalized preview of the standardized request. This is
                diagnostic only; submit the same original request body, not a
                body reconstructed from this preview.
              additionalProperties: true
          additionalProperties: true
      additionalProperties: true
    ErrorResponse:
      type: object
      required:
        - success
        - error
      properties:
        success:
          type: boolean
          enum:
            - false
        error:
          type: object
          required:
            - code
            - message
          properties:
            code:
              type: string
            message:
              type: string
            type:
              type: string
            details: {}
          additionalProperties: true
        timestamp:
          $ref: '#/components/schemas/Timestamp'
        requestId:
          type: string
      additionalProperties: true
    Timestamp:
      oneOf:
        - type: string
          format: date-time
        - type: number

````