Skip to main content

Recursos na API REST

Aprenda a navegar pelos recursos fornecidos pela API de GitHub Enterprise Server.

Esquema

A API é acessada de http(s)://HOSTNAME/api/v3. Todos os dados são enviados e recebidos como JSON.

$ curl -I http(s)://HOSTNAME/api/v3/users/octocat/orgs

> HTTP/2 200
> Server: nginx
> Date: Fri, 12 Oct 2012 23:33:14 GMT
> Content-Type: application/json; charset=utf-8
> ETag: "a00049ba79152d03380c34652f2cb612"
> X-GitHub-Media-Type: github.v3
> x-ratelimit-limit: 5000
> x-ratelimit-remaining: 4987
> x-ratelimit-reset: 1350085394
> X-GitHub-Enterprise-Version: 3.6.0
> Content-Length: 5
> Cache-Control: max-age=0, private, must-revalidate
> X-Content-Type-Options: nosniff

Os campos em branco são incluídos como null em vez de serem omitidos.

Todos os timestamps são retornados no formato UTC, ISO 8601:

YYYY-MM-DDTHH:MM:SSZ

Para obter mais informações sobre fusos horários em carimbos de data/hora, confira esta seção.

Apresentações resumidas

Ao buscar uma lista de recursos, a resposta inclui um subconjunto dos atributos para esse recurso. Esta é a representação "resumo" do recurso. (Alguns atributos são computacionalmente caros para a API fornecer. Por razões de desempenho, a representação resumida exclui esses atributos. Para obter esses atributos, busque a representação "detalhada".)

Exemplo: ao receber uma lista de repositórios, você recebe a representação resumida de cada repositório. Aqui, buscamos a lista de repositórios pertencentes à organização octokit:

GET /orgs/octokit/repos

Representações detalhadas

Ao buscar um recurso individual, a resposta normalmente inclui todos os atributos para esse recurso. Esta é a representação "detalhada" do recurso. (Observe que a autorização às vezes influencia a quantidade de detalhes incluídos na representação.)

Exemplo: ao receber um repositório individual, você recebe a representação detalhada do repositório. Aqui, buscamos o repositório octokit/octokit.rb:

GET /repos/octokit/octokit.rb

A documentação fornece um exemplo de resposta para cada método da API. A resposta de exemplo ilustra todos os atributos que retornados por esse método.

Autenticação

Existem duas maneiras de efetuar a autenticação por meio da API REST de GitHub Enterprise Server. As solicitações que exigem autenticação retornarão 404 Not Found, em vez de 403 Forbidden, em alguns lugares. Isso é para evitar a fuga acidental de repositórios privados para usuários não autorizados.

Autenticação Básica

$ curl -u "username" http(s)://HOSTNAME/api/v3

Token do OAuth2 (enviado em um cabeçalho)

$ curl -H "Authorization: Bearer OAUTH-TOKEN" http(s)://HOSTNAME/api/v3

Observação: O GitHub recomenda enviar tokens do OAuth usando o cabeçalho de autorização.

Observação: Na maioria dos casos, você pode usar Authorization: Bearer ou Authorization: token a fim de passar um token. No entanto, se estiver passando um JWT (token Web JSON), você deverá usar Authorization: Bearer.

Leia mais sobre OAuth2. Observe que os tokens OAuth2 podem ser adquiridos usando o fluxo do aplicativo Web para aplicativos de produção.

OAuth2 key/secret

Aviso de reprovação: o GitHub descontinuará a autenticação na API com parâmetros de consulta. A autenticação na API deve ser feita com a autenticação básica HTTP. Para obter mais informações, incluindo brownouts agendados, confira a postagem no blog.

A autenticação na API com parâmetros de consulta, enquanto estavam disponíveis, deixou de ter suporte devido a preocupações sobre a segurança. Em vez disso, recomendamos que os integradores movam o token de acesso, a client_id ou o client_secret no cabeçalho. GitHub anunciará a remoção da autenticação por parâmetros de consulta com aviso prévio.

curl -u my_client_id:my_client_secret 'http(s)://HOSTNAME/api/v3/user/repos'

Usar seu client_id e client_secret não autentica como usuário, apenas identificará seu aplicativo OAuth para aumentar seu limite de taxa. As permissões só são concedidas a usuários, não aplicativos, e você só obterá dados que um usuário não autenticado visualizaria. Por este motivo, você só deve usar a chave/segredo OAuth2 em cenários de servidor para servidor. Não deixe vazar o segredo do cliente do OAuth do seu aplicativo para os seus usuários.

Você não conseguirá efetuar a autenticação usando sua chave e segredo do OAuth2 enquanto estiver no modo privado e essa tentativa de autenticação irá retornar 401 Unauthorized. Para obter mais informações, confira "Como habilitar o modo privado".

Falha no limite de login

A autenticação com credenciais inválidas retornará 401 Unauthorized:

$ curl -I http(s)://HOSTNAME/api/v3 -u foo:bar
> HTTP/2 401

> {
>   "message": "Bad credentials",
>   "documentation_url": "https://docs.github.com/enterprise/3.6/rest"
> }

Após detectar várias solicitações com credenciais inválidas em um curto período de tempo, a API rejeitará temporariamente todas as tentativas de autenticação para esse usuário (incluindo aquelas com credenciais válidas) com 403 Forbidden:

$ curl -i http(s)://HOSTNAME/api/v3 -u -u VALID_USERNAME:VALID_PASSWORD 
> HTTP/2 403
> {
>   "message": "Maximum number of login attempts exceeded. Please try again later.",
>   "documentation_url": "https://docs.github.com/enterprise/3.6/rest"
> }

Parâmetros

Muitos métodos de API tomam parâmetros opcionais. Para solicitações tipo GET, todos os parâmetros não especificados como um segmento no caminho podem ser passados como um parâmetro de string de consulta de HTTP:

$ curl -i "http(s)://HOSTNAME/api/v3/repos/vmg/redcarpet/issues?state=closed"

Neste exemplo, os valores 'vmg' e 'redcarpet' são fornecidos para os parâmetros :owner e :repo no caminho, enquanto :state é passado na cadeia de caracteres de consulta.

Para as solicitações POST, PATCH, PUT e DELETE, os parâmetros não incluídos na URL devem ser codificados como JSON com um tipo de conteúdo de 'application/json':

$ curl -i -u username -d '{"scopes":["repo_deployment"]}' http(s)://HOSTNAME/api/v3/authorizations

Ponto de extremidade raiz

Você pode emitir uma solicitação GET para o ponto de extremidade de raiz para obter todas as categorias do ponto de extremidade com a qual a API REST é compatível:

$ curl -u USERNAME:PASSWORD http(s)://HOSTNAME/api/v3

IDs de nós globais do GraphQL

Confira o guia sobre "Usar IDs de nós globais" para obter informações detalhadas sobre como localizar node_ids por meio da API REST e usá-los em operações do GraphQL.

Erros do cliente

Há três tipos possíveis de erros de cliente em chamadas de API que recebem corpos de solicitação:

  1. O envio de JSON inválido resultará em uma resposta 400 Bad Request.

    HTTP/2 400
    Content-Length: 35
    
    {"message":"Problems parsing JSON"}
    
  2. O envio do tipo errado de valores JSON resultará em uma resposta 400 Bad Request.

     HTTP/2 400
     Content-Length: 40
    
     {"message":"Body should be a JSON object"}
    
  3. O envio de campos inválidos resultará em uma resposta 422 Unprocessable Entity.

    HTTP/2 422
    Content-Length: 149
    
    {
      "message": "Validation Failed",
      "errors": [
        {
          "resource": "Issue",
          "field": "title",
          "code": "missing_field"
        }
      ]
    }
    

Todos os objetos de erro têm propriedades de recursos e campos para que seu cliente possa dizer qual é o problema. Há também um código de erro para que você saiba o que está errado com o campo. Estes são os possíveis códigos de erro de validação:

Nome do código de erroDescrição
missingUm recurso não existe.
missing_fieldNão foi definido um campo obrigatório em um recurso.
invalidFormatação de um campo é inválida. Revise a documentação para obter informações mais específicas.
already_existsOutro recurso tem o mesmo valor que este campo. Isso pode acontecer em recursos que precisam ter alguma chave única (como nomes de etiqueta).
unprocessableAs entradas fornecidas eram inválidas.

Os recursos também podem enviar erros de validação personalizados (em que code e custom ). Os erros personalizados sempre terão um campo de message que descreve o erro e a maioria dos erros também incluirá um campo de documentation_url que aponta para algum conteúdo que pode ajudá-lo a resolver o erro.

Redirecionamentos HTTP

A API REST do GitHub Enterprise Server usa o redirecionamento HTTP quando apropriado. Os clientes devem assumir que qualquer solicitação pode resultar em um redirecionamento. Receber um redirecionamento de HTTP não é um erro e os clientes devem seguir esse redirecionamento. As respostas de redirecionamento terão um campo do cabeçalho do tipo Location que contém o URI do recurso ao qual o cliente deve repetir as solicitações.

Código de statusDescrição
301Redirecionamento permanente. O URI que você usou para fazer a solicitação foi substituído pelo especificado no campo do cabeçalho Location. Este e todas as solicitações futuras deste recurso devem ser direcionadas para o novo URI.
302, 307Redirecionamento temporário. A solicitação deve ser repetida literalmente para o URI especificado no campo de cabeçalho Location, mas os clientes devem continuar a usar o URI original para solicitações futuras.

Outros códigos de status de redirecionamento podem ser usados de acordo com a especificação HTTP 1.1.

Verbos HTTP

Sempre que possível, a API REST do GitHub Enterprise Server procura usar verbos HTTP apropriados para cada ação. Observe que os verbos HTTP diferenciam maiúsculas de minúsculas.

VerboDescrição
HEADPode ser emitido contra qualquer recurso para obter apenas as informações de cabeçalho HTTP.
GETUsado para recuperar recursos.
POSTUsado para criar recursos.
PATCHUsado para atualizar recursos com dados parciais do JSON. Por exemplo, um recurso de problema tem os atributos title e body. Uma solicitação de PATCH pode aceitar um ou mais dos atributos para atualizar o recurso.
PUTUsado para substituir recursos ou coleções. Para solicitações PUT sem atributo body, defina o cabeçalho Content-Length como zero.
DELETEUsado para excluir recursos.

Hipermídia

Todos os recursos podem ter uma ou mais propriedades *_url vinculando outros recursos. Estes tem o objetivo de fornecer URLs explícitas para que os clientes API apropriados não precisem construir URLs por conta própria. É altamente recomendável que os clientes da API os utilizem. Fazer isso tornará as futuras atualizações da API mais fáceis para os desenvolvedores. Espera-se que todas as URLs sejam modelos de URI RFC 6570 adequados.

Em seguida, você pode expandir esses modelos usando algo como ogem uri_template:

>> tmpl = URITemplate.new('/notifications{?since,all,participating}')
>> tmpl.expand
=> "/notifications"

>> tmpl.expand all: 1
=> "/notifications?all=1"

>> tmpl.expand all: 1, participating: 1
=> "/notifications?all=1&participating=1"

Paginação

Pedidos que retornam vários itens serão paginados para 30 itens por padrão. Você pode especificar mais páginas com o parâmetro page. Para alguns recursos, você também pode definir um tamanho de página até 100 com o parâmetro per_page. Observe que por motivos técnicos nem todos os pontos de extremidade respeitam o parâmetro per_page, confira eventos por exemplo.

$ curl 'http(s)://HOSTNAME/api/v3/user/repos?page=2&per_page=100'

Observe que a numeração da página é baseada em 1 e que, ao omitir o parâmetro page, retornará a primeira página.

Alguns pontos de extremidade usam paginação baseada no cursor. Um cursor é uma string que aponta para uma localização no conjunto de resultados. Com paginação baseada em cursor, não há um conceito fixo de "páginas" no conjunto de resultados. Portanto, você não pode navegar para uma página específica. Em vez disso, você pode percorrer os resultados usando os parâmetros before ou after.

Para obter mais informações sobre paginação, confira nosso guia sobre Deslocamento com paginação.

Observação: É importante formar chamadas com valores de cabeçalho de link, em vez de construir suas URLs.

O cabeçalho Link inclui informações de paginação. Por exemplo:

Link: <http(s)://HOSTNAME/api/v3/user/repos?page=3&per_page=100>; rel="next",
  <http(s)://HOSTNAME/api/v3/user/repos?page=50&per_page=100>; rel="last"

O exemplo inclui uma quebra de linha para legibilidade.

Ou, se o ponto de extremidade usar paginação baseada em cursor:

Link: <http(s)://HOSTNAME/api/v3/orgs/ORG/audit-log?after=MTYwMTkxOTU5NjQxM3xZbGI4VE5EZ1dvZTlla09uWjhoZFpR&before=>; rel="next",

Esse cabeçalho de resposta Link contém uma ou mais relações de link de Hipermídia, algumas das quais podem exigir expansão como modelos de URI.

Os valores rel possíveis são:

NomeDescrição
nextA relação de link para a próxima página de resultados.
lastA relação de link para a última página de resultados.
firstA relação de link para a primeira página de resultados.
prevA relação de link para a página de resultados anterior imediata.

Tempos limite

Se GitHub leva mais de 10 segundos para processar uma solicitação de API, GitHub encerrará a solicitação e você receberá uma resposta de tempo limite como esta:

{
    "message": "Server Error"
}

GitHub Enterprise Server se reserva o direito de alterar o período de tempo limite para proteger a velocidade e confiabilidade da API.

Limitação de taxa

Os diferentes tipos de solicitações da API para your GitHub Enterprise Server instance estão sujeitos a diferentes limites de taxa.

Além disso, a API de pesquisa tem limites dedicados. Para obter mais informações, confira "Pesquisar" na documentação da API REST.

Note: The following rate limits are the default rate limits for GitHub Enterprise Server. Contact your site administrator to confirm the rate limits for your GitHub Enterprise Server instance.

Observação: você pode confirmar o status do seu limite de taxa atual a qualquer momento. Para obter mais informações, confira "Como verificar o status do seu limite de taxa".

Solicitações de contas pessoais

As solicitações diretas da API que você autentica com um personal access token são solicitações do usuário para servidor. Um aplicativo OAuth ou GitHub também pode fazer uma solicitação de usuário para servidor em seu nome depois de autorizar o aplicativo. Para obter mais informações, confira "Como criar um personal access token", "Como autorizar aplicativos OAuth" e "Como autorizar aplicativos GitHub".

GitHub Enterprise Server associa todas as solicitações de usuário para servidor ao usuário autenticado. Para aplicativos OAuth e aplicativos GitHub, este é o usuário que autorizou o aplicativo. Todos os pedidos de usuário-servidor contam para o limite de taxa do usuário autenticado.

By default, user-to-server requests are limited to 5,000 requests per hour and per authenticated user. All requests from OAuth applications authorized by a user or a personal access token owned by the user, and requests authenticated with any of the user's authentication credentials, share the same quota of 5,000 requests per hour for that user.

Solicitações de aplicativos GitHub

As solicitações de um aplicativo GitHub podem ser de usuário para servidor ou de servidor para servidor. Para obter mais informações sobre limites de taxa para aplicativos GitHub, confira "Limites de taxa para aplicativos GitHub".

Solicitações do GitHub Actions

Você pode utilizar o GITHUB_TOKEN integrado para autenticar as solicitações nos fluxos de trabalho do GitHub Actions. Para obter mais informações, confira "Autenticação automática de token".

Quando GITHUB_TOKEN é usado, o limite de taxa é de 1.000 solicitações por hora por repositório.

Verificando o status do seu limite da taxa

A API de limite de taxa e os cabeçalhos HTTP de uma resposta são fontes autorizadas para o número atual de chamadas de API disponíveis para você ou seu aplicativo a qualquer momento.

API de limite de taxa

Você pode usar a API do limite de taxa para verificar o status do seu limite de taxa sem impactar no limite atual. Para obter mais informações, confira "Limite de taxa".

Cabeçalhos de HTTP de limite de taxa

Os cabeçalhos HTTP retornados de qualquer solicitação de API mostram o seu status atual de limite de taxa:

$ curl -I http(s)://HOSTNAME/api/v3/users/octocat
> HTTP/2 200
> Date: Mon, 01 Jul 2013 17:27:06 GMT
> x-ratelimit-limit: 60
> x-ratelimit-remaining: 56
> x-ratelimit-used: 4
> x-ratelimit-reset: 1372700873
Nome do cabeçalhoDescrição
x-ratelimit-limitO número máximo de solicitações que você pode fazer por hora.
x-ratelimit-remainingO número de solicitações restantes na janela de limite de taxa atual.
x-ratelimit-usedO número de solicitações feitas na janela de limite de taxa atual.
x-ratelimit-resetO tempo em que a janela de limite de taxa atual é redefinida em segundos de época UTC.

Se você precisar de outro formato de tempo, qualquer linguagem de programação moderna pode fazer o trabalho. Por exemplo, se você abrir o console em seu navegador, você pode facilmente obter o tempo de redefinição como um objeto de tempo do JavaScript.

new Date(1372700873 * 1000)
// => Mon Jul 01 2013 13:47:53 GMT-0400 (EDT)

Se você exceder o limite de taxa, uma resposta do erro retorna:

> HTTP/2 403
> Date: Tue, 20 Aug 2013 14:50:41 GMT
> x-ratelimit-limit: 60
> x-ratelimit-remaining: 0
> x-ratelimit-used: 60
> x-ratelimit-reset: 1377013266

> {
>    "message": "API rate limit exceeded for xxx.xxx.xxx.xxx. (But here's the good news: Authenticated requests get a higher rate limit. Check out the documentation for more details.)",
>    "documentation_url": "https://docs.github.com/enterprise/3.6/rest/overview/resources-in-the-rest-api#rate-limiting"
> }

Aumentando o limite de taxa não autenticado para aplicativos OAuth

Se o seu aplicativo OAuth precisar fazer chamadas não autenticadas com um limite de taxa mais alto, você poderá passar o ID e o segredo do cliente do seu aplicativo antes do encaminhamento de pontos de extremidade.

$ curl -u my_client_id:my_client_secret -I http(s)://HOSTNAME/api/v3/user/repos
> HTTP/2 200
> Date: Mon, 01 Jul 2013 17:27:06 GMT
> x-ratelimit-limit: 5000
> x-ratelimit-remaining: 4966
> x-ratelimit-used: 34
> x-ratelimit-reset: 1372700873

Observação: Nunca compartilhe seu segredo de cliente com alguém ou o inclua no código do navegador do lado do cliente. Use o método mostrado aqui apenas para chamadas de servidor para servidor.

Manter-se dentro do limite de taxa

Se você exceder o limite de taxa usando a autenticação básica ou o OAuth, provavelmente poderá corrigir o problema armazenando em cache as respostas da API e usando solicitações condicionais.

Limites de taxa secundária

A fim de fornecer serviço de qualidade no GitHub Enterprise Server, podem-se aplicar limites de taxa adicionais podem a algumas ações ao usar a API. Por exemplo, usar a API para criar rapidamente conteúdo, fazer sondagem de modo agressivo em vez de usar webhooks, fazer várias solicitações simultâneas ou solicitar repetidamente dados caros do ponto de vista computacional podem resultar na limitação da taxa secundária.

Limites de taxa secundária não pretendem interferir com o uso legítimo da API. Seus limites de taxa normais devem ser o único limite em que você deve focar. Para garantir que você esteja agindo como um bom cidadão da API, confira nossas Diretrizes de Práticas Recomendadas.

Se seu aplicativo acionar este limite de taxa, você receberá uma resposta informativa:

> HTTP/2 403
> Content-Type: application/json; charset=utf-8
> Connection: close

> {
>   "message": "You have exceeded a secondary rate limit and have been temporarily blocked from content creation. Please retry your request again later.",
>   "documentation_url": "https://docs.github.com/enterprise/3.6/rest/overview/resources-in-the-rest-api#secondary-rate-limits"
> }

Solicitações condicionais

A maioria das respostas retorna um cabeçalho ETag. Muitas respostas também retornam um cabeçalho Last-Modified. Você pode usar os valores desses cabeçalhos para fazer solicitações subsequentes a esses recursos usando os cabeçalhos If-None-Match e If-Modified-Since, respectivamente. Se o recurso não tiver sido alterado, o servidor retornará um 304 Not Modified.

$ curl -I http(s)://HOSTNAME/api/v3/user
> HTTP/2 200
> Cache-Control: private, max-age=60
> ETag: "644b5b0155e6404a9cc4bd9d8b1ae730"
> Last-Modified: Thu, 05 Jul 2012 15:31:30 GMT
> Vary: Accept, Authorization, Cookie
> x-ratelimit-limit: 5000
> x-ratelimit-remaining: 4996
> x-ratelimit-reset: 1372700873

$ curl -I http(s)://HOSTNAME/api/v3/user -H 'If-None-Match: "644b5b0155e6404a9cc4bd9d8b1ae730"'
> HTTP/2 304
> Cache-Control: private, max-age=60
> ETag: "644b5b0155e6404a9cc4bd9d8b1ae730"
> Last-Modified: Thu, 05 Jul 2012 15:31:30 GMT
> Vary: Accept, Authorization, Cookie
> x-ratelimit-limit: 5000
> x-ratelimit-remaining: 4996
> x-ratelimit-reset: 1372700873

$ curl -I http(s)://HOSTNAME/api/v3/user -H "If-Modified-Since: Thu, 05 Jul 2012 15:31:30 GMT"
> HTTP/2 304
> Cache-Control: private, max-age=60
> Last-Modified: Thu, 05 Jul 2012 15:31:30 GMT
> Vary: Accept, Authorization, Cookie
> x-ratelimit-limit: 5000
> x-ratelimit-remaining: 4996
> x-ratelimit-reset: 1372700873

Compartilhamento de recursos entre origens

A API é compatível com Compartilhamento de Recursos de Origens Cruzadas (CORS) para solicitações de AJAX de qualquer origem. Você pode ler a Recomendação CORS W3C ou esta introdução do Guia de Segurança HTML 5.

Aqui está uma solicitação de exemplo enviada de um navegador atingindo http://example.com:

$ curl -I http(s)://HOSTNAME/api/v3 -H "Origin: http://example.com"
HTTP/2 302
Access-Control-Allow-Origin: *
Access-Control-Expose-Headers: ETag, Link, X-GitHub-OTP, x-ratelimit-limit, x-ratelimit-remaining, x-ratelimit-reset, X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Poll-Interval

A solicitação pré-voo de CORS se parece com isso:

$ curl -I http(s)://HOSTNAME/api/v3 -H "Origin: http://example.com" -X OPTIONS
HTTP/2 204
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Authorization, Content-Type, If-Match, If-Modified-Since, If-None-Match, If-Unmodified-Since, X-GitHub-OTP, X-Requested-With
Access-Control-Allow-Methods: GET, POST, PATCH, PUT, DELETE
Access-Control-Expose-Headers: ETag, Link, X-GitHub-OTP, x-ratelimit-limit, x-ratelimit-remaining, x-ratelimit-reset, X-OAuth-Scopes, X-Accepted-OAuth-Scopes, X-Poll-Interval
Access-Control-Max-Age: 86400

Chamadas de retorno do JSON-P

Você pode enviar um parâmetro ?callback para qualquer chamada de GET para envolver os resultados em uma função JSON. Isso geralmente é usado quando os navegadores desejam incorporar o conteúdo do GitHub Enterprise Server em páginas da Web, contornando problemas entre domínios. A resposta inclui a mesma saída de dados da API regular, mais as informações relevantes do cabeçalho de HTTP.

$ curl http(s)://HOSTNAME/api/v3?callback=foo

> /**/foo({
>   "meta": {
>     "status": 200,
>     "x-ratelimit-limit": "5000",
>     "x-ratelimit-remaining": "4966",
>     "x-ratelimit-reset": "1372700873",
>     "Link": [ // pagination headers and other links
>       ["http(s)://HOSTNAME/api/v3?page=2", {"rel": "next"}]
>     ]
>   },
>   "data": {
>     // the data
>   }
> })

Você pode escrever um manipulador do JavaScript para processar o retorno de chamada. Aqui está um exemplo pequeno que você pode experimentar:

<html>
<head>
<script type="text/javascript">
function foo(response) {
  var meta = response.meta;
  var data = response.data;
  console.log(meta);
  console.log(data);
}

var script = document.createElement('script');
script.src = 'http(s)://HOSTNAME/api/v3?callback=foo';

document.getElementsByTagName('head')[0].appendChild(script);
</script>
</head>

<body>
  <p>Open up your browser's console.</p>
</body>
</html>

Todos os cabeçalhos têm o mesmo valor da string que os cabeçalhos de HTTP com uma exceção notável: Link. Cabeçalhos de link são pré-analisados para você e chegam como um array de tuplas de [url, options].

Um link que se parece com isto:

Link: <url1>; rel="next", <url2>; rel="foo"; bar="baz"

... será mostrado assim na saída da chamada de retorno:

{
  "Link": [
    [
      "url1",
      {
        "rel": "next"
      }
    ],
    [
      "url2",
      {
        "rel": "foo",
        "bar": "baz"
      }
    ]
  ]
}

Fusos horários

Algumas solicitações que criam novos dados, como a criação de um novo commit, permitem que você forneça informações do fuso horário ao especificar ou marcas de tempo. Aplicamos as seguintes regras, por ordem de prioridade, para determinar as informações do fuso horário para essas chamadas da API.

Observe que essas regras se aplicam somente a dados passados para a API, não a dados retornados pela API. Conforme mencionado no "Esquema", os registros de hora retornados pela API estão em formato UTC, ISO 8601.

Fornecer explicitamente uma marca de tempo ISO 8601 com informações de fuso horário

Para chamadas de API que permitem que uma marca de tempo seja especificada, usamos essa marca de tempo exata. Um exemplo disso é a API Commits.

Esses carimbos de data/hora se parecem com 2014-02-27T15:05:06+01:00. Confira também este exemplo para saber como esses carimbos de data/hora podem ser especificados.

Usar o cabeçalho Time-Zone

É possível fornecer um cabeçalho Time-Zone que define um fuso horário de acordo com a lista de nomes do banco de dados Olson.

$ curl -H "Time-Zone: Europe/Amsterdam" -X POST http(s)://HOSTNAME/api/v3/repos/github/linguist/contents/new_file.md

Isso significa que geramos uma marca de tempo no momento em que sua chamada de API é feita no fuso horário que este cabeçalho define. Por exemplo, o API de Conteúdo gera um commit do git para cada adição ou alteração e usa a hora atual como marca de tempo. Este cabeçalho determinará o fuso horário usado para gerar essa marca de tempo atual.

Usar o último fuso horário conhecido para o usuário

Se nenhum cabeçalho Time-Zone for especificado e você fizer uma chamada autenticada para a API, nós usaremos o último fuso horário conhecido para o usuário autenticado. O último fuso horário conhecido é atualizado sempre que você navegar no site de GitHub Enterprise Server.

Definir como padrão UTC sem outras informações de fuso horário

Se as etapas acima não resultarem em nenhuma informação, usaremos UTC como o fuso horário para criar o commit do git.