Notice: We're retiring Works with Nest. See the home page for more information.
En Google, luchamos por la equidad racial de la comunidad negra. Más información
Se usó la API de Cloud Translation para traducir esta página.
Switch to English

Ejemplos de lectura de API

Lejos

Utilice la API de Nest para escuchar los cambios en estructuras y dispositivos, de modo que pueda tomar medidas para ahorrar energía cuando los propietarios no estén, notificarles que algo anda mal (por ejemplo, la puerta del garaje está abierta) o activar funciones para hacer que el hogar más cómodo y acogedor.

Esta guía muestra cómo leer datos de estructuras y dispositivos Nest. Para aprender a realizar llamadas de escritura, consulte Ejemplos de escritura de API .

Prerrequisitos

Antes de realizar llamadas a la API, obtenga un token de acceso, como se describe en Autenticación con OAuth 2.0 .

Acerca de las llamadas de lectura REST

Para llamadas REST, use GET para leer datos.

Las llamadas de lectura REST son útiles en escenarios limitados, como los siguientes casos de uso:

  • Llamadas puntuales ad-hoc
  • Laboratorios de prueba de concepto
  • Solución de problemas
  • Aplicaciones que sondean aproximadamente cada minuto
  • Implementaciones de botones de actualización

Las llamadas de lectura REST no son útiles para escenarios continuos en tiempo real o de transmisión.

Autenticación de portador

Recomendamos el cumplimiento del estándar OAuth , que ofrece una mayor seguridad mediante el uso de la autenticación "Bearer" para transmitir el token de acceso. No se recomiendan las llamadas con credenciales de cliente en la URL.

El "Content-Type" indica al servidor que utilice JSON.

El encabezado "Authorization" proporciona acceso a la API.

Ejemplos

En los siguientes ejemplos, reemplace YOUR_TOKEN_HERE con su token de acceso específico, como "c.twC2q ...".

Leer estructuras y dispositivos

Para leer toda la estructura y los datos del dispositivo (nivel base), use la URL de nivel raíz. Para obtener respuestas más detalladas, modifique la URL según sea necesario.

Rizo
curl -v --location-trusted \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_TOKEN_HERE" \
  -X GET "https://developer-api.nest.com/"
Multiplex de curl
curl -v --location-trusted \
  -H "Accept: text/event-stream" \
  -H "Authorization: Bearer LIST_OF_ACCESS_TOKENS" \
  -X GET "https://developer-api.nest.com/multiplex"
Vamos
package main

import (
    "errors"
    "fmt"
    "io/ioutil"
    "net/http"
)

const token = "YOUR_TOKEN_HERE" // Update with your token

func main() {
    url := "https://developer-api.nest.com/"
    req, _ := http.NewRequest(http.MethodGet, url, nil)

    req.Header.Add(
        "Authorization",
        fmt.Sprintf("Bearer %s", token),
    )

    customClient := http.Client {
        CheckRedirect: func(redirRequest *http.Request, via []*http.Request) error {
            // Go's http.DefaultClient does not forward headers when a redirect 3xx
            // response is received. Thus, the header (which in this case contains the
            // Authorization token) needs to be passed forward to the redirect
            // destinations.
            redirRequest.Header = req.Header

            // Go's http.DefaultClient allows 10 redirects before returning an
            // an error. We have mimicked this default behavior.
            if len(via) >= 10 {
                return errors.New("stopped after 10 redirects")
            }
            return nil
        },
    }

    response, _ := customClient.Do(req)

    if response.StatusCode != 200 {
        panic(fmt.Sprintf(
            "Expected a 200 status code; got a %d",
            response.StatusCode,
        ))
    }

    defer response.Body.Close()
    body, _ := ioutil.ReadAll(response.Body)
    fmt.Println(string(body))

}
Node.js
"use strict"

var request = require('request');

var token = "YOUR_TOKEN_HERE"; // Update with your token

var url = "https://developer-api.nest.com";

var options = {
    "method": "GET",
    "path": "/",
    "headers": {
       "Authorization": "Bearer " + token
    },
    "followRedirect": true
};

var req = request(url, options, function(err, resp, data) {
    console.log('response code: ' + resp.statusCode);
    if (err) {
        console.log('Error: ' + err.message);
    }
    console.log("data: " + data);
});

req.end();

Para usar el ejemplo de código de Node.js, instale el módulo de solicitud ( https://www.npmjs.com/package/request ).

npm install request
Python 2
import hashlib
import json
import os
import requests

url = "https://developer-api.nest.com/"

token = "YOUR_TOKEN_HERE" # Update with your token

headers = {'Authorization': 'Bearer {0}'.format(token), 'Content-Type': 'application/json'}

response = requests.get(url, headers=headers, allow_redirects=False)
if response.status_code == 307:
    response = requests.get(response.headers['Location'], headers=headers, allow_redirects=False)

print(response.text)
Python 3
import http.client
from urllib.parse import urlparse

token = "YOUR_TOKEN_HERE" # Update with your token

conn = http.client.HTTPSConnection("developer-api.nest.com")
headers = {'authorization': "Bearer {0}".format(token)}
conn.request("GET", "/", headers=headers)
response = conn.getresponse()

if response.status == 307:
    redirectLocation = urlparse(response.getheader("location"))
    conn = http.client.HTTPSConnection(redirectLocation.netloc)
    conn.request("GET", "/", headers=headers)
    response = conn.getresponse()
    if response.status != 200:
        raise Exception("Redirect with non 200 response")

data = response.read()
print(data.decode("utf-8"))
Java
import java.io.IOException;
import okhttp3.Headers;
import okhttp3.OkHttpClient;
import okhttp3.OkHttpClient.Builder;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.Authenticator;
import okhttp3.Route;

public class ReadNest {

    public static void main(String[] args) throws IOException {
        String auth = "Bearer YOUR_TOKEN_HERE"; // Update with your token

        OkHttpClient client = new OkHttpClient.Builder()
        .authenticator(new Authenticator() {
          @Override public Request authenticate(Route route, Response response) throws IOException {
            return response.request().newBuilder()
                .header("Authorization", auth)
                .build();
          }
        })
        .followRedirects(true)
        .followSslRedirects(true)
        .build();

        Request request = new Request.Builder()
        .url("https://developer-api.nest.com")
        .get()
        .addHeader("content-type", "application/json; charset=UTF-8")
        .addHeader("authorization", auth)
        .build();

        try {
            System.out.println("Begin request:  ");
            Response response = client.newCall(request).execute();
            System.out.println(response.body().string());
            System.out.println("End request");
            System.out.println();
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
                e.printStackTrace();
        }
   }
}

Para usar el ejemplo de código Java:

1. Descargue los últimos archivos Okhttp y Okio Jar en http://square.github.io/okhttp/ . Además, descargue el archivo stdlib de Kotlin en https://mvnrepository.com/artifact/org.jetbrains.kotlin/kotlin-stdlib si su versión de okhttp depende de él.

2. Construya su código.

3. Compile y ejecute el programa con la siguiente configuración de ruta de clases.

Sustituya los números de versión de su biblioteca en los comandos javac y java a continuación:
javac -cp .:okhttp-<ver>.jar:okio-<ver>.jar ReadNest.java
java -cp .:okhttp-<ver>.jar:okio-<ver>.jar:kotlin-stdlib-<ver>.jar ReadNest

Por ejemplo, si tiene las siguientes versiones 3.11.0, 2.1.0 y 1.3.0, sus comandos se verían así:
javac -cp .:okhttp-3.11.0.jar:okio-2.1.0.jar ReadNest.java
java -cp .:okhttp-3.11.0.jar:okio-2.1.0.jar:kotlin-stdlib-1.3.0.jar ReadNest

Usando Postman para probar la API

La llamada de Curl anterior se puede replicar fácilmente en Postman.

PONER encabezado para escribir

Utilice el enlace Código en Postman para traducir una llamada a diferentes idiomas como punto de partida para un mayor desarrollo.