Obtenga información de usuario a través de la API de Google

¿Es posible obtener información del perfil del usuario a través de la API de Google? Si es posible, ¿qué API debo usar?

Me interesa esa información:

• URL del perfil de usuario (por ejemplo, https://profiles.google.com/115063121183536852887 );
• Género (sexo);
• Foto de perfil.

También sería genial obtener otra información del perfil del usuario.

Agregue esto al alcance: https://www.googleapis.com/auth/userinfo.profile

Y una vez realizada la autorización, obtenga la información de: https://www.googleapis.com/oauth2/v1/userinfo?alt=json

Tiene un montón de cosas, incluido el nombre, la URL del perfil público, el género, la foto, etc.

alcance: https://www.googleapis.com/auth/userinfo.profile

return youraccess_token = access_token

obtener https://www.googleapis.com/oauth2/v1/userinfo?alt=json&access_token=youraccess_token

obtendrás json:

{
 "id": "xx",
 "name": "xx",
 "given_name": "xx",
 "family_name": "xx",
 "link": "xx",
 "picture": "xx",
 "gender": "xx",
 "locale": "xx"
}

Para Tahir Yasin:

Este es un ejemplo de php.
Puede usar la función json_decode para obtener la matriz userInfo.

$q = 'https://www.googleapis.com/oauth2/v1/userinfo?access_token=xxx';
$json = file_get_contents($q);
$userInfoArray = json_decode($json,true);
$googleEmail = $userInfoArray['email'];
$googleFirstName = $userInfoArray['given_name'];
$googleLastName = $userInfoArray['family_name'];

Este alcance https://www.googleapis.com/auth/userinfo.profile ha quedado obsoleto ahora. Consulte https://developers.google.com/+/api/auth-migration#timetable .

El nuevo alcance que utilizará para obtener información de perfil es: profile o https://www.googleapis.com/auth/plus.login

y el punto final es - https://www.googleapis.com/plus/v1/people/ {userId} - userId puede ser solo "yo" para el usuario que ha iniciado sesión actualmente.

Estoy usando PHPy resolví esto usando la versión 1.1.4 de google-api-php-client

Suponiendo que se utiliza el siguiente código para redirigir a un usuario a la página de autenticación de Google:

 $client = new Google_Client();
 $client->setAuthConfigFile('/path/to/config/file/here');
 $client->setRedirectUri('https://redirect/url/here');
 $client->setAccessType('offline'); //optional
 $client->setScopes(['profile']); //or email
 $auth_url = $client->createAuthUrl();
 header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
 exit();

Suponiendo que se devuelva un código de autenticación válido redirect_url, lo siguiente generará un token a partir del código de autenticación y proporcionará información básica del perfil:

 //assuming a successful authentication code is return
 $authentication_code = 'code-returned-by-google';
 $client = new Google_Client();
 //.... configure $client object code goes here
 $client->authenticate($authentication_code);
 $token_data = $client->getAccessToken();

 //get user email address
 $google_oauth =new Google_Service_Oauth2($client);
 $google_account_email = $google_oauth->userinfo->get()->email;
 //$google_oauth->userinfo->get()->familyName;
 //$google_oauth->userinfo->get()->givenName;
 //$google_oauth->userinfo->get()->name;
 //$google_oauth->userinfo->get()->gender;
 //$google_oauth->userinfo->get()->picture; //profile picture

Sin embargo, no se devuelve la ubicación. Las nuevas cuentas de YouTube no tienen nombres de usuario específicos de YouTube

Estoy usando la API de Google para .Net, pero sin duda puede encontrar la misma forma de obtener esta información usando otra versión de API. Como mencionó user872858 , el alcance userinfo.profile ha quedado obsoleto ( artículo de Google ).

Para obtener información de perfil de usuario, uso el siguiente código (parte reescrita del ejemplo de Google ):

IAuthorizationCodeFlow flow = new GoogleAuthorizationCodeFlow(
                                  new GoogleAuthorizationCodeFlow.Initializer
                                      {
                                            ClientSecrets = Secrets,
                                            Scopes = new[] { PlusService.Scope.PlusLogin,"https://www.googleapis.com/auth/plus.profile.emails.read"  }
                                       });    
TokenResponse _token = flow.ExchangeCodeForTokenAsync("", code, "postmessage", 
                              CancellationToken.None).Result;

                    // Create an authorization state from the returned token.
                    context.Session["authState"] = _token;

                    // Get tokeninfo for the access token if you want to verify.
                    Oauth2Service service = new Oauth2Service(
                     new Google.Apis.Services.BaseClientService.Initializer());
                    Oauth2Service.TokeninfoRequest request = service.Tokeninfo();
                    request.AccessToken = _token.AccessToken;
                    Tokeninfo info = request.Execute();
                    if (info.VerifiedEmail.HasValue && info.VerifiedEmail.Value)
                    {
                        flow = new GoogleAuthorizationCodeFlow(
                                    new GoogleAuthorizationCodeFlow.Initializer
                                         {
                                             ClientSecrets = Secrets,
                                             Scopes = new[] { PlusService.Scope.PlusLogin }
                                          });

                        UserCredential credential = new UserCredential(flow, 
                                                              "me", _token);
                        _token = credential.Token;
                        _ps = new PlusService(
                              new Google.Apis.Services.BaseClientService.Initializer()
                               {
                                   ApplicationName = "Your app name",
                                   HttpClientInitializer = credential
                               });
                        Person userProfile = _ps.People.Get("me").Execute();
                    }

Entonces, puede acceder a casi cualquier cosa usando userProfile.

ACTUALIZACIÓN: Para que este código funcione, debe usar los alcances adecuados en el botón de inicio de sesión de Google. Por ejemplo mi botón:

     <button class="g-signin"
             data-scope="https://www.googleapis.com/auth/plus.login https://www.googleapis.com/auth/plus.profile.emails.read"
             data-clientid="646361778467-nb2uipj05c4adlk0vo66k96bv8inqles.apps.googleusercontent.com"
             data-accesstype="offline"
             data-redirecturi="postmessage"
             data-theme="dark"
             data-callback="onSignInCallback"
             data-cookiepolicy="single_host_origin"
             data-width="iconOnly">
     </button>

Hay 3 pasos que deben ejecutarse.

1. Registre el ID de cliente de su aplicación desde la consola API de Google
2. Pídale a su usuario final que dé su consentimiento mediante esta API https://developers.google.com/identity/protocols/OpenIDConnect#sendauthrequest
3. Use la API de oauth2 de Google como se describe en https://any-api.com/googleapis_com/oauth2/docs/userinfo/oauth2_userinfo_v2_me_get usando el token obtenido en el paso 2. (Aunque todavía no pude encontrar cómo completar el parámetro "fields" correctamente) .

Es muy interesante que este uso más simple no se describa claramente en ninguna parte. Y creo que existe un peligro, debe prestar atención al verified_emailparámetro que viene en la respuesta. Porque si no me equivoco , pueden producirse correos electrónicos falsos para registrar su aplicación. (Esta es solo mi interpretación, ¡hay muchas posibilidades de que me equivoque!)

Creo que la mecánica de OAuth de Facebook se describe con mucha claridad.

Si se encuentra en un entorno web del lado del cliente, la nueva API javascript auth2 contiene una función muy necesaria getBasicProfile(), que devuelve el nombre del usuario, el correo electrónico y la URL de la imagen.

https://developers.google.com/identity/sign-in/web/reference#googleusergetbasicprofile

Si solo desea obtener la identificación de usuario, el nombre y la imagen de Google para un visitante de su aplicación web, aquí está mi solución de servicio PHP pura para el año 2020 sin bibliotecas externas utilizadas -

Si lee la guía Uso de OAuth 2.0 para aplicaciones de servidor web de Google (y tenga cuidado, a Google le gusta cambiar los enlaces a su propia documentación), entonces solo debe realizar 2 pasos:

1. Presentar al visitante una página web solicitando el consentimiento para compartir su nombre con su aplicación web.
2. Luego, tome el "código" pasado por la página web anterior a su aplicación web y obtenga un token (en realidad 2) de Google.

Uno de los tokens devueltos se llama "id_token" y contiene la identificación del usuario, el nombre y la foto del visitante.

Aquí está el código PHP de un juego web mío. Inicialmente estaba usando Javascript SDK, pero luego me di cuenta de que los datos de usuario falsos se podían pasar a mi juego web, cuando solo usaba el SDK del lado del cliente (especialmente la identificación de usuario, que es importante para mi juego), así que cambié a usar PHP en el lado del servidor:

<?php

const APP_ID       = '1234567890-abcdefghijklmnop.apps.googleusercontent.com';
const APP_SECRET   = 'abcdefghijklmnopq';

const REDIRECT_URI = 'https://the/url/of/this/PHP/script/';
const LOCATION     = 'Location: https://accounts.google.com/o/oauth2/v2/auth?';
const TOKEN_URL    = 'https://oauth2.googleapis.com/token';
const ERROR        = 'error';
const CODE         = 'code';
const STATE        = 'state';
const ID_TOKEN     = 'id_token';

# use a "random" string based on the current date as protection against CSRF
$CSRF_PROTECTION   = md5(date('m.d.y'));

if (isset($_REQUEST[ERROR]) && $_REQUEST[ERROR]) {
    exit($_REQUEST[ERROR]);
}

if (isset($_REQUEST[CODE]) && $_REQUEST[CODE] && $CSRF_PROTECTION == $_REQUEST[STATE]) {
    $tokenRequest = [
        'code'          => $_REQUEST[CODE],
        'client_id'     => APP_ID,
        'client_secret' => APP_SECRET,
        'redirect_uri'  => REDIRECT_URI,
        'grant_type'    => 'authorization_code',
    ];

    $postContext = stream_context_create([
        'http' => [
            'header'  => "Content-type: application/x-www-form-urlencoded\r\n",
            'method'  => 'POST',
            'content' => http_build_query($tokenRequest)
        ]
    ]);

    # Step #2: send POST request to token URL and decode the returned JWT id_token
    $tokenResult = json_decode(file_get_contents(TOKEN_URL, false, $postContext), true);
    error_log(print_r($tokenResult, true));
    $id_token    = $tokenResult[ID_TOKEN];
    # Beware - the following code does not verify the JWT signature! 
    $userResult  = json_decode(base64_decode(str_replace('_', '/', str_replace('-', '+', explode('.', $id_token)[1]))), true);

    $user_id     = $userResult['sub'];
    $given_name  = $userResult['given_name'];
    $family_name = $userResult['family_name'];
    $photo       = $userResult['picture'];

    if ($user_id != NULL && $given_name != NULL) {
        # print your web app or game here, based on $user_id etc.
        exit();
    }
}

$userConsent = [
    'client_id'     => APP_ID,
    'redirect_uri'  => REDIRECT_URI,
    'response_type' => 'code',
    'scope'         => 'profile',
    'state'         => $CSRF_PROTECTION,
];

# Step #1: redirect user to a the Google page asking for user consent
header(LOCATION . http_build_query($userConsent));

?>

Puede usar una biblioteca PHP para agregar seguridad adicional verificando la firma JWT. Para mis propósitos fue innecesario, porque confío en que Google no traicionará mi pequeño juego web enviando datos de visitantes falsos.

Además, si desea obtener más datos personales del visitante, necesita un tercer paso:

const USER_INFO    = 'https://www.googleapis.com/oauth2/v3/userinfo?access_token=';
const ACCESS_TOKEN = 'access_token'; 

# Step #3: send GET request to user info URL
$access_token = $tokenResult[ACCESS_TOKEN];
$userResult = json_decode(file_get_contents(USER_INFO . $access_token), true);

O puede obtener más permisos en nombre del usuario: consulte la lista larga en el documento OAuth 2.0 Scopes for Google API .

Finalmente, las constantes APP_ID y APP_SECRET utilizadas en mi código, las obtienes de la consola API de Google :