Collabora con i partecipanti

Questa guida spiega come ottenere i dettagli dei partecipanti che hanno partecipato a una conferenza passata o che sono in una conferenza attiva, insieme alle informazioni sulla sessione, utilizzando l'API REST di Google Meet.

Un partecipante è una persona che ha partecipato a una chiamata o che utilizza la modalità Complementare, che guarda la chiamata come spettatore o un dispositivo della sala connesso a una chiamata. Esiste una participants risorsa per ogni persona.

Una sessione partecipante è un ID sessione univoco creato per ogni coppia di partecipante e dispositivo che partecipa a una chiamata. Esiste una participantSessions risorsa per ogni sessione. Se il partecipante partecipa alla stessa chiamata più volte dalla stessa coppia partecipante-dispositivo, a ciascuno vengono assegnati ID sessione univoci.

Se sei un proprietario o un partecipante di uno spazio di riunione, puoi chiamare i metodi get() e list() sia sulle risorse participants sia su quelle participantSessions per recuperare i record dei partecipanti.

L'autenticazione e l'autorizzazione con le credenziali dell'utente consentono alle app Google Meet di accedere ai dati dell'utente ed eseguire operazioni per conto dell'utente autenticato. L'autenticazione con la delega a livello di dominio ti consente di autorizzare l'account di servizio di un'applicazione ad accedere ai dati dei tuoi utenti senza che sia necessario il consenso di ogni utente.

Partecipanti

Le sezioni seguenti descrivono in dettaglio come ottenere informazioni sui partecipanti di un record della conferenza.

La risorsa participants si unisce al campo user. Un user può essere solo uno dei seguenti oggetti:

  • Un signedinUser è:

    • Un utente che partecipa da un computer personale, un dispositivo mobile o tramite la modalità Companion.

    • Un account robot utilizzato dai dispositivi per sale conferenze.

  • Un anonymousUser è un utente non identificato che non ha eseguito l'accesso a un Account Google.

  • Un phoneUser è un utente che si connette da uno smartphone la cui identità è sconosciuta perché non ha eseguito l'accesso con un Account Google.

Tieni presente che, sebbene tutti e tre gli oggetti restituiscano un displayName, signedinUser inoltre restituisce un ID user univoco interoperabile con l'API SDK Admin e con l'API Persone. Formato: users/{user}. Per ulteriori informazioni sull'utilizzo dell'ID user con l'API People, consulta Recupero dei dettagli dei partecipanti con l'API People.

Visualizzare i dettagli di un partecipante

Per visualizzare i dettagli di un partecipante specifico, utilizza il metodo get() nella risorsa participants con il parametro di percorso name. Se non conosci il nome del partecipante, puoi elencare tutti i nomi dei partecipanti utilizzando il metodo list().

Il metodo restituisce i dati di un partecipante come istanza di una risorsa participants.

Il seguente esempio di codice mostra come recuperare un partecipante specifico:

Java

java-meet/samples/snippets/generated/com/google/apps/meet/v2/conferencerecordsservice/getparticipant/AsyncGetParticipant.java
import com.google.api.core.ApiFuture;
import com.google.apps.meet.v2.ConferenceRecordsServiceClient;
import com.google.apps.meet.v2.GetParticipantRequest;
import com.google.apps.meet.v2.Participant;
import com.google.apps.meet.v2.ParticipantName;

public class AsyncGetParticipant {

  public static void main(String[] args) throws Exception {
    asyncGetParticipant();
  }

  public static void asyncGetParticipant() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (ConferenceRecordsServiceClient conferenceRecordsServiceClient =
        ConferenceRecordsServiceClient.create()) {
      GetParticipantRequest request =
          GetParticipantRequest.newBuilder()
              .setName(ParticipantName.of("[CONFERENCE_RECORD]", "[PARTICIPANT]").toString())
              .build();
      ApiFuture<Participant> future =
          conferenceRecordsServiceClient.getParticipantCallable().futureCall(request);
      // Do something.
      Participant response = future.get();
    }
  }
}

Node.js

packages/google-apps-meet/samples/generated/v2/conference_records_service.get_participant.js
/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. Resource name of the participant.
 */
// const name = 'abc123'

// Imports the Meet library
const {ConferenceRecordsServiceClient} = require('@google-apps/meet').v2;

// Instantiates a client
const meetClient = new ConferenceRecordsServiceClient();

async function callGetParticipant() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const response = await meetClient.getParticipant(request);
  console.log(response);
}

callGetParticipant();

Python

packages/google-apps-meet/samples/generated_samples/meet_v2_generated_conference_records_service_get_participant_async.py
# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.apps import meet_v2


async def sample_get_participant():
    # Create a client
    client = meet_v2.ConferenceRecordsServiceAsyncClient()

    # Initialize request argument(s)
    request = meet_v2.GetParticipantRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_participant(request=request)

    # Handle the response
    print(response)

Sostituisci il nome del partecipante con il nome dell'ID partecipante specifico in un record della conferenza.

Elenca tutti i partecipanti

Per elencare i dettagli di tutti i partecipanti in un record della conferenza, utilizza il metodo list() nella risorsa participants con il parametro di percorso parent. Formato: conferenceRecords/{conferenceRecord}.

Il metodo restituisce un elenco di partecipanti alla conferenza, ordinati in base a earliestStartTime in ordine decrescente, come istanza di una risorsa participants. Per regolare le dimensioni della pagina e filtrare i risultati della query, consulta Personalizzare la paginazione o filtrare l'elenco dei partecipanti.

Il seguente esempio di codice mostra come elencare tutti i partecipanti di una registrazione della conferenza:

Java

java-meet/samples/snippets/generated/com/google/apps/meet/v2/conferencerecordsservice/listparticipants/AsyncListParticipants.java
import com.google.api.core.ApiFuture;
import com.google.apps.meet.v2.ConferenceRecordName;
import com.google.apps.meet.v2.ConferenceRecordsServiceClient;
import com.google.apps.meet.v2.ListParticipantsRequest;
import com.google.apps.meet.v2.Participant;

public class AsyncListParticipants {

  public static void main(String[] args) throws Exception {
    asyncListParticipants();
  }

  public static void asyncListParticipants() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (ConferenceRecordsServiceClient conferenceRecordsServiceClient =
        ConferenceRecordsServiceClient.create()) {
      ListParticipantsRequest request =
          ListParticipantsRequest.newBuilder()
              .setParent(ConferenceRecordName.of("[CONFERENCE_RECORD]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      ApiFuture<Participant> future =
          conferenceRecordsServiceClient.listParticipantsPagedCallable().futureCall(request);
      // Do something.
      for (Participant element : future.get().iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Node.js

packages/google-apps-meet/samples/generated/v2/conference_records_service.list_participants.js
/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. Format: `conferenceRecords/{conference_record}`
 */
// const parent = 'abc123'
/**
 *  Maximum number of participants to return. The service might return fewer
 *  than this value.
 *  If unspecified, at most 100 participants are returned.
 *  The maximum value is 250; values above 250 are coerced to 250.
 *  Maximum might change in the future.
 */
// const pageSize = 1234
/**
 *  Page token returned from previous List Call.
 */
// const pageToken = 'abc123'
/**
 *  Optional. User specified filtering condition in EBNF
 *  format (https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form).
 *  The following are the filterable fields:
 *  * `earliest_start_time`
 *  * `latest_end_time`
 *  For example, `latest_end_time IS NULL` returns active participants in
 *  the conference.
 */
// const filter = 'abc123'

// Imports the Meet library
const {ConferenceRecordsServiceClient} = require('@google-apps/meet').v2;

// Instantiates a client
const meetClient = new ConferenceRecordsServiceClient();

async function callListParticipants() {
  // Construct request
  const request = {
    parent,
  };

  // Run request
  const iterable = meetClient.listParticipantsAsync(request);
  for await (const response of iterable) {
      console.log(response);
  }
}

callListParticipants();

Python

packages/google-apps-meet/samples/generated_samples/meet_v2_generated_conference_records_service_list_participants_async.py
# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.apps import meet_v2


async def sample_list_participants():
    # Create a client
    client = meet_v2.ConferenceRecordsServiceAsyncClient()

    # Initialize request argument(s)
    request = meet_v2.ListParticipantsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_participants(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Sostituisci il valore principale con il nome del record della conferenza.

Personalizzare la paginazione o filtrare l'elenco dei partecipanti

Passa i seguenti parametri di query per personalizzare la paginazione o filtrare i partecipanti:

  • pageSize: il numero massimo di partecipanti da restituire. Il servizio potrebbe restituire un numero inferiore a questo valore. Se non specificato, vengono restituiti al massimo 100 partecipanti. Il valore massimo è 250; i valori superiori a 250 vengono automaticamente impostati su 250.

  • pageToken: un token di pagina ricevuto da una precedente chiamata dell'elenco. Fornisci questo token per recuperare la pagina successiva.

  • filter: facoltativo. Un filtro di query per recuperare elementi specifici nei risultati della risorsaparticipants.

    Puoi utilizzare i campi earliestStartTime o latestEndTime per filtrare in base agli utenti che si sono uniti prima o che sono usciti dopo un determinato momento. Entrambi i campi utilizzano il formato Timestamp in formato "Zulu" UTC RFC 3339, con risoluzione in nanosecondi e fino a nove cifre decimali: {year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z. Ad esempio:

    • earliestStartTime < 2023-10-01T15:01:23Z
    • latestEndTime < 2023-10-01T15:01:23Z

    Per elencare tutti i partecipanti attivi di una conferenza esistente, utilizza latestEndTime IS NULL.

Recuperare i dettagli dei partecipanti con l'API People

Per recuperare i dettagli su un partecipante, utilizza il metodo get() sulla risorsa people nell'API People.

  1. Estrai l'ID della persona dalla risorsa participant utilizzando il componente finale del percorso. Ad esempio, se il valore della risorsa participant è conferenceRecords/abc-123/participants/12345, l'ID per l'API People è 12345.

  2. Includi READ_SOURCE_TYPE_PROFILE, READ_SOURCE_TYPE_CONTACT e READ_SOURCE_TYPE_OTHER_CONTACT ReadSourceType. In questo modo, sia gli utenti interni di un'organizzazione Google Workspace sia i contatti esterni sono inclusi nella risposta.

Il seguente esempio di codice mostra come cercare sia i profili dell'organizzazione sia i contatti di una persona:

cURL

curl \
   'https://people.googleapis.com/v1/people/PERSON_ID?personFields=names%2CemailAddresses&sources=READ_SOURCE_TYPE_OTHER_CONTACT&sources=READ_SOURCE_TYPE_PROFILE&sources=READ_SOURCE_TYPE_CONTACT' \
   --header 'Authorization: Bearer ACCESS_TOKEN' \
   --header 'Accept: application/json' \
   --compressed

Sostituisci quanto segue:

  • PERSON_ID: l'ID della persona da trovare.
  • ACCESS_TOKEN: il token di accesso che concede l'accesso a più API.

Sessioni dei partecipanti

Le seguenti sezioni descrivono in dettaglio come ottenere informazioni sulle sessioni dei partecipanti di un partecipante in un record della conferenza.

Visualizzare i dettagli di una sessione del partecipante

Per visualizzare i dettagli di una sessione del partecipante specifica, utilizza il metodo get() nella risorsa participantSessions con il parametro di percorso name. Se non conosci il nome della sessione del partecipante, puoi elencare tutte le sessioni del partecipante utilizzando il metodo list().

Il metodo restituisce il nome di un partecipante come istanza di una risorsa participantSessions.

Il seguente esempio di codice mostra come recuperare una sessione del partecipante specifica:

Java

java-meet/samples/snippets/generated/com/google/apps/meet/v2/conferencerecordsservice/getparticipantsession/AsyncGetParticipantSession.java
import com.google.api.core.ApiFuture;
import com.google.apps.meet.v2.ConferenceRecordsServiceClient;
import com.google.apps.meet.v2.GetParticipantSessionRequest;
import com.google.apps.meet.v2.ParticipantSession;
import com.google.apps.meet.v2.ParticipantSessionName;

public class AsyncGetParticipantSession {

  public static void main(String[] args) throws Exception {
    asyncGetParticipantSession();
  }

  public static void asyncGetParticipantSession() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (ConferenceRecordsServiceClient conferenceRecordsServiceClient =
        ConferenceRecordsServiceClient.create()) {
      GetParticipantSessionRequest request =
          GetParticipantSessionRequest.newBuilder()
              .setName(
                  ParticipantSessionName.of(
                          "[CONFERENCE_RECORD]", "[PARTICIPANT]", "[PARTICIPANT_SESSION]")
                      .toString())
              .build();
      ApiFuture<ParticipantSession> future =
          conferenceRecordsServiceClient.getParticipantSessionCallable().futureCall(request);
      // Do something.
      ParticipantSession response = future.get();
    }
  }
}

Node.js

packages/google-apps-meet/samples/generated/v2/conference_records_service.get_participant_session.js
/**
 * This snippet has been automatically generated and should be regarded as a code template only.
 * It will require modifications to work.
 * It may require correct/in-range values for request initialization.
 * TODO(developer): Uncomment these variables before running the sample.
 */
/**
 *  Required. Resource name of the participant.
 */
// const name = 'abc123'

// Imports the Meet library
const {ConferenceRecordsServiceClient} = require('@google-apps/meet').v2;

// Instantiates a client
const meetClient = new ConferenceRecordsServiceClient();

async function callGetParticipantSession() {
  // Construct request
  const request = {
    name,
  };

  // Run request
  const response = await meetClient.getParticipantSession(request);
  console.log(response);
}

callGetParticipantSession();

Python

packages/google-apps-meet/samples/generated_samples/meet_v2_generated_conference_records_service_get_participant_session_async.py
# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.apps import meet_v2


async def sample_get_participant_session():
    # Create a client
    client = meet_v2.ConferenceRecordsServiceAsyncClient()

    # Initialize request argument(s)
    request = meet_v2.GetParticipantSessionRequest(
        name="name_value",
    )

    # Make the request
    response = await client.get_participant_session(request=request)

    # Handle the response
    print(response)

Sostituisci il nome del partecipante con il nome dell'ID sessione del partecipante specifico in una sessione del partecipante.

Elenco di tutte le sessioni dei partecipanti

Per elencare i dettagli di tutte le sessioni di un partecipante in un record della conferenza, utilizza il metodo list() nella risorsa participantSessions con il parametro di percorso parent. Formato: conferenceRecords/{conferenceRecord}/participants/{participant}.

Il metodo restituisce un elenco di sessioni dei partecipanti, ordinate per startTime in ordine decrescente, come istanza di una risorsa participantSession. Per regolare le dimensioni della pagina e filtrare i risultati della query, consulta Personalizzare la paginazione o filtrare l'elenco delle sessioni dei partecipanti.

Il seguente esempio di codice mostra come elencare tutte le sessioni dei partecipanti in un record della conferenza:

Java

java-meet/samples/snippets/generated/com/google/apps/meet/v2/conferencerecordsservice/listparticipantsessions/AsyncListParticipantSessions.java
import com.google.api.core.ApiFuture;
import com.google.apps.meet.v2.ConferenceRecordsServiceClient;
import com.google.apps.meet.v2.ListParticipantSessionsRequest;
import com.google.apps.meet.v2.ParticipantName;
import com.google.apps.meet.v2.ParticipantSession;

public class AsyncListParticipantSessions {

  public static void main(String[] args) throws Exception {
    asyncListParticipantSessions();
  }

  public static void asyncListParticipantSessions() throws Exception {
    // This snippet has been automatically generated and should be regarded as a code template only.
    // It will require modifications to work:
    // - It may require correct/in-range values for request initialization.
    // - It may require specifying regional endpoints when creating the service client as shown in
    // https://cloud.google.com/java/docs/setup#configure_endpoints_for_the_client_library
    try (ConferenceRecordsServiceClient conferenceRecordsServiceClient =
        ConferenceRecordsServiceClient.create()) {
      ListParticipantSessionsRequest request =
          ListParticipantSessionsRequest.newBuilder()
              .setParent(ParticipantName.of("[CONFERENCE_RECORD]", "[PARTICIPANT]").toString())
              .setPageSize(883849137)
              .setPageToken("pageToken873572522")
              .setFilter("filter-1274492040")
              .build();
      ApiFuture<ParticipantSession> future =
          conferenceRecordsServiceClient.listParticipantSessionsPagedCallable().futureCall(request);
      // Do something.
      for (ParticipantSession element : future.get().iterateAll()) {
        // doThingsWith(element);
      }
    }
  }
}

Node.js

packages/google-apps-meet/samples/generated/v2/conference_records_service.list_participant_sessions.js
// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// ** This file is automatically generated by gapic-generator-typescript. **
// ** https://github.com/googleapis/gapic-generator-typescript **
// ** All changes to this file may be overwritten. **



'use strict';

function main(parent) {
  /**
   * This snippet has been automatically generated and should be regarded as a code template only.
   * It will require modifications to work.
   * It may require correct/in-range values for request initialization.
   * TODO(developer): Uncomment these variables before running the sample.
   */
  /**
   *  Required. Format:
   *  `conferenceRecords/{conference_record}/participants/{participant}`
   */
  // const parent = 'abc123'
  /**
   *  Optional. Maximum number of participant sessions to return. The service
   *  might return fewer than this value. If unspecified, at most 100
   *  participants are returned. The maximum value is 250; values above 250 are
   *  coerced to 250. Maximum might change in the future.
   */
  // const pageSize = 1234
  /**
   *  Optional. Page token returned from previous List Call.
   */
  // const pageToken = 'abc123'
  /**
   *  Optional. User specified filtering condition in EBNF
   *  format (https://en.wikipedia.org/wiki/Extended_Backus%E2%80%93Naur_form).
   *  The following are the filterable fields:
   *  * `start_time`
   *  * `end_time`
   *  For example, `end_time IS NULL` returns active participant sessions in
   *  the conference record.
   */
  // const filter = 'abc123'

  // Imports the Meet library
  const {ConferenceRecordsServiceClient} = require('@google-apps/meet').v2;

  // Instantiates a client
  const meetClient = new ConferenceRecordsServiceClient();

  async function callListParticipantSessions() {
    // Construct request
    const request = {
      parent,
    };

    // Run request
    const iterable = meetClient.listParticipantSessionsAsync(request);
    for await (const response of iterable) {
        console.log(response);
    }
  }

  callListParticipantSessions();
}

process.on('unhandledRejection', err => {
  console.error(err.message);
  process.exitCode = 1;
});
main(...process.argv.slice(2));

Python

packages/google-apps-meet/samples/generated_samples/meet_v2_generated_conference_records_service_list_participant_sessions_async.py
# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.apps import meet_v2


async def sample_list_participant_sessions():
    # Create a client
    client = meet_v2.ConferenceRecordsServiceAsyncClient()

    # Initialize request argument(s)
    request = meet_v2.ListParticipantSessionsRequest(
        parent="parent_value",
    )

    # Make the request
    page_result = client.list_participant_sessions(request=request)

    # Handle the response
    async for response in page_result:
        print(response)

Sostituisci il valore principale con il nome delle sessioni dei partecipanti di un partecipante in un record della conferenza.

Personalizzare la paginazione o filtrare l'elenco delle sessioni dei partecipanti

Passa i seguenti parametri di query facoltativi per personalizzare la paginazione o filtrare le sessioni dei partecipanti:

  • pageSize: il numero massimo di sessioni dei partecipanti da restituire. Il servizio potrebbe restituire un numero inferiore a questo valore. Se non specificato, vengono restituite al massimo 100 sessioni dei partecipanti. Il valore massimo è 250; i valori superiori a 250 vengono modificati automaticamente in 250.

  • pageToken: un token di pagina ricevuto da una precedente chiamata dell'elenco. Fornisci questo token per recuperare la pagina successiva.

  • filter: facoltativo. Un filtro di query per recuperare elementi specifici nei risultati della risorsaparticipants.

    Puoi utilizzare i campi startTime o endTime per filtrare gli utenti che si sono uniti prima o che sono usciti dopo un determinato periodo di tempo. Entrambi i campi utilizzano il formato Timestamp in formato "Zulu" UTC RFC 3339, con risoluzione in nanosecondi e fino a nove cifre decimali: {year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z. Ad esempio:

    • startTime < 2023-10-01T15:01:23Z
    • endTime < 2023-10-01T15:01:23Z

    Per elencare tutte le sessioni dei partecipanti attivi nel record della conferenza, utilizza endTime IS NULL.