Guides
Learn More about Newline

SDK Overview

The Newline TypeScript SDK provides a type‑safe, developer‑friendly way to integrate with the Newline Platform APIs using modern JavaScript and TypeScript. It offers language‑native abstractions that reduce integration boilerplate while preserving the exact behavior, lifecycle semantics, and constraints defined by the underlying APIs.

This page explains what the SDK is designed to do, how it fits into the Newline platform, and how to use it effectively alongside other integration options such as direct API calls and CSV‑based reporting.

What the SDK Is Designed For

The Newline TypeScript SDK is intended for application developers who want to interact programmatically with Newline APIs from JavaScript or TypeScript environments.

The SDK is designed to:

  • Simplify API integration using strongly typed methods
  • Handle authentication and request configuration consistently
  • Surface API responses and errors in predictable, structured formats
  • Reduce manual HTTP request construction
  • Align closely with documented API behavior and lifecycle rules

The SDK improves developer productivity without abstracting away platform behavior.

What the SDK Is (and Is Not)

The Newline TypeScript SDK is a thin client layered directly on top of the Newline REST API.

What the SDK is

  • A generated, type‑safe wrapper around documented API endpoints
  • A convenience layer for application‑level integrations
  • Fully aligned with Newline API limits, permissions, and lifecycle rules

What the SDK is not

  • A separate execution layer
  • A replacement for Newline CSV reporting
  • A system that modifies settlement, posting, or reconciliation semantics
  • An abstraction that hides transaction lifecycle complexity

Understanding core Newline concepts such as transactions, settlement, posting, and reconciliation remains essential when using the SDK.

Relationship to the Newline API

Every SDK method maps directly to a documented Newline API endpoint.

As a result:

  • API authentication rules apply unchanged
  • Rate limits and permissions behave exactly as documented
  • Transaction, settlement, and posting timelines are identical
  • API documentation remains the source of truth for behavior

When troubleshooting or validating platform behavior, always reference the underlying API documentation.

How the SDK Fits into the Newline Integration Model

The SDK is one of several ways to integrate with the Newline platform:

  • SDKs — Programmatic access using language‑native tooling
  • Direct API calls — Custom HTTP integrations using REST
  • CSV reporting — Authoritative sources for reconciliation and posting visibility
  • MCP server — Dynamic API discovery and invocation for AI‑based tools

Each serves a distinct purpose. The SDK is optimized for application logic, while CSV reporting is essential for reconciliation and financial accuracy.

Capabilities at a Glance

The SDK exposes operations across major Newline platform domains, including:

  • Authentication and authorization
  • Transfers and payments
  • Transactions and transaction events
  • Accounts and balances
  • Returns processing
  • Reporting and closing balances
  • Virtual reference number management
  • Sandbox simulation utilities

Detailed method documentation is available in the SDK reference.

Transaction Lifecycle Awareness

Using the SDK effectively requires understanding the Newline transaction lifecycle:

  • Settlement represents completed movement of funds
  • Posting reflects bank statement activity, typically available via CSV reports
  • Lifecycle updates may be reflected as record‑level changes or new transactions

Important considerations:

  • SDK access complements, but does not replace, CSV reporting
  • Posted dates and closing balances may populate later than settlement
  • Statement‑level reconciliation depends on dedicated CSV reports

Applications should treat settlement, posting, and reconciliation as distinct phases.

Supported Environments

The Newline TypeScript SDK is built for modern JavaScript and TypeScript runtimes and is published as an ES Module (ESM).

Runtime support details are documented in the SDK repository. Applications using CommonJS must use dynamic imports.

Documentation Structure

The SDK documentation is organized to support different stages of integration:

  • Quick Start — Install the SDK and make a first API call
  • Authentication & Configuration — Credential handling and environments
  • Using the SDK — Common patterns and workflows
  • SDK Reference — Complete, generated method documentation
  • Reporting Guides — CSV‑based reconciliation and posting workflows

The Quick Start is the recommended next step for first‑time users.

Maturity and Versioning

The Newline TypeScript SDK is currently in beta.

Breaking changes may occur between releases without a major version bump. Production integrations should pin SDK versions and follow documented upgrade guidance.

Next Step

With an understanding of what the Newline TypeScript SDK is and how it fits into the platform, continue through the SDK documentation in the following order:

  1. SDK Quick Start Guide:
    Install the SDK, configure basic authentication, and make your first successful API call.

  2. Authentication & Environment Setup:
    Learn how program‑level credentials work, how to manage sandbox and production environments, and recommended practices for secure configuration.

  3. Using the SDK:
    Explore common usage patterns, workflows, and best practices for working with transactions, transfers, accounts, and errors.

  4. SDK Reference:
    Access the complete, generated reference documentation for all SDK resources, methods, configuration options, and error types.

Following this sequence provides a clear progression from initial setup to advanced implementation.

Updated 8 days ago