Square SDKs & Libraries: Official & Community Integrations (2026)

SDKs overview

Square provides a suite of Software Development Kits (SDKs) designed to facilitate integration with its various APIs, including Payments, Orders, Customers, and Catalog. These SDKs abstract away the complexities of direct HTTP requests, authentication, and data serialization, allowing developers to focus on application logic rather than low-level API interactions. The official SDKs are available across multiple programming languages, reflecting common developer preferences and environments. Each SDK is maintained by Square and kept up-to-date with the latest API versions and features, ensuring compatibility and access to new functionalities as they are released. Developers can utilize these tools to build custom point-of-sale systems, e-commerce integrations, inventory management solutions, and other applications that interact with Square's platform.

The availability of SDKs for popular languages like Java, Python, and Node.js supports a broad developer ecosystem. By using an SDK, developers can often reduce the amount of boilerplate code required to make API calls, handle errors, and process responses. This approach can accelerate development cycles and improve code maintainability. Square also offers a sandbox environment, which is fully supported by the SDKs, allowing developers to test their integrations without affecting live production data or incurring real transaction costs. This testing environment mirrors the production API behavior, enabling thorough validation of application functionality before deployment. The underlying API itself is RESTful, communicating primarily through JSON payloads, a common standard for web services as defined by organizations like the W3C JSON standard.

Official SDKs by language

Square maintains official SDKs for several widely used programming languages. These SDKs are designed to provide idiomatic interfaces for each language, making the integration process more natural for developers familiar with specific language conventions. Each SDK includes client libraries for accessing various Square API services, utility functions for common tasks like signature verification, and support for OAuth authentication flows.

The following table outlines the official SDKs, their typical package names, and their general maturity:

Each SDK provides specific client objects for interacting with different API groups, such as PaymentsApi, CustomersApi, and CatalogApi. These objects encapsulate the necessary methods for performing operations like creating payments, managing customer profiles, or retrieving catalog items. For example, the Node.js SDK's Client object would be initialized with an access token, and then its various API clients, like paymentsApi, would be used to invoke specific operations such as createPayment. The comprehensive Square API reference details all available endpoints and their corresponding request/response structures, which the SDKs implement.

Installation

Installing Square's SDKs typically involves using the package manager specific to the programming language's ecosystem. The process is standardized for each environment, facilitating quick setup for developers. Below are common installation commands for the official Square SDKs:

Java Installation

For Java projects, you can add the Square SDK as a dependency in your pom.xml (Maven) or build.gradle (Gradle) file. This integrates the SDK into your project's build path.

<!-- Maven dependency -->
<dependency>
    <groupId>com.squareup</groupId>
    <artifactId>square</artifactId>
    <version>25.0.0</version> <!-- Replace with the latest version -->
</dependency>

// Gradle dependency
implementation 'com.squareup:square:25.0.0' // Replace with the latest version

PHP Installation

The PHP SDK is installed via Composer, the dependency manager for PHP. This command adds the SDK to your project and generates the autoloader configuration.

composer require square/square

Python Installation

For Python projects, the SDK is installed using pip, the Python package installer. This command makes the square package available in your Python environment.

pip install square

Ruby Installation

Ruby developers can install the SDK using RubyGems, the standard package manager for Ruby. This adds the square gem to your system or project's Gemfile.

gem install square

.NET (C#) Installation

The .NET SDK is typically installed via NuGet Package Manager in Visual Studio or using the .NET CLI.

dotnet add package Square.Connect

Node.js Installation

For Node.js applications, the SDK is installed using npm (Node Package Manager) or yarn.

npm install square-connect

After installation, developers typically need to configure the SDK with their Square application credentials, such as an access token, which can be generated from the Square Developer Dashboard. The access token is crucial for authenticating API requests and ensuring secure communication with Square's services, adhering to principles of secure API access as outlined by resources like OAuth.net.

Quickstart example

This example demonstrates how to create a payment using the Square Node.js SDK. This quickstart assumes you have installed the square-connect package and have a valid Square access token and location ID.

const { Client, Environment } = require('square-connect');
const { v4: uuidv4 } = require('uuid'); // For generating unique IDs

// Initialize the Square client
const client = new Client({
  environment: Environment.Sandbox, // Use Environment.Production for live transactions
  accessToken: process.env.SQUARE_ACCESS_TOKEN, // Your Square access token
});

const paymentsApi = client.paymentsApi;

async function createSquarePayment() {
  const idempotencyKey = uuidv4(); // Unique key to prevent duplicate payments
  const sourceId = 'cnon:card-nonce-ok'; // Replace with an actual card nonce from a Square Web Payment SDK or Reader SDK
  const locationId = process.env.SQUARE_LOCATION_ID; // Your Square location ID

  const requestBody = {
    sourceId: sourceId,
    idempotencyKey: idempotencyKey,
    amountMoney: {
      amount: 100, // Amount in cents (e.g., $1.00)
      currency: 'USD',
    },
    autocomplete: true,
    locationId: locationId,
    // Optional: referenceId, buyerEmailAddress, customerId, etc.
  };

  try {
    const { result } = await paymentsApi.createPayment(requestBody);
    console.log('Payment created successfully:', result.payment);
    return result.payment;
  } catch (error) {
    console.error('Error creating payment:', error.result);
    if (error.result) {
      console.error('Detailed error:', error.result.errors);
    }
    throw error;
  }
}

// Example usage:
createSquarePayment()
  .then(payment => {
    console.log('Payment process complete.');
  })
  .catch(err => {
    console.error('Payment failed:', err);
  });

This example demonstrates the typical flow:

1. Initialization: Create a new Client instance, specifying the environment (Sandbox for testing, Production for live) and providing your accessToken.
2. API Client Access: Obtain a specific API client, such as paymentsApi, from the initialized Client object.
3. Request Body Construction: Build the request payload according to the API's specifications. Key elements include sourceId (a token representing the payment method, often obtained from a client-side SDK like the Square Web Payments SDK), idempotencyKey (a unique identifier to ensure requests are processed only once), and amountMoney.
4. API Call: Invoke the relevant method on the API client (e.g., createPayment) with the constructed request body.
5. Error Handling: Implement try-catch blocks to gracefully handle potential API errors, which can include issues like invalid credentials, insufficient funds, or network problems.

For production environments, the sourceId would typically come from a client-side payment form handled by Square's Web Payments SDK or In-App Payments SDK, which securely tokenizes card information without it ever touching your server directly, helping maintain PCI DSS compliance.

Community libraries

Beyond the official SDKs, the Square developer community has created various libraries and tools that extend Square's functionality or provide integrations in languages not officially supported. These community-driven projects can range from wrappers for specific API endpoints to full-fledged integrations with third-party systems. While not officially supported by Square, they can offer flexibility and address niche requirements. Developers should evaluate community libraries for their maintenance status, documentation, and licensing before incorporating them into critical applications.

Examples of community contributions often include:

• Client libraries for less common languages: Developers might create SDKs for languages like Go, Rust, or Swift (outside of the official iOS/Android SDKs) to interact with Square APIs.
• Framework integrations: Libraries that specifically integrate Square's APIs with popular web frameworks such as Django, Flask, Laravel, or Ruby on Rails, providing helper methods or ORM-like interfaces.
• Specialized utilities: Tools for specific tasks, like advanced webhook validation, custom reporting, or bulk data operations that might simplify common developer workflows.
• Plugins for e-commerce platforms: While Square offers official plugins for some platforms, community members might develop integrations for other e-commerce solutions or provide enhanced features for existing ones.

Discovering community libraries often involves searching developer forums, GitHub, or package registries specific to programming languages. The Square developer community forums and GitHub repositories are good starting points for finding and contributing to such projects, fostering a collaborative environment around the Square platform.