Configure meeting space settings

A meeting space represents a virtual place or a persistent object (such as a meeting room) where conferences are held. A meeting space also helps users meet and find shared resources.

When you create a meeting space using the spaces.create method, it returns an instance of a spaces resource. The resource includes the SpaceConfig object that's the configuration for the meeting space. It also contains the ActiveConference object that's a link to the current conferenceRecords resource within the meeting space. For more information on managing a meeting space, see Manage meeting spaces.

The following sections detail how to configure a meeting space using these objects and methods.

Set moderation and meeting access

You can set how users join a meeting, the moderation modes, the feature restrictions, and the permissions users receive when they join a meeting, through the SpaceConfig object.

Access meeting spaces

To determine who can join a meeting space without knocking, set the accessType field using the AccessType object. You can choose from multiple settings on whether to automatically allow attendees to join. The field defaults to the user's default access settings.

To define the entry points that can be used to join meetings hosted in a meeting space, set the entryPointAccess field using the EntryPointAccess object. Set to ALL to allow all entry points or CREATOR_APP_ONLY to scope the entry points to only those owned by the Google Cloud project that created the meeting space.

The following code sample shows how to configure access settings for a meeting space:

Java

import com.google.apps.meet.v2.Space;
import com.google.apps.meet.v2.SpaceConfig;
import com.google.apps.meet.v2.SpacesServiceClient;
import com.google.apps.meet.v2.UpdateSpaceRequest;
import com.google.protobuf.FieldMask;

public class ConfigureSpaceAccess {
  public static void main(String[] args) throws Exception {
    try (SpacesServiceClient client = SpacesServiceClient.create()) {
      Space space =
          Space.newBuilder()
              .setName("spaces/SPACE_NAME")
              .setConfig(
                  SpaceConfig.newBuilder()
                      .setAccessType(SpaceConfig.AccessType.RESTRICTED)
                      .setEntryPointAccess(SpaceConfig.EntryPointAccess.ALL)
                      .build())
              .build();
      FieldMask updateMask =
          FieldMask.newBuilder()
              .addPaths("config.access_type")
              .addPaths("config.entry_point_access")
              .build();
      UpdateSpaceRequest request =
          UpdateSpaceRequest.newBuilder()
              .setSpace(space)
              .setUpdateMask(updateMask)
              .build();
      Space response = client.updateSpace(request);
      System.out.println("Updated space: " + response.getName());
    }
  }
}

Node.js

const {SpacesServiceClient} = require('@google-apps/meet').v2;

async function configureSpaceAccess(spaceName) {
  const meetClient = new SpacesServiceClient();
  const [response] = await meetClient.updateSpace({
    space: {
      name: spaceName,
      config: {
        accessType: 'RESTRICTED',
        entryPointAccess: 'ALL',
      },
    },
    updateMask: {
      paths: ['config.access_type', 'config.entry_point_access'],
    },
  });
  console.log(`Updated space: ${response.name}`);
  return response;
}

Python

from google.apps import meet_v2
from google.protobuf import field_mask_pb2

def configure_space_access(space_name):
    client = meet_v2.SpacesServiceClient()
    space = meet_v2.Space(
        name=space_name,
        config=meet_v2.SpaceConfig(
            access_type=meet_v2.SpaceConfig.AccessType.RESTRICTED,
            entry_point_access=meet_v2.SpaceConfig.EntryPointAccess.ALL,
        ),
    )
    update_mask = field_mask_pb2.FieldMask(
        paths=["config.access_type", "config.entry_point_access"]
    )
    request = meet_v2.UpdateSpaceRequest(
        space=space,
        update_mask=update_mask
    )
    response = client.update_space(request=request)
    print(f"Updated space: {response.name}")
    return response

Apps Script

function configureSpaceAccess(spaceName) {
  const baseUrl = 'https://meet.googleapis.com/v2/';
  const mask = 'updateMask=config.accessType,config.entryPointAccess';
  const response = UrlFetchApp.fetch(`${baseUrl}${spaceName}?${mask}`, {
    method: 'patch',
    contentType: 'application/json',
    headers: {
      Authorization: 'Bearer ' + ScriptApp.getOAuthToken(),
    },
    payload: JSON.stringify({
      config: {
        accessType: 'RESTRICTED',
        entryPointAccess: 'ALL',
      },
    }),
  });
  const space = JSON.parse(response.getContentText());
  Logger.log('Updated space: ' + space.name);
  return space;
}

cURL

curl -X PATCH \
  "https://meet.googleapis.com/v2/spaces/SPACE_NAME?updateMask=config.accessType,config.entryPointAccess" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "config": {
      "accessType": "RESTRICTED",
      "entryPointAccess": "ALL"
    }
  }'

Replace ACCESS_TOKEN with the access token that grants access to the API.

Replace the space name value with the unique server-generated ID for the meeting space.

Moderate meeting spaces

To moderate a meeting, you can set the moderation field using the Moderation object. When the moderation mode is on, the meeting organizer has control over the meeting with features such as co-host management (see spaces.members) and feature restrictions using the moderationRestrictions field. For more information on members, see Manage meeting space members.

To define feature restrictions when the meeting is moderated (moderation is on), set the moderationRestrictions field using the ModerationRestrictions object. The restrictions define who has permission within the meeting space to send chat messages or reactions, or to share their screen.

To set the feature restrictions on the moderationRestrictions field, use the RestrictionType to apply the chatRestriction, reactionRestriction, and presentRestriction. Set to HOSTS_ONLY to apply the permissions to both the meeting organizer and co-hosts, or NO_RESTRICTION to apply to all participants.

To restrict the default role assigned to users as viewer, set the defaultJoinAsViewerType field using the DefaultJoinAsViewerType. If defaultJoinAsViewerType is on, users join as viewers. If off, users join as contributors. Default is off. If an explicit role is set for a user in spaces.members, the user joins as that role.

Generate attendance report

To create an attendance report for the meeting space, set the attendanceReportGenerationType field using the AttendanceReportGenerationType object. If a report is requested, Google Meet saves the attendance report to the meeting organizer's Google Drive and an email is also sent.

Manage auto artifacts

Meeting organizers, but not co-hosts, can pre-configure auto-recording, auto-transcripts, and smart notes within the meeting space. When these settings are enabled, the meeting space is recorded, transcripts are generated, and meeting notes are captured and organized into Google Docs automatically. Each feature is independent and is set per meeting space. Recording captions are only available in English.

You can pre-configure the auto artifacts either when you create a meeting space or once the meeting space is created. Both methods require the meetings.space.settings OAuth scope. For more information, see OAuth scopes by use case.

You can also set up auto artifacts for meetings created from Google Calendar.

To set auto artifacts, use the ArtifactConfig object within the SpaceConfig object. ArtifactConfig is made up of the recordingConfig, transcriptionConfig, and smartNotesConfig fields.

Each field is mapped to a similar object such as RecordingConfig, TranscriptionConfig, and SmartNotesConfig. To set each object, use the AutoGenerationType to toggle the config object on or off.

To retrieve the artifacts created during a conference, see Work with artifacts.

Difference between transcripts and smart notes

While both meeting transcripts and smart notes (also known as "take notes for me") capture information from your meeting, these features serve different purposes and produce different artifacts.

The following table shows how they differ:

Feature Transcripts Smart notes
Overview A verbatim, word-for-word record. A concise summary of key points generated by Gemini.
Detail level 100% detail. Everything said is written down. High-level. Focuses on decisions and action items.
Use case Legal compliance, checking exact quotes, and user accessibility. Allows late participants to catch up instantly; automates minute-taking and project tracking.
Real-time usage Used for captions. The file is generated after the call. You can view the summary building in the side panel during the call.
Output A long Docs document with speaker name and timestamps. A concise Docs document of meeting notes with sections and bullet points.
Citation Contains the full text that can be linked to. Includes citations (timestamps) that link back to the specific moment in the transcript for context, if both transcripts and smart notes are enabled. For more information, see When both features are enabled.

When both features are enabled

While each feature can be used separately, both transcripts and smart notes can also be used at the same time to create better post-meeting artifacts.

When both are enabled, you'll see citations in your generated smart notes document. These citations are located throughout the details section and link to specific timestamps in the meeting transcript. By clicking on these citations, you can jump directly to the relevant section in the transcript to gain a deeper understanding of the discussion.

During the meeting, participants see indicators that both features are active. They must remain active for the duration of the meeting to generate clickable citations. Even though the files are interlinked, the system still generates two distinct documents in the host's Drive. Both files are also automatically attached to the Calendar event.

For more information on OAuth scopes required for meeting spaces and settings, see OAuth scopes by use case.