Trabaja con los participantes

En esta guía, se explica cómo obtener detalles sobre los participantes que asistieron a una conferencia anterior o que están en una conferencia activa, junto con la información de su sesión, con la API de REST de Google Meet.

Un participante es una persona que se unió a una llamada o que usa el Modo complementario, mira como un usuario o usa un dispositivo de sala conectado a una llamada. Hay un recurso participants para cada persona.

Una sesión de participante es un ID de sesión único que se crea para cada par de participante y dispositivo que se une a una llamada. Hay un recurso participantSessions para cada sesión. Si el participante se une a la misma llamada varias veces desde el mismo par participante-dispositivo, se le asignan IDs de sesión únicos.

Si eres propietario o participante de un espacio de reunión, puedes llamar a los métodos get() y list() en los recursos participants y participantSessions para recuperar los registros de los participantes.

La autenticación y autorización con credenciales del usuario permite que las apps de Google Meet accedan a los datos del usuario y realicen operaciones en su nombre. La autenticación con la delegación de autoridad en todo el dominio te permite autorizar a la cuenta de servicio de una aplicación para que acceda a los datos de tus usuarios sin que cada uno de ellos deba dar su consentimiento.

Participantes

En las siguientes secciones, se detalla cómo obtener información sobre los participantes en un registro de conferencia.

Las uniones de recursos participants se unen con el campo user. Un user solo puede ser uno de los siguientes objetos:

  • Un signedinUser puede ser una de las siguientes opciones:

    • Una persona que se une desde una computadora personal, un dispositivo móvil o con el modo complementario

    • Es una cuenta de robot que usan los dispositivos de sala de conferencias.

  • Un anonymousUser es un usuario no identificado que no accedió a una Cuenta de Google.

  • Un phoneUser es un usuario que llama desde un teléfono en el que se desconoce su identidad porque no accedió con una Cuenta de Google.

Ten en cuenta que, si bien los tres objetos muestran un displayName, signedinUser también muestra un ID user único que es interoperable con la API de Admin SDK y la API de People. Formato: users/{user}. Para obtener más información sobre el uso del ID user con la API de People, consulta Cómo recuperar detalles de los participantes con la API de People.

Cómo obtener detalles sobre un participante

Para obtener detalles sobre un participante específico, usa el método get() en el recurso participants con el parámetro de ruta name. Si no conoces el nombre del participante, puedes enumerar todos los nombres de los participantes con el método list().

El método muestra los datos de un participante como una instancia de un recurso participants.

En la siguiente muestra de código, se muestra cómo recuperar un participante específico:

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)

Reemplaza el nombre del participante por el nombre del ID de participante específico en un registro de conferencia.

Cómo ver una lista de todos los participantes

Para enumerar los detalles de todos los participantes en un registro de conferencia, usa el método list() en el recurso participants con el parámetro de ruta parent. Formato: conferenceRecords/{conferenceRecord}.

El método muestra una lista de participantes de la conferencia, ordenados por earliestStartTime en orden descendente, como una instancia de un recurso participants. Para ajustar el tamaño de la página y filtrar los resultados de la consulta, consulta Cómo personalizar la paginación o filtrar la lista de participantes.

En la siguiente muestra de código, se muestra cómo enumerar a todos los participantes de un registro de conferencia:

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)

Reemplaza el valor superior por el nombre del registro de la conferencia.

Personaliza la paginación o filtra la lista de participantes

Pasa los siguientes parámetros de consulta para personalizar la paginación de los participantes o filtrar:

  • pageSize: Es la cantidad máxima de participantes que se mostrarán. Es posible que el servicio muestre menos que este valor. Si no se especifica, se muestran como máximo 100 participantes. El valor máximo es 250. Los valores superiores a 250 se cambian automáticamente a 250.

  • pageToken: Es un token de página, recibido desde una llamada a lista anterior. Proporciona este token para recuperar la página siguiente.

  • filter: Opcional Es un filtro de consulta para recuperar elementos específicos en los resultados del recurso participants.

    Puedes usar los campos earliestStartTime o latestEndTime para filtrar usuarios que se unieron antes o salieron después de un período determinado. Ambos campos usan el formato Timestamp en formato RFC 3339 UTC “Zulu”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios: {year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z. Por ejemplo:

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

    Para enumerar todos los participantes activos de una conferencia existente, usa latestEndTime IS NULL.

Cómo recuperar detalles de los participantes con la API de People

Para recuperar detalles sobre un participante, usa el método get() en el recurso people de la API de People.

  1. Extrae el ID de la persona del recurso participant con el componente final de la ruta de acceso. Por ejemplo, si el valor del recurso participant es conferenceRecords/abc-123/participants/12345, el ID de la API de People es 12345.

  2. Incluye READ_SOURCE_TYPE_PROFILE, READ_SOURCE_TYPE_CONTACT y READ_SOURCE_TYPE_OTHER_CONTACT ReadSourceType. Esto garantiza que se incluyan en la respuesta los usuarios internos de una organización de Google Workspace y los contactos externos.

En la siguiente muestra de código, se muestra cómo buscar perfiles de organización y contactos de 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

Reemplaza lo siguiente:

  • PERSON_ID: El ID de la persona que se busca.
  • ACCESS_TOKEN: Es el token de acceso que otorga acceso a varias APIs.

Sesiones de los participantes

En las siguientes secciones, se detalla cómo obtener información sobre las sesiones de un participante en un registro de conferencia.

Obtén detalles sobre una sesión de participante

Para obtener detalles sobre una sesión de participante específica, usa el método get() en el recurso participantSessions con el parámetro de ruta name. Si no conoces el nombre de la sesión del participante, puedes enumerar todas las sesiones de un participante con el método list().

El método muestra un nombre de participante como una instancia de un recurso participantSessions.

En la siguiente muestra de código, se muestra cómo recuperar una sesión de participante específica:

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)

Reemplaza el nombre del participante por el nombre del ID de sesión del participante específico en una sesión de participante.

Muestra todas las sesiones de los participantes

Para enumerar los detalles de todas las sesiones de un participante en un registro de conferencia, usa el método list() en el recurso participantSessions con el parámetro de ruta parent. Formato: conferenceRecords/{conferenceRecord}/participants/{participant}.

El método muestra una lista de sesiones de participantes, ordenadas por startTime en orden descendente, como una instancia de un recurso participantSession. Para ajustar el tamaño de la página y filtrar los resultados de la consulta, consulta Cómo personalizar la paginación o filtrar la lista de sesiones de los participantes.

En la siguiente muestra de código, se muestra cómo enumerar todas las sesiones de los participantes en un registro de conferencia:

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)

Reemplaza el valor superior por el nombre de las sesiones de un participante en un registro de conferencia.

Personaliza la paginación o filtra la lista de sesiones de los participantes

Pasa los siguientes parámetros de consulta opcionales para personalizar la paginación de las sesiones de los participantes o filtrarlas:

  • pageSize: Es la cantidad máxima de sesiones de participantes que se mostrarán. El servicio puede mostrar menos que este valor. Si no se especifica, se devuelven, como máximo, 100 sesiones de participante. El valor máximo es 250; los valores superiores a 250 se cambian automáticamente a 250.

  • pageToken: Es un token de página, recibido desde una llamada a lista anterior. Proporciona este token para recuperar la página siguiente.

  • filter: Opcional Es un filtro de consulta para recuperar elementos específicos en los resultados del recurso participants.

    Puedes usar los campos startTime o endTime para filtrar los usuarios que se unieron antes o salieron después de un período determinado. Ambos campos usan el formato Timestamp en formato RFC 3339 UTC “Zulu”, con una resolución de nanosegundos y hasta nueve dígitos fraccionarios: {year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z. Por ejemplo:

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

    Para enumerar todas las sesiones de participantes activas en el registro de la conferencia, usa endTime IS NULL.