> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.telekesher.dev/llms.txt. > For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.telekesher.dev/_mcp/server. # Stop recording POST https://api.telekesher.dev/v1/sessions/{uuid}/recording/stop Content-Type: application/json **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s Stop the active [Recording](/api/recording). The accepted [Operation](/api) is returned immediately. This bucket's high capacity lets a DTMF terminator press right after the recording-start beep end the recording without sharing `recording/start`'s independent bucket. **Triggered webhook:** `recording.ended` is emitted when stop is accepted; it carries `recording_uuid`, the signed public `pull_url`, the `operation_uuid` of the originating `recording/start` command, and `duration`. There is no post-stop reachability probe. A `recording.failed` emitted earlier because the start-liveness check timed out can coexist with this later `recording.ended`; consumers must not treat those events as mutually exclusive. The signed `pull_url` carried by `recording.ended` gets a fresh validity window at that event's emission (24 hours by default). After completion it supports HTTP Range requests. Treat the complete URL as opaque and use it exactly as emitted. Reference: https://docs.telekesher.dev/api/recording/stop ## OpenAPI Specification ```yaml openapi: 3.1.0 info: title: voice-api version: 1.0.0 paths: /v1/sessions/{uuid}/recording/stop: post: operationId: stopRecording summary: Stop recording description: >- **Rate limit: Per command** · **Burst:** 20 · **Refill:** 20 req/s Stop the active [Recording](/api/recording). The accepted [Operation](/api) is returned immediately. This bucket's high capacity lets a DTMF terminator press right after the recording-start beep end the recording without sharing `recording/start`'s independent bucket. **Triggered webhook:** `recording.ended` is emitted when stop is accepted; it carries `recording_uuid`, the signed public `pull_url`, the `operation_uuid` of the originating `recording/start` command, and `duration`. There is no post-stop reachability probe. A `recording.failed` emitted earlier because the start-liveness check timed out can coexist with this later `recording.ended`; consumers must not treat those events as mutually exclusive. The signed `pull_url` carried by `recording.ended` gets a fresh validity window at that event's emission (24 hours by default). After completion it supports HTTP Range requests. Treat the complete URL as opaque and use it exactly as emitted. tags: - recording parameters: - name: uuid in: path description: '[Session](/api/sessions) UUID (format `{5-char-prefix}-{uuid}`).' required: true schema: type: string - name: Authorization in: header description: >- Application auth. Send `Authorization: Bearer :`. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details. required: true schema: type: string - name: Idempotency-Key in: header description: >- Optional client-generated key for a mutating endpoint. It identifies one method, route, query, content type, and exact raw body within the authenticated app. Reusing it for a different request returns 422. While its record exists, a retry replays the original accepted response when available. Keys are valid for 1 hour. Allowed characters: letters, digits, dot, hyphen, underscore; max 128 characters. See the Idempotency guide. required: false schema: type: string responses: '202': description: Command accepted for async execution content: application/json: schema: $ref: '#/components/schemas/AsyncCommandResponse' '400': description: >- Missing `Authorization`, malformed Bearer credentials, or invalid request parameters. A syntactically valid credential with an invalid API key returns `401` instead. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestBadRequestError' '401': description: >- The Bearer credential is syntactically valid but its API key is invalid. Missing `Authorization` or malformed Bearer credentials return `400`. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestUnauthorizedError' '404': description: >- The requested resource was not found or is not owned by the authenticated app. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestNotFoundError' '409': description: >- The request cannot be completed because of state conflict — typically the session is terminating, or the resource (room, recording) is in a state incompatible with this command. On an operation that accepts `Idempotency-Key`, this status can also mean the original request with that key is still in progress; wait for its result rather than sending a different request with the same key. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestConflictError' '413': description: Request body exceeds the endpoint's size limit. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestContentTooLargeError' '415': description: >- A request with a JSON body must use `Content-Type: application/json`. content: application/json: schema: $ref: >- #/components/schemas/StopRecordingRequestUnsupportedMediaTypeError '422': description: >- The `Idempotency-Key` was reused with a different request body. A key maps to one request; use a new key. See the Idempotency guide. content: application/json: schema: $ref: >- #/components/schemas/StopRecordingRequestUnprocessableEntityError '429': description: >- Rate limit exceeded — a per-command, per-room, or per-app token bucket was empty. The `retry_after` field gives the integer seconds to wait before retrying. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestTooManyRequestsError' '500': description: Internal gateway error. content: application/json: schema: $ref: '#/components/schemas/StopRecordingRequestInternalServerError' '503': description: >- When an `Idempotency-Key` was supplied, the idempotency store is unavailable and the request was NOT processed; retry with the same key. Some operations can also return `503` for an unavailable room/session source or another documented dependency even when no key was supplied; in that case this response does not imply idempotency-store failure. See the operation description and the Idempotency guide. content: application/json: schema: $ref: >- #/components/schemas/StopRecordingRequestServiceUnavailableError requestBody: content: application/json: schema: $ref: '#/components/schemas/CommandRequest' servers: - url: https://api.telekesher.dev description: Gateway server components: schemas: CommandRequest: type: object properties: operation_uuid: type: string format: uuid description: >- Optional caller-supplied per-command correlation id, a bare lowercase RFC-4122 v4 UUID (no prefix). Echoed back as `operation_uuid` in the 202 ack. A later lifecycle webhook carries it only when the gateway can unambiguously associate that event with this command; the field is correlation, not proof of causation. When omitted, the gateway mints one. Not an idempotency key — request deduplication is the `Idempotency-Key` header. Invalid input (not a v4 UUID) is rejected with `400 invalid_request`. title: CommandRequest AsyncCommandResponseStatus: type: string enum: - in_progress - completed title: AsyncCommandResponseStatus AsyncCommandResponse: type: object properties: operation_uuid: type: string format: uuid status: $ref: '#/components/schemas/AsyncCommandResponseStatus' already_ended: type: boolean enum: - true description: >- Optional. Set to `true` on idempotent terminal commands when the session was already in a terminal state at the time the request was received. Absent otherwise. required: - operation_uuid - status description: >- 202 Accepted body for an async command. The command's success/failure is delivered later as a domain lifecycle webhook (e.g. `playback.started`/`stopped`/`failed`, `command.recording.start.accepted`, `digits.collected`, `session.answered`/`session.ended`). A lifecycle event carries `operation_uuid` only when it can be unambiguously associated with the submitted command — not as a generic ack on this response. title: AsyncCommandResponse V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode: type: string enum: - invalid_request - payload_too_large - result_set_too_large - unauthorized - forbidden - not_found - conflict - recording_not_active - room_full - rate_limited - unavailable - internal description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. title: V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode StopRecordingRequestBadRequestError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestBadRequestError StopRecordingRequestUnauthorizedError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestUnauthorizedError StopRecordingRequestNotFoundError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestNotFoundError StopRecordingRequestConflictError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestConflictError StopRecordingRequestContentTooLargeError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestContentTooLargeError StopRecordingRequestUnsupportedMediaTypeError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestUnsupportedMediaTypeError StopRecordingRequestUnprocessableEntityError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestUnprocessableEntityError StopRecordingRequestTooManyRequestsError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - retry_after - success title: StopRecordingRequestTooManyRequestsError StopRecordingRequestInternalServerError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestInternalServerError StopRecordingRequestServiceUnavailableError: type: object properties: code: $ref: >- #/components/schemas/V1SessionsUuidRecordingStopPostResponsesContentApplicationJsonSchemaCode description: >- Stable, machine-readable error class from a closed set of twelve values. Branch on this for programmatic handling. New codes are only added with a documented API change. Maps to the HTTP status as follows: `invalid_request` (400/415/422), `payload_too_large` and `result_set_too_large` (413), `unauthorized` (401), `forbidden` (403), `not_found` (404), `recording_not_active` (400); `conflict` and `room_full` (409), `rate_limited` (429), `unavailable` (502/503/529), `internal` (500). Note: `413` is the only status shared by two codes — `payload_too_large` means the request body exceeded its size cap, while `result_set_too_large` means a list response exceeded the system result ceiling (narrow the query with filters and retry). Note: `unavailable` is the only code that maps to multiple HTTP statuses, which represent different retry conditions: `502` means a command dependency could not accept the request, `503` means a required service (including the idempotency store) is temporarily unavailable, and `529` means the gateway is overloaded with no spare capacity. Use the HTTP status and operation description, not just `code`, to distinguish them. error: type: string description: >- Human-readable, English-only error message. For display only — phrasing may change without notice, so branch on `code`, not on this string. retry_after: type: integer description: >- Integer seconds to wait before retrying. Present on `429` (the time until the denying token bucket refills by one token) and on `529` (overload back-off hint). Mirrors the `Retry-After` response header. success: type: boolean required: - code - error - success title: StopRecordingRequestServiceUnavailableError securitySchemes: bearerAppAuth: type: http scheme: bearer description: >- Application auth. Send `Authorization: Bearer :`. See [Authentication](https://voice-platform.docs.buildwithfern.com/api/authentication) for details. ``` ## Examples **Request** ```json {} ``` **Response** ```json { "operation_uuid": "550e8400-e29b-41d4-a716-446655440000", "status": "in_progress" } ``` **SDK Code** ```python Recording_stopRecording_example import requests url = "https://api.telekesher.dev/v1/sessions/uuid/recording/stop" payload = {} headers = { "Authorization": "Bearer ", "Content-Type": "application/json" } response = requests.post(url, json=payload, headers=headers) print(response.json()) ``` ```javascript Recording_stopRecording_example const url = 'https://api.telekesher.dev/v1/sessions/uuid/recording/stop'; const options = { method: 'POST', headers: {Authorization: 'Bearer ', 'Content-Type': 'application/json'}, body: '{}' }; try { const response = await fetch(url, options); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } ``` ```go Recording_stopRecording_example package main import ( "fmt" "strings" "net/http" "io" ) func main() { url := "https://api.telekesher.dev/v1/sessions/uuid/recording/stop" payload := strings.NewReader("{}") req, _ := http.NewRequest("POST", url, payload) req.Header.Add("Authorization", "Bearer ") req.Header.Add("Content-Type", "application/json") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() body, _ := io.ReadAll(res.Body) fmt.Println(res) fmt.Println(string(body)) } ``` ```ruby Recording_stopRecording_example require 'uri' require 'net/http' url = URI("https://api.telekesher.dev/v1/sessions/uuid/recording/stop") http = Net::HTTP.new(url.host, url.port) http.use_ssl = true request = Net::HTTP::Post.new(url) request["Authorization"] = 'Bearer ' request["Content-Type"] = 'application/json' request.body = "{}" response = http.request(request) puts response.read_body ``` ```java Recording_stopRecording_example import com.mashape.unirest.http.HttpResponse; import com.mashape.unirest.http.Unirest; HttpResponse response = Unirest.post("https://api.telekesher.dev/v1/sessions/uuid/recording/stop") .header("Authorization", "Bearer ") .header("Content-Type", "application/json") .body("{}") .asString(); ``` ```php Recording_stopRecording_example request('POST', 'https://api.telekesher.dev/v1/sessions/uuid/recording/stop', [ 'body' => '{}', 'headers' => [ 'Authorization' => 'Bearer ', 'Content-Type' => 'application/json', ], ]); echo $response->getBody(); ``` ```csharp Recording_stopRecording_example using RestSharp; var client = new RestClient("https://api.telekesher.dev/v1/sessions/uuid/recording/stop"); var request = new RestRequest(Method.POST); request.AddHeader("Authorization", "Bearer "); request.AddHeader("Content-Type", "application/json"); request.AddParameter("application/json", "{}", ParameterType.RequestBody); IRestResponse response = client.Execute(request); ``` ```swift Recording_stopRecording_example import Foundation let headers = [ "Authorization": "Bearer ", "Content-Type": "application/json" ] let parameters = [] as [String : Any] let postData = JSONSerialization.data(withJSONObject: parameters, options: []) let request = NSMutableURLRequest(url: NSURL(string: "https://api.telekesher.dev/v1/sessions/uuid/recording/stop")! as URL, cachePolicy: .useProtocolCachePolicy, timeoutInterval: 10.0) request.httpMethod = "POST" request.allHTTPHeaderFields = headers request.httpBody = postData as Data let session = URLSession.shared let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in if (error != nil) { print(error as Any) } else { let httpResponse = response as? HTTPURLResponse print(httpResponse) } }) dataTask.resume() ```