> 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.

# Update room

PUT https://%7BYour_Space_Name%7D.signalwire.com/api/video/rooms/{id}
Content-Type: application/json

Changes how an existing Video Room runs for subsequent joins while preserving the same project resource and unique name. Use client SDK controls for actions on participants in an active session.

#### Permissions

The API token used to authenticate must have the following scope(s) enabled to make a successful request: _Video_.

[Learn more about API scopes](/docs/platform/your-signalwire-api-space).

Reference: https://signalwire.com/docs/apis/rest/video/rooms/update-room

## Authentication

- `Authorization` header (basic auth, required) — SignalWire Basic Authentication using Project ID and API Token. The client sends HTTP requests with the Authorization header containing the word Basic followed by a space and a base64-encoded string of project_id:token. The project ID will be used as the username and the API token as the password. Example: ``` Authorization: Basic base64(project_id:token) ```

## Request

### Path parameters

- `id` (string, required) — Unique ID of the room.

### Body (application/json)

This endpoint expects a Video.UpdateRoomRequest.

- `display_name` (string, optional) — Display name of the room. Maximum of 200 characters. Defaults to the value of name.
- `description` (string, optional) — Description of the room. Maximum of 3000 characters.
- `max_members` (integer, optional, default: 20) — The maximum number of members in the room at a time. Must be at least 1 to a maximum of 300.
- `quality` (enum, optional, default: 720p) — The room's resolution.
  - Allowed values: `720p`, `1080p`
- `join_from` (datetime, optional) — Room does not accept new participants before this time. Expects RFC 3339 datetime: `2022-01-01T23:59:60Z`. Date only: `2022-01-01` will be converted to `2022-01-01T00:00:00Z`.
- `join_until` (datetime, optional) — Room stops accepting new participants at this time, but keeps running until all participants leave. Expects RFC 3339 datetime: `2022-01-01T23:59:60Z`. Date only: `2022-01-01` will be converted to `2022-01-01T00:00:00Z`.
- `remove_at` (datetime, optional) — Remove users from the room at this time. Expects RFC 3339 datetime: `2022-01-01T23:59:60Z`. Date only: `2022-01-01` will be converted to `2022-01-01T00:00:00Z`.
- `remove_after_seconds_elapsed` (integer, optional) — Remove users after they are in the room for N seconds.
- `layout` (enum, optional, default: grid-responsive) — The room's initial layout.
  - Allowed values: `grid-responsive`, `grid-responsive-mobile`, `highlight-1-responsive`, `1x1`, `2x1`, `2x2`, `5up`, `3x3`, `4x4`, `5x5`, `6x6`, `8x8`, `10x10`
- `record_on_start` (boolean, optional, default: false) — Specifies whether to start recording a Room Session when one is started for this Room.
- `enable_room_previews` (boolean, optional, default: false) — Whether a video with a preview of the content of the room is to be generated.
- `meta` (VideoUpdateRoomRequestMeta, optional) — User-defined metadata for the room. Must be a valid JSON object. Maximum of 2000 characters when serialized.
- `sync_audio_video` (boolean, optional) — Enable/disable jitter buffer audio-video sync.

## Response

### 200

The request has succeeded.

- `id` (string, required) — A unique identifier for the room.
- `name` (string, required) — A named unique identifier for the room.
- `display_name` (string, required, nullable) — Display name of the room.
- `description` (string, required, nullable) — Description of the room.
- `max_members` (integer, required) — The maximum number of members in the room at a time.
- `quality` (enum, required) — The room's resolution.
  - Allowed values: `720p`, `1080p`
- `fps` (integer, required) — Frames per second parameter of room video quality.
- `join_from` (datetime, required, nullable) — Room does not accept new participants before this time.
- `join_until` (datetime, required, nullable) — Room stops accepting new participants at this time.
- `remove_at` (datetime, required, nullable) — Remove users from the room at this time.
- `remove_after_seconds_elapsed` (integer, required, nullable) — Remove users after they are in the room for N seconds.
- `layout` (enum, required) — The room's initial layout.
  - Allowed values: `grid-responsive`, `grid-responsive-mobile`, `highlight-1-responsive`, `1x1`, `2x1`, `2x2`, `5up`, `3x3`, `4x4`, `5x5`, `6x6`, `8x8`, `10x10`
- `record_on_start` (boolean, required) — Specifies whether to start recording a Room Session when one is started for this Room.
- `tone_on_entry_and_exit` (boolean, required) — Whether a tone is played when participants enter or exit the room.
- `room_join_video_off` (boolean, required) — Whether the room's video is turned off when participants join.
- `user_join_video_off` (boolean, required) — Whether a user's video is turned off when they join the room.
- `enable_room_previews` (boolean, required, nullable) — Whether a video with a preview of the content of the room is to be generated.
- `sync_audio_video` (boolean, required, nullable) — Enable/disable jitter buffer audio-video sync.
- `meta` (VideoRoomResponseMeta, required, nullable) — User-defined metadata for the room.
- `prioritize_handraise` (boolean, required) — Whether hand raises are prioritized in the room layout.
- `created_at` (datetime, required) — Timestamp when the room was created.
- `updated_at` (datetime, required) — Timestamp when the room was last updated.
- `active_session` (Video.ActiveSession, optional) — Active session information for the room.

## Errors

### 400 Bad Request Error

The request is invalid.

- `error` (enum, required)
  - Allowed values: `Bad Request`

### 401 Unauthorized Error

Access is unauthorized.

- `error` (enum, required)
  - Allowed values: `Unauthorized`

### 404 Not Found Error

The server cannot find the requested resource.

- `error` (enum, required)
  - Allowed values: `Not Found`

### 422 Unprocessable Entity Error

The request contains invalid parameters. See errors for details.

- `errors` (list of Types.StatusCodes.RestApiErrorItem, required) — List of validation errors.

### 500 Internal Server Error

An internal server error occurred.

- `error` (enum, required)
  - Allowed values: `Internal Server Error`

## Types

### VideoUpdateRoomRequestMeta

User-defined metadata for the room. Must be a valid JSON object. Maximum of 2000 characters when serialized.

### VideoRoomResponseMeta

User-defined metadata for the room.

### Video.ActiveSession

Active session information for a room.

- `id` (string, optional) — Unique ID of the session.
- `room_id` (string, optional) — Unique ID of the Room if the Session was created from a Room and was not an auto-created Session.
- `name` (string, optional) — The named identifier of room session.
- `display_name` (string, optional) — Display name of room, no character limitations. Maximum of 200 characters. Defaults to the value of name.
- `join_from` (datetime, optional) — Room Session does not accept new Members before this time.
- `join_until` (datetime, optional) — Room Session stops accepting new Members at this time.
- `remove_at` (datetime, optional) — Remove Members from the Room Session at this time.
- `remove_after_seconds_elapsed` (integer, optional) — Remove Members after they are in the Room Session for N seconds.
- `layout` (string, optional) — The Room Session's initial layout. See documentation for a full list of supported layouts.
- `max_members` (integer, optional) — The maximum number of members allowed in the room at a time.
- `fps` (enum, optional) — The Room Session's frames per second.
  - Allowed values: `20`, `30`
- `quality` (enum, optional) — The Room Session's resolution.
  - Allowed values: `720p`, `1080p`
- `start_time` (datetime, optional) — Start time of the session.
- `end_time` (datetime, optional) — End time of the session.
- `duration` (integer, optional) — How long, in seconds, the Room Session lasted.
- `status` (enum, optional) — Status of the session.
  - Allowed values: `in-progress`, `completed`
- `record_on_start` (boolean, optional) — Whether a recording was automatically started when this Room Session began.
- `enable_room_previews` (boolean, optional) — Whether a video with a preview of the content of the room is to be generated.
- `preview_url` (string, optional) — If room previews are enabled and the room session is in progress, this is the URL of the preview video.
- `audio_video_sync` (boolean, optional) — Enable/disable jitter buffer audio-video sync.

### Types.StatusCodes.RestApiErrorItem

Details about a specific error.

- `type` (string, required) — The category of error.
- `code` (string, required) — A specific error code.
- `message` (string, required) — A description of what caused the error.
- `url` (string, required) — A link to documentation about this error.
- `attribute` (string, optional, nullable) — The request parameter that caused the error, if applicable.

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "id": "c22d24f6-5a47-4597-9a23-c7d01e696b92",
  "name": "my_room",
  "display_name": "My Room's Name",
  "description": "This room will be used for full company all hands meetings",
  "max_members": 20,
  "quality": "720p",
  "fps": 20,
  "join_from": "2022-01-01T00:00:00Z",
  "join_until": "2022-12-31T23:59:59Z",
  "remove_at": "2022-12-31T23:59:59Z",
  "remove_after_seconds_elapsed": 120,
  "layout": "grid-responsive",
  "record_on_start": false,
  "tone_on_entry_and_exit": true,
  "room_join_video_off": false,
  "user_join_video_off": false,
  "enable_room_previews": false,
  "sync_audio_video": true,
  "meta": {},
  "prioritize_handraise": false,
  "created_at": "2022-01-01T10:00:00Z",
  "updated_at": "2022-01-01T11:00:00Z",
  "active_session": {
    "id": "c22d24f6-5a47-4597-9a23-c7d01e696b92",
    "room_id": "a1b2c3d4-5e6f-7890-abcd-ef1234567890",
    "name": "my_example_room",
    "display_name": "My Room's Name",
    "join_from": "2022-01-01T00:00:00Z",
    "join_until": "2022-12-31T23:59:59Z",
    "remove_at": "2022-12-31T23:59:59Z",
    "remove_after_seconds_elapsed": 120,
    "layout": "grid-responsive",
    "max_members": 20,
    "fps": 20,
    "quality": "720p",
    "start_time": "2022-01-01T10:00:00Z",
    "end_time": "2022-01-01T11:00:00Z",
    "duration": 120,
    "status": "completed",
    "record_on_start": true,
    "enable_room_previews": true,
    "preview_url": "https://example.signalwire.com/api/video/room_sessions/c22d24f6-5a47-4597-9a23-c7d01e696b92/preview",
    "audio_video_sync": true
  }
}
```

**SDK Code**

```python
import requests

url = "https://{your_space_name}.signalwire.com/api/video/rooms/id"

payload = {}
headers = {
    "Content-Type": "application/json"
}

response = requests.put(url, json=payload, headers=headers, auth=("<project_id>", "<api_token>"))

print(response.json())
```

```javascript
const url = 'https://{your_space_name}.signalwire.com/api/video/rooms/id';
const credentials = btoa("<project_id>:<api_token>");

const options = {
  method: 'PUT',
  headers: {
    Authorization: `Basic ${credentials}`,
    '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
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://{your_space_name}.signalwire.com/api/video/rooms/id"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.SetBasicAuth("<project_id>", "<api_token>")
	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
require 'uri'
require 'net/http'

url = URI("https://{your_space_name}.signalwire.com/api/video/rooms/id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request.basic_auth("<project_id>", "<api_token>")
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.put("https://{your_space_name}.signalwire.com/api/video/rooms/id")
  .basicAuth("<project_id>", "<api_token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PUT', 'https://{your_space_name}.signalwire.com/api/video/rooms/id', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
    'auth' => ['<project_id>', '<api_token>'],
]);

echo $response->getBody();
```

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://{your_space_name}.signalwire.com/api/video/rooms/id");
client.Authenticator = new HttpBasicAuthenticator("<project_id>", "<api_token>");
var request = new RestRequest(Method.PUT);

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<project_id>:<api_token>".utf8).base64EncodedString()

let headers = [
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://{your_space_name}.signalwire.com/api/video/rooms/id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
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()
```