<img src="/img/tutorial/websockets/image01.png">

You can type messages in the input box, and send them:

<img src="/img/tutorial/websockets/image02.png">

And your **FastAPI** application with WebSockets will respond back:

<img src="/img/tutorial/websockets/image03.png">

You can send (and receive) many messages:

<img src="/img/tutorial/websockets/image04.png">

And all of them will use the same WebSocket connection.

If it doesn't see an `Authorization` header, or the value doesn't have a `Bearer ` token, it will respond with a 401 status code error (`UNAUTHORIZED`) directly.

You don't even have to check if the token exists to return an error. You can be sure that if your function is executed, it will have a `str` in that token.

                response = (NameServicePacket) responseTable.get(Integer.valueOf(nameTrnId));
                if (response == null || response.received) {
                    continue;
                }
                synchronized (response) {
                    response.readWireFormat(rcv_buf, 0);
                    response.received = true;

                    if (LogStream.level > 3) {

  abstract class Listener {
    /**
     * Handle a new stream from this connection's peer. Implementations should respond by either
     * [replying to the stream][Http2Stream.writeHeaders] or [closing it][Http2Stream.close]. This
     * response does not need to be synchronous.
     *
     * Multiple calls to this method may be made concurrently.
     */
    @Throws(IOException::class)

    public static final String MASTER_BROWSER_NAME = "\u0001\u0002__MSBROWSE__\u0002";

    /**
     * A special generic name specified when connecting to a host for which
     * a name is not known. Not all servers respond to this name.
     */

    public static final String SMBSERVER_NAME = "*SMBSERVER     ";

    /**
     * A B node only broadcasts name queries. This is the default if a

	if xnet.IsNetworkOrHostDown(err, r.expectTimeouts) {
		r.errorStatusOnce.Do(func() {
			atomic.AddUint64(&globalStats.errs, 1)
		})
	}
}

// dumpHTTP - dump HTTP request and response.
func (c *Client) dumpHTTP(req *http.Request, resp *http.Response) {
	// Starts http dump.
	_, err := fmt.Fprintln(c.TraceOutput, "---------START-HTTP---------")
	if err != nil {
		return
	}

    val response = call.execute()

    // Body contains nothing.
    assertThat(response.body.bytes().size).isEqualTo(0)
    assertThat(response.body.contentLength()).isEqualTo(0)

    // Content-Length header doesn't exist in a 204 response.
    assertThat(response.header("content-length")).isNull()
    assertThat(response.code).isEqualTo(204)
    val request = server.takeRequest()

		return matches[1]
	}
	return "unknown"
}

func methodNotAllowedHandler(api string) func(w http.ResponseWriter, r *http.Request) {
	return errorResponseHandler
}

// If none of the http routes match respond with appropriate errors
func errorResponseHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method == http.MethodOptions {
		return
	}

  }

  /**
   * Invoked immediately after receiving response headers.
   *
   * This method is always invoked after [responseHeadersStart].
   *
   * @param response the response received over the network. It is an error to access the body of
   *     this response.
   */
  open fun responseHeadersEnd(
    call: Call,
    response: Response,
  ) {
  }

  /**

            assertThat(chain.request().body).isNull()
            val response = chain.proceed(chain.request())
            assertThat(response.header("Connection")).isEqualTo("Upgrade")
            assertThat(response.body).isInstanceOf<UnreadableResponseBody>()
            interceptedCount.incrementAndGet()
            response
          },
        ).build()
    webServer.enqueue(
      MockResponse