> This page is for APIs.

> Fetch clean Markdown by appending `.md` to any page URL under https://signalwire.com/docs or requesting it with the HTTP header `Accept: text/markdown`. The root index at https://signalwire.com/docs/llms.txt lists the available documentation indexes.

# webrtc.verto

GET /

Send a Verto frame

Reference: https://signalwire.com/docs/apis/relay/client/webrtc/webrtc-verto

## AsyncAPI Specification

```yaml
asyncapi: 2.6.0
info:
  title: webrtc.verto
  version: subpackage_webrtcVerto.webrtc.verto
  description: Send a Verto frame
channels:
  /:
    description: Send a Verto frame
    publish:
      operationId: subpackage_webrtcVerto.webrtc.verto-publish
      summary: webrtc.verto response
      message:
        name: onWebrtcVertoResponse
        title: webrtc.verto response
        payload:
          $ref: '#/components/schemas/webrtc.verto_webrtcVertoResponse'
    subscribe:
      operationId: subpackage_webrtcVerto.webrtc.verto-subscribe
      summary: webrtc.verto
      message:
        name: webrtcVerto
        title: webrtc.verto
        payload:
          $ref: '#/components/schemas/webrtc.verto_webrtcVertoRequest'
servers:
  production:
    url: wss://relay.signalwire.com/
    protocol: wss
    x-default: true
components:
  schemas:
    ChannelsWebrtcVertoMessagesWebrtcVertoResponseJsonrpc:
      type: string
      enum:
        - '2.0'
      description: JSON-RPC version. Always `2.0`.
      title: ChannelsWebrtcVertoMessagesWebrtcVertoResponseJsonrpc
    WebRTC.VertoResult:
      type: object
      properties:
        code:
          type: string
          description: >-
            Result code as a string. `"200"` means success. On failure this is a
            lowercase

            error identifier such as `not_allowed`, `invalid_params`,
            `internal_error`, or

            `response_timeout`. Always check `code` to tell success from
            failure.
        result:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            The Verto reply payload — for example the answer to a
            `verto.invite`. The shape depends on the Verto method.
        message:
          type: string
          description: >-
            A human-readable status message. Present on errors and on some
            informational replies.
        node_id:
          type: string
          description: >-
            The node now hosting the call. Capture it and send it on later
            frames for this call.
      required:
        - code
      description: >-
        The reply to your Verto frame: the Verto outcome plus the node now
        hosting the call.
      title: WebRTC.VertoResult
    JsonRpcErrorCode0:
      type: string
      enum:
        - '-32000'
      title: JsonRpcErrorCode0
    JsonRpcErrorCode1:
      type: string
      enum:
        - '-32001'
      title: JsonRpcErrorCode1
    JsonRpcErrorCode2:
      type: string
      enum:
        - '-32002'
      title: JsonRpcErrorCode2
    JsonRpcErrorCode3:
      type: string
      enum:
        - '-32003'
      title: JsonRpcErrorCode3
    JsonRpcErrorCode4:
      type: string
      enum:
        - '-32004'
      title: JsonRpcErrorCode4
    JsonRpcErrorCode5:
      type: string
      enum:
        - '-32005'
      title: JsonRpcErrorCode5
    JsonRpcErrorCode6:
      type: string
      enum:
        - '-32600'
      title: JsonRpcErrorCode6
    JsonRpcErrorCode7:
      type: string
      enum:
        - '-32601'
      title: JsonRpcErrorCode7
    JsonRpcErrorCode8:
      type: string
      enum:
        - '-32602'
      title: JsonRpcErrorCode8
    JsonRpcErrorCode9:
      type: string
      enum:
        - '-32603'
      title: JsonRpcErrorCode9
    JsonRpcErrorCode10:
      type: string
      enum:
        - '-32700'
      title: JsonRpcErrorCode10
    JsonRpcErrorCode:
      oneOf:
        - $ref: '#/components/schemas/JsonRpcErrorCode0'
        - $ref: '#/components/schemas/JsonRpcErrorCode1'
        - $ref: '#/components/schemas/JsonRpcErrorCode2'
        - $ref: '#/components/schemas/JsonRpcErrorCode3'
        - $ref: '#/components/schemas/JsonRpcErrorCode4'
        - $ref: '#/components/schemas/JsonRpcErrorCode5'
        - $ref: '#/components/schemas/JsonRpcErrorCode6'
        - $ref: '#/components/schemas/JsonRpcErrorCode7'
        - $ref: '#/components/schemas/JsonRpcErrorCode8'
        - $ref: '#/components/schemas/JsonRpcErrorCode9'
        - $ref: '#/components/schemas/JsonRpcErrorCode10'
      title: JsonRpcErrorCode
    JsonRpcError:
      type: object
      properties:
        code:
          $ref: '#/components/schemas/JsonRpcErrorCode'
          description: >-
            The error code — a negative integer identifying the failure. See
            `JsonRpcErrorCode` for the full list of values and meanings.
        message:
          type: string
          description: A human-readable description of what went wrong.
        original_request:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            An echo of the request that failed — the full JSON-RPC frame you
            sent

            (`jsonrpc`, `id`, `method`, `params`). Always present.
        requester_nodeid:
          type: string
          description: >-
            The node that sent the failed request. Present only on some routing
            errors.
        requester_identity:
          type: string
          description: >-
            The identity of the requester. Present only on some routing errors;
            same value as `requester_nodeid`.
        responder_nodeid:
          type: string
          description: >-
            The node that was handling the request. Present only on some routing
            errors.
        responder_identity:
          type: string
          description: >-
            The identity of the responder. Present only on some routing errors;
            same value as `responder_nodeid`.
        last_hop_timeout:
          type: boolean
          description: >-
            `true` when the request timed out on its final hop inside
            SignalWire. Present only on some timeout errors.
      required:
        - code
        - message
        - original_request
      description: >-
        A JSON-RPC 2.0 error object, delivered on the `error` field of a
        `JsonRpcResponse` when

        a request fails at the protocol level (bad version, authentication,
        scope, params, or

        your project's connection limit). It replaces `result` — a frame carries
        one or the other, never both.
      title: JsonRpcError
    webrtc.verto_webrtcVertoResponse:
      type: object
      properties:
        jsonrpc:
          $ref: >-
            #/components/schemas/ChannelsWebrtcVertoMessagesWebrtcVertoResponseJsonrpc
          description: JSON-RPC version. Always `2.0`.
        id:
          type: string
          description: The id of the request this responds to.
        result:
          $ref: '#/components/schemas/WebRTC.VertoResult'
          description: The method result. Present when the request succeeded.
        error:
          $ref: '#/components/schemas/JsonRpcError'
          description: >-
            Present instead of `result` when the request failed at the protocol
            level.
      required:
        - jsonrpc
        - id
      description: >-
        A JSON-RPC response frame correlated to a request by `id`. On success
        the frame carries

        `result` (the method result). If the request fails at the protocol level
        — an

        incompatible version, failed authentication, insufficient scope, invalid
        params, or your

        project's connection limit — the frame carries `error` instead of
        `result`. Many

        method-level failures (for example most Calling failures) are reported
        the other way: a

        normal `result` whose own `code` is not `"200"`. Each method documents
        which form its

        failures take.


        An `error` returned for `signalwire.connect` is followed by the service
        closing the

        WebSocket; open a new connection to try again. The same happens when

        `signalwire.reauthenticate` sends credentials that are rejected, except
        for a

        Subscriber Access Token. Errors on any other request leave the
        connection open.
      title: webrtc.verto_webrtcVertoResponse
    ChannelsWebrtcVertoMessagesWebrtcVertoRequestJsonrpc:
      type: string
      enum:
        - '2.0'
      description: JSON-RPC version. Always `2.0`.
      title: ChannelsWebrtcVertoMessagesWebrtcVertoRequestJsonrpc
    ChannelsWebrtcVertoMessagesWebrtcVertoRequestMethod:
      type: string
      enum:
        - webrtc.verto
      description: The name of the JSON-RPC method being invoked.
      title: ChannelsWebrtcVertoMessagesWebrtcVertoRequestMethod
    WebRTC.VertoParams:
      type: object
      properties:
        node_id:
          type: string
          description: >-
            The node currently hosting your call. Once a call exists, set this
            to the

            `node_id` you received in an earlier event or response so the frame
            reaches

            the right node. Leave it absent on your first message, before a call
            has been

            established — SignalWire assigns one for you.
        message:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            The Verto frame (the WebRTC signaling message format used for peer
            calls) to

            send — a JSON-RPC 2.0 object `{ jsonrpc, id, method, params }`. For
            a

            `verto.invite`, `params` carries your `sdp` (the Session Description
            Protocol

            offer) and a `dialogParams` object; `layout` and `positions` apply
            only when

            inviting into a conference. Each frame is a Verto-protocol signaling
            message

            whose `params` depend on the Verto method it carries, and SignalWire
            passes it

            through as-is. The Verto call ID belongs inside this frame, at

            `dialogParams.callID` — generate one when you create a call and
            reuse it on

            every frame for that call. There is no top-level `callID`.
        subscribe:
          type: array
          items:
            type: string
          description: >-
            The room events to receive, by event type. Read only when this frame
            is a

            participant `verto.invite` that joins a Video Room: from then on,
            that room's

            events reach this connection only if their type is in this list,
            except

            `room.subscribed`, which always arrives. A screen-share or
            additional-device

            invite reuses the list from the participant invite. Calls to any
            other kind of

            address deliver their call, member, and room events without this
            list, so you

            can omit it.
      required:
        - message
      description: >-
        The parameters for a `webrtc.verto` request: the Verto frame to send,
        the `node_id` that scopes it to your call, and any event channels to
        subscribe to.
      title: WebRTC.VertoParams
    webrtc.verto_webrtcVertoRequest:
      type: object
      properties:
        jsonrpc:
          $ref: >-
            #/components/schemas/ChannelsWebrtcVertoMessagesWebrtcVertoRequestJsonrpc
          description: JSON-RPC version. Always `2.0`.
        id:
          type: string
          description: Request id, echoed on the correlated response.
        method:
          $ref: >-
            #/components/schemas/ChannelsWebrtcVertoMessagesWebrtcVertoRequestMethod
          description: The name of the JSON-RPC method being invoked.
        params:
          $ref: '#/components/schemas/WebRTC.VertoParams'
          description: The method's input parameters.
      required:
        - jsonrpc
        - id
        - method
        - params
      description: >-
        A JSON-RPC request frame. `Method` is the method name; `Params` is the
        method's input.
      title: webrtc.verto_webrtcVertoRequest

```