@octokit/auth-token

What is @octokit/auth-token?

The @octokit/auth-token package is designed to simplify the process of authenticating GitHub API requests. It provides a straightforward way to create an authentication token that can be used with Octokit clients or any other HTTP client to interact with the GitHub API securely.

What are @octokit/auth-token's main functionalities?

Creating an authentication token

This feature allows you to create an authentication token using a personal access token. The created auth object can then be used to authenticate GitHub API requests.

const { createTokenAuth } = require('@octokit/auth-token');
const auth = createTokenAuth('personal-access-token123');
auth().then((authentication) => {
  console.log(authentication);
});

Other packages similar to @octokit/auth-token

@octokit/auth-app

Similar to @octokit/auth-token, @octokit/auth-app focuses on authenticating GitHub Apps instead of personal access tokens. It provides more complex authentication mechanisms required for GitHub Apps, including handling JWT and installation access tokens.

@octokit/auth-basic

This package offers basic authentication for GitHub using a username and password combination. It's simpler and less secure compared to @octokit/auth-token, which uses tokens for authentication. @octokit/auth-basic is primarily used for legacy projects or in scenarios where token-based authentication cannot be used.

@octokit/auth-oauth-app

The @octokit/auth-oauth-app package is designed for OAuth-based authentication for GitHub applications. It differs from @octokit/auth-token by providing a complete OAuth flow, including redirecting users to GitHub for authentication and handling the OAuth tokens, making it suitable for web applications that need to authenticate users via GitHub.

README

auth-token.js

GitHub API token authentication for browsers and Node.js

@octokit/auth-token is the simplest of GitHub’s authentication strategies.

It is useful if you want to support multiple authentication strategies, as it’s API is compatible with its sibling packages for basic, GitHub App and OAuth app authentication.

• Usage
• createTokenAuth(token) options
• auth()
• Authentication object
• auth.hook(request, route, options) or auth.hook(request, options)
• Find more information
  • Find out what scopes are enabled for oauth tokens
  • Find out if token is a personal access token or if it belongs to an OAuth app
  • Find out what permissions are enabled for a repository
  • Use token for git operations
• License

Usage

Browsers	Load @octokit/auth-token directly from esm.sh <script type="module"> import { createTokenAuth } from "https://esm.sh/@octokit/auth-token"; </script>
Node	Install with npm install @octokit/auth-token import { createTokenAuth } from "@octokit/auth-token";

const auth = createTokenAuth("ghp_PersonalAccessToken01245678900000000");
const authentication = await auth();
// {
//   type: 'token',
//   token: 'ghp_PersonalAccessToken01245678900000000',
//   tokenType: 'oauth'
// }

createTokenAuth(token) options

The createTokenAuth method accepts a single argument of type string, which is the token. The passed token can be one of the following:

• Personal access token
• OAuth access token
• GITHUB_TOKEN provided to GitHub Actions
• Installation access token (server-to-server)
• User authentication for installation (user-to-server)

Examples

// Personal access token or OAuth access token
createTokenAuth("ghp_PersonalAccessToken01245678900000000");
// {
//   type: 'token',
//   token: 'ghp_PersonalAccessToken01245678900000000',
//   tokenType: 'oauth'
// }

// Installation access token or GitHub Action token
createTokenAuth("ghs_InstallallationOrActionToken00000000");
// {
//   type: 'token',
//   token: 'ghs_InstallallationOrActionToken00000000',
//   tokenType: 'installation'
// }

// Installation access token or GitHub Action token
createTokenAuth("ghu_InstallationUserToServer000000000000");
// {
//   type: 'token',
//   token: 'ghu_InstallationUserToServer000000000000',
//   tokenType: 'user-to-server'
// }

auth()

The auth() method has no options. It returns a promise which resolves with the the authentication object.

Authentication object

name	type	description
type	string	"token"
token	string	The provided token.
tokenType	string	Can be either "oauth" for personal access tokens and OAuth tokens, "installation" for installation access tokens (includes GITHUB_TOKEN provided to GitHub Actions), "app" for a GitHub App JSON Web Token, or "user-to-server" for a user authentication token through an app installation.

auth.hook(request, route, options) or auth.hook(request, options)

auth.hook() hooks directly into the request life cycle. It authenticates the request using the provided token.

The request option is an instance of @octokit/request. The route/options parameters are the same as for the request() method.

auth.hook() can be called directly to send an authenticated request

const { data: authorizations } = await auth.hook(
  request,
  "GET /authorizations",
);

Or it can be passed as option to request().

const requestWithAuth = request.defaults({
  request: {
    hook: auth.hook,
  },
});

const { data: authorizations } = await requestWithAuth("GET /authorizations");

Find more information

auth() does not send any requests, it only transforms the provided token string into an authentication object.

Here is a list of things you can do to retrieve further information

Find out what scopes are enabled for oauth tokens

Note that this does not work for installations. There is no way to retrieve permissions based on an installation access tokens.

const TOKEN = "ghp_PersonalAccessToken01245678900000000";

const auth = createTokenAuth(TOKEN);
const authentication = await auth();

const response = await request("HEAD /");
const scopes = response.headers["x-oauth-scopes"].split(/,\s+/);

if (scopes.length) {
  console.log(
    `"${TOKEN}" has ${scopes.length} scopes enabled: ${scopes.join(", ")}`,
  );
} else {
  console.log(`"${TOKEN}" has no scopes enabled`);
}

Find out if token is a personal access token or if it belongs to an OAuth app

const TOKEN = "ghp_PersonalAccessToken01245678900000000";

const auth = createTokenAuth(TOKEN);
const authentication = await auth();

const response = await request("HEAD /");
const clientId = response.headers["x-oauth-client-id"];

if (clientId) {
  console.log(
    `"${token}" is an OAuth token, its app’s client_id is ${clientId}.`,
  );
} else {
  console.log(`"${token}" is a personal access token`);
}

Find out what permissions are enabled for a repository

Note that the permissions key is not set when authenticated using an installation access token.

const TOKEN = "ghp_PersonalAccessToken01245678900000000";

const auth = createTokenAuth(TOKEN);
const authentication = await auth();

const response = await request("GET /repos/{owner}/{repo}", {
  owner: "octocat",
  repo: "hello-world",
});

console.log(response.data.permissions);
// {
//   admin: true,
//   push: true,
//   pull: true
// }

Use token for git operations

Both OAuth and installation access tokens can be used for git operations. However, when using with an installation, the token must be prefixed with x-access-token.

This example is using the execa package to run a git push command.

const TOKEN = "ghp_PersonalAccessToken01245678900000000";

const auth = createTokenAuth(TOKEN);
const { token, tokenType } = await auth();
const tokenWithPrefix =
  tokenType === "installation" ? `x-access-token:${token}` : token;

const repositoryUrl = `https://${tokenWithPrefix}@github.com/octocat/hello-world.git`;

const { stdout } = await execa("git", ["push", repositoryUrl]);
console.log(stdout);

License

MIT