Developer Tools • SDK • OAuth 2.0
TypeScript/JavaScript SDK for OAuth 2.0
The TypeScript/JavaScript SDK helps developers build API integrations without manually implementing every part of the OAuth 2.0 lifecycle. It provides structured API access, automated authentication handling, flexible token storage, and implementation resources for TypeScript and JavaScript projects. Use this guide to understand what the SDK manages and how to add it to your application.
What You'll Learn

Learn what the TypeScript/JavaScript SDK does, how it simplifies OAuth 2.0 authentication, how token storage works, how public APIs are accessed, and how to configure and test the SDK in your development environment.

Important

SDK package names, exported classes, configuration properties, and installation syntax may change as the developer tooling evolves. Always use the exact package name and current code examples provided in your developer documentation when installing or upgrading the SDK.

1

What is the TypeScript/JavaScript SDK?

The TypeScript/JavaScript SDK is a developer library designed to simplify OAuth 2.0 authentication and interaction with supported public APIs. Instead of manually building authorization, token exchange, refresh, storage, and API-request logic from the ground up, developers can use SDK components that handle much of this infrastructure.

The SDK is designed for TypeScript and JavaScript applications and supports flexible token-storage implementations. This allows development teams to integrate OAuth authentication into their existing architecture while reducing repetitive authentication and API-access code.

2

Key Benefits of the TypeScript/JavaScript SDK

The SDK reduces authentication boilerplate and provides reusable components for common integration requirements. This allows developers to spend more time building application functionality instead of recreating OAuth and API-access infrastructure.

  • OAuth 2.0 Automation: Simplifies supported installation, authentication, token-management, and uninstallation workflows.
  • Automatic Token Refresh: Reduces the need to manually build access-token refresh logic.
  • Flexible Token Storage: Allows applications to connect an appropriate database or storage implementation.
  • Public API Access: Provides SDK services for working with supported public API endpoints.
  • Implementation Samples: Gives developers examples that can reduce setup and testing time.
  • Generated SDK Releases: Helps keep SDK releases aligned with changes to supported API definitions.
3

Automated OAuth 2.0 Management

OAuth 2.0 involves more than obtaining an initial access token. Applications must manage authorization, token persistence, refresh behavior, requested scopes, installation events, and cleanup when an application is removed. The SDK reduces the amount of custom logic developers must build for these common authentication tasks.

CapabilityWhat It Helps Manage
Application InstallationSupports OAuth authorization during supported application-installation flows.
Token StorageWorks with the configured storage implementation to persist authentication information.
Token RefreshHelps obtain refreshed authentication when access credentials require renewal.
UninstallationSupports cleanup associated with removing an application installation.
OAuth 2.0 lifecycle management with the TypeScript JavaScript SDK
4

Database-Agnostic Token Management

OAuth applications require persistent storage for authentication data. The SDK uses a database-agnostic approach so developers can connect a storage implementation that fits their existing application architecture rather than being restricted to one database technology.

  • Flexible Storage: Connect an appropriate storage implementation that fits your application environment.
  • Existing Infrastructure: Keep authentication data within your established application architecture where appropriate.
  • Reference Implementations: Use available database examples to understand how token persistence can be implemented.
  • Scalable Architecture: Select storage technology based on the requirements of your application rather than the SDK itself.

Important: Database-agnostic does not mean token storage is optional. Your application still needs a reliable storage implementation so authentication information can be retrieved and updated throughout the OAuth lifecycle.

5

Public API Integration and Code Samples

The SDK provides generated services for interacting with supported public APIs and reduces the amount of request-building code developers need to maintain manually. Available examples can also help clarify expected request patterns and SDK usage.

Generated API Services: Use SDK methods for supported API operations instead of manually recreating every request.
Implementation Examples: Use current code samples to understand authentication, requests, parameters, and returned data.
Version Awareness: Verify the current API reference and SDK version when implementing or upgrading an integration.
TypeScript JavaScript SDK API documentation and code samples

6

Automated SDK Generation

The SDK is generated from supported API definitions so SDK releases can remain aligned with changes to endpoints, request models, and response schemas. Automated generation reduces manual SDK maintenance and helps expose newer API capabilities through consistent client methods.

  • API Alignment: SDK releases can be regenerated as supported API definitions change.
  • Consistent Client Structure: Generated services provide predictable patterns across API resources.
  • Controlled Upgrades: Development teams can adopt newer SDK releases through their normal package-management and testing process.

Note: Automated SDK generation refers to how newer SDK releases are produced. It does not mean a package already installed in your application automatically upgrades itself.

Getting Started
Ready to Add the SDK to Your Application?
Install the current SDK package, configure your OAuth application, connect token storage, and verify authentication and API connectivity before moving the integration into production.
7

How To Set Up the TypeScript/JavaScript SDK

A complete SDK implementation includes the current SDK package, OAuth application credentials, the correct redirect URI and scopes, persistent token storage, and a successful test API request. Verify each component independently before using the integration in production.

Step 1
Install the Current SDK Package

Open your developer documentation and locate the TypeScript/JavaScript SDK installation instructions. Copy the current NPM installation command exactly as documented and run it from the root of your project.

Installing the TypeScript JavaScript SDK from a project terminal
Step 2
Import and Initialize the SDK

Use the current import and initialization example from the developer documentation. Copy the documented exported class, package identifier, and configuration properties exactly rather than relying on older implementation examples.

Step 3
Configure the OAuth 2.0 Application

Configure the OAuth application before attempting authenticated API requests.

  • Create or open the application used by your integration.
  • Configure the OAuth scopes required by the application.
  • Configure the application's redirect URI.
  • Add the Client ID and Client Secret to your application's secure configuration.
  • Confirm the selected scopes provide access to the API resources your application needs.
Step 4
Configure Token Storage

Connect the storage implementation used by your application so OAuth token information can be persisted, retrieved, and updated. Use the available SDK storage examples as references when implementing this layer.

Step 5
Complete an OAuth Authorization Test

Run the application through an OAuth authorization flow using a test account. Confirm that the redirect succeeds, authentication information is stored, and the granted scopes match the permissions required by your integration.

Step 6
Test API Connectivity

Use a documented SDK method to make a test API request. Confirm the request succeeds using the application's OAuth credentials and verify that your token-storage implementation can retrieve and update authentication information as expected.

8

Frequently Asked Questions

Q: Where can I find the current SDK package and import syntax?
Use the current TypeScript/JavaScript SDK instructions in your developer documentation. Package identifiers and exported classes should be copied exactly as documented.
Q: Do I need to build token refresh logic manually?
The SDK is designed to manage supported token-refresh behavior as part of its OAuth lifecycle handling when authentication and token storage are configured correctly.
Q: Am I required to use a specific database?
No. The SDK uses a database-agnostic approach. Your application can use a compatible storage implementation that fits its architecture.
Q: Does automated SDK generation automatically upgrade my application?
No. Automated generation helps produce newer SDK releases. Your development team is still responsible for updating the package dependency and testing newer versions before deployment.
Q: Are SDKs available for other programming languages?
Yes. Additional SDK options are available for developers who prefer supported languages other than TypeScript or JavaScript. Check the current developer documentation for available SDKs and installation instructions.
Q: Why does OAuth succeed but my API request return a permission error?
Confirm the required OAuth scopes were requested and granted, verify that the expected installation token is being retrieved, and check that the API operation is permitted by the application's configured scopes.
Q: Can I continue using an older SDK implementation?
Review the current developer documentation before maintaining or upgrading an older implementation. Package names, exported classes, API versions, and supported methods can change over time.
9

Need Help?

If the SDK does not behave as expected, first determine whether the failure occurs during installation, OAuth authorization, token storage, token refresh, or the API request itself. Isolating the failing stage makes troubleshooting significantly easier.

  • Installation or Import Error: Compare the package name, installed version, import syntax, and exported class with the current developer documentation.
  • OAuth Redirect Error: Confirm the redirect URI sent by your application exactly matches the URI configured for the OAuth application.
  • Permission Error: Confirm the application requested and received the scopes required for the API operation.
  • Token Error: Verify your storage implementation can create, retrieve, update, and persist the expected authentication data.
  • API Request Error: Review the current API reference for the endpoint, HTTP method, required parameters, scopes, and supported API version.
  • Reproducible Platform Error: Capture the request details, response status, response body, affected endpoint, timestamp, SDK version, and steps required to reproduce the issue before contacting support.