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

103

¿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:

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

glagola
fuente

Respuestas:

122

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.

Abhinav Manchanda
fuente
1
Usé las URL anteriores pero no pude obtener el perfil del usuario. Obteniendo '{' solamente. Por favor, puede publicar algún código o enlaces. Gracias por adelantado.
Panache
9
La URL que proporcionó funciona perfectamente, es decir, googleapis.com/oauth2/v1/userinfo . Pero, ¿puedes saber de dónde obtuviste esta URL? Intenté buscarlo pero no lo encontré en ninguna parte. ¿Google documenta estas URL en algún lugar?
Akshar Raaj
1
¿Dónde puedo ver la especificación de los datos devueltos para un alcance específico?
Matko
3
El alcance "userinfo.profile" parece estar en desuso, en su lugar debería utilizar "perfil" y "correo electrónico". developers.google.com/+/web/api/rest/oauth#authorization-scopes
Martin B.
3
Puede simplemente consultar esta URL, utilizando el token de acceso que obtiene después de que el usuario le haya autorizado a acceder a este alcance. Ejemplo:curl -X GET "https://www.googleapis.com/oauth2/v1/userinfo?alt=json" -H"Authorization: Bearer accessTokenHere"
Pratik Singhal
90

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'];
eason
fuente
1
¿Cómo puedo usar su respuesta?
Tahir Yasin
¿Cómo puedo obtener la dirección de correo electrónico junto con el resto de la información que ha mencionado?
Dilantha
Por favor, actualice el código para tener el formato correcto para acceder a las $userInfoArraypropiedades. Debería ser como $userInfoArray['email']obtener la dirección de correo electrónico del $userInfoArray. TENGA EN CUENTA LA COTIZACIÓN ÚNICA PARA ACCEDER A LAS OPCIONES.
Shantha Kumara
@Shantha Kumara, podrías haberlo editado tú mismo, pero no te preocupes, ya que lo he hecho ahora. Por lo que sabemos, podrían haber omitido el código define(email, 'email');)
verbumSapienti
quiero obtener el número de teléfono y la edad / cumpleaños
Prasad
29

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.

usuario872858
fuente
Esta es una importante tranquilidad para tener la integración a prueba de futuro. más información sobre alcances obsoletos developers.google.com/+/web/api/rest/oauth
Pandurang Patil
y sin embargo ... If you are directly requesting the “plus.me” scope, any other Google+ OAuth scopes, or making any Google+ API calls, please ensure that you remove these requests from your project before March 7, 2019.- Google
plumSemPy
25

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

singh1469
fuente
¿Cómo obtener la ubicación?
SoftSan
No puedo obtener información de género (he mantenido pública la información de género) usando este alcance. He probado oauth playground developers.google.com/oauthplayground para esto. Quiero hacer esto usando REST API en el lado del servidor. ¿Me puedes ayudar con esto?
Vishant dhandha
Tampoco puedo obtener el género. Y en alguna cuenta, no se devuelve nada excepto el correo electrónico. Ideas?
Reinado 85
5

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>
LaoR
fuente
2

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.

Mehmet Kaplan
fuente
1

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

alalonde
fuente
Pero, ¿cuál es la URL de la API real? Miré la documentación, no puedo encontrar la URL de la API real. Google parece estar empujándonos a su SDK, pero no todos quieren usar el SDK.
Supertecnoboff
0

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 :

captura de pantalla

Alexander Farber
fuente