Aspera strives to help organizations move big data around the world at top speeds regardless of their preferred implementation method. That’s why we have created a comprehensive SDK that enables integration of Aspera’s FASP® transport technology into virtually any web, desktop or mobile application.

The Aspera SDK offers a complete set of Application Program Interfaces (APIs) with supporting documentation and sample code to help developers integrate Aspera technology into applications as a replacement for traditional TCP-based protocols such as FTP or HTTP. The Aspera SDK includes web service APIs (REST and SOAP) as well as native libraries for Java, .NET, and C++.

The Aspera SDK is available to developers via an annual development subscription to Aspera Developer Network that includes all available libraries, APIs and  web services, as well as development licenses and developer support.

SDK Highlights

  • Easily integrate Aspera  FASP® transfer technology into any applications
  • Use REST web services, SOAP web services, or JavaScript to integrate Aspera FASP into web applications
  • Leverage the Aspera FASP Manager API for Java, .NET, and C++ to embed Aspera transfer technology into your client, server, and embedded applications
  • Transfer byte-stream data using Aspera FASPStream to enable in-memory access
  • Fully embeddable client or embeddable server
  • Develop mobile applications using the Aspera Mobile SDK for iOS and Android applications.
  • View best practices and code examples on the Aspera Developer Network, including fully functional online web application examples

Web APIs

Node API

The Node API consists of a set of RESTful interfaces to provide control of the Aspera transfer server environment including the ability to ping and query information about an Aspera Node; create, delete and rename files on an Aspera Node; perform searches within the node file system; and prepare for transferring files utilizing Aspera technology.

faspex™ Web API

The Aspera faspex Web API provides a set of RESTful web services to enable browsing, publishing, sending, and receiving faspex packages while leveraging Aspera FASP® high-speed transfer technology.


The Aspera Console API provides full control over Aspera transfer sessions including initiation, queuing, management and control through a set of RESTful interfaces.

SOAP Web Services

Aspera offers SOAP web services to allow local or remote applications to initiate, monitor, and control FASP-based transfers. The SOAP API is useful for server-to-server job submissions and retrieving transfer information.

Transfer SDK

FASP Manager

The Aspera FASP Manager SDK is used to develop custom applications that embed Aspera transfer technology.  The Aspera FASP Manager SDK includes native bindings for Java, C++, and .NET.


The Aspera FASPStream API enables developers to bypass the file system and directly access the Aspera high-speed FASP pipe∫ from within their applications. By utilizing the FASPStream interface, data being generated or captured can be transferred before written to disk and/or incoming data can be processed as soon as bytes are received. The FASPStream API supports .NET, Java, and C++.

Connect Client

The Connect JavaScript API allows for the integration of FASP-based file transfer technology directly into web application for a completely in-browser user experience. Developers can define how users initiate and control transfers (with an optional drag-and-drop interface between desktop and the browser), how transfer progress is presented to the users within their web application, and how various user actions and error conditions are handled by the application.

mobile SDK

Developers who wish to embed high-speed file transfer into mobile applications can leverage the Aspera Mobile SDKs for iOS and Android. The Aspera Mobile SDK offers a queue-based API for initiating, managing and monitoring high-speed FASP transfers between mobile devices and Aspera transfer servers.

Android SDK

The Aspera Android SDK provides a Java API to transfer files using FASP on Google Android-powered mobile devices.


The Aspera iOS SDK provides an Objective C API to transfer files using FASP on iPhone and iPad devices.

application API

Java faspex Client

The Aspera Java faspex Client SDK provides a comprehensive, easy-to-use API to access Aspera faspex services. This SDK brings together the faspex REST API and the actual transfer of files using FASP. It allows developers to build a functional faspex client with only a few lines of code.

Aspera Developer Network (ADN) is an online portal that provides developers with guides, reference information and sample code to assist developers with the process of integrating Aspera technology into their own applications. Continuously updated with the latest releases, documentation and examples, it is THE place for the developers who are working on integrating Aspera FASP® technology into their desktop, mobile, network-based, and web applications.

ADN access is available on an annual subscription basis. The deployment of applications integrating Aspera software requires valid Aspera product licenses depending on the type of application.

Login to Aspera Developer Network


The Aspera Files API allows developers to create applications that leverage the Aspera Files SAAS platform. API’s are available for all aspects of Aspera files including the creation and management of Workspaces, Groups, Users, permissions, packages, and dropboxes.

Building upon the previous Files REST-based API’s, support now exists for both web and client-based applications. In addition to OAuth-based authorization for Web applications, we have added support for client-based applications by integrating JSON Web Token (JWT) support. This eliminates the need to have a browser session established as is required with standard OAuth authentication.

Any number of clients can be authorized to use JWT as an authentication mechanism each with their own, individual set of credentials (or tokens). Each registered client/user is secured by a public/private keypair which is unique to each JWT client.

JWT Tokens support the same authorization scoping as OAuth to allow for varying levels of access to resources.

Screen Shot 2017-04-02 at 4.46.25 PM.png

The Aspera Files REST API’s adhere strictly to REST best-practices including appropriate use of HTTP verbs, HTTP response codes, etc.

High-level Aspera Files API resources include:

  • Clients
  • Contacts
  • Dropboxes
  • Groups
  • Messages
  • Nodes
  • Operations
  • Organizations
  • Packages
  • SAML_Configurations
  • URL_Tokens
  • Usage_Reports
  • Users
  • Workspaces

 Additional details on the Aspera Files REST API’s may be found at:

 Screen Shot 2017-04-02 at 4.50.13 PM.png

Node API

  • /usage reports transfer usage (bytes in, out and total) by access key for per tenant reporting in Aspera Files and 3rd-party applications
  • /events reports file create, rename and delete events, and filters by event id
  • /permissions API implements read, write, delete, mkdir, rename, and preview permissions for all user and group based permissions to allow for fine-grained permission capabilities in Aspera Files and other applications
  • /filelocks capability allows a specific user to lock a path to such that any modification attempt by another user (rename, delete, overwrite) will fail. Locks can be deleted by owner users or Administrative-scoped users.
  • /files API can now return the file path for admin-scoped users
  • /files/preview API with support for range GET requests compatible with stock iOS and Android previews
  • /files has new case-insensitive filters that return filename matches regardless of case
  • /ops/transfers API supports an iteration token for querying file and transfer events from a point-in-time /ops/transfers option to pause/resume/cancel or change rate, bandwidth priority of transfers (3.7.4)
  • /info and / API responses now include content protection settings.
  • new call returns verbatim the content of a file within the file size restriction set in aspera.conf.
  • /ops token authorization now uses SHA-2 as the default checksum, rather than SHA-1.


Aspera has released significant updates to it’s popular FaspManager API. In addition to the traditional Java, .NET, and C++ FaspManager API’s we have now added support for Python and Golang. All of the FaspManager implementations follow the same semantics such that they are familiar from one language to another.

FaspManager versions are now following the same versioning as the Aspera Enterprise Server products so now it is very easy to determine which features are supported when paired with a particular Aspera Enterprise Server implementation.

With the release of FaspManager 3.7.2 for Java, .NET, Python, and Golang, support has been added for the following transfer options:

 --preserve-access-time and --preserve-source-access-time
 --preserve-acls and --remote-preserve-acls
 --preserve-xattrs and --remote-preserve-xattrs

In addition, beginning with the Java FaspManager 3.7.2 releases for Java and Golang, support has been added for ascp4 stream-to-file streaming such that native language objects (InputStream or Readers in Java for example) may be used as stream sources for files being written to a remote destination. FaspManager no longer requires a file as the source, nor does it require you to know the size of the stream source ahead of time. For example one could use the following code to create a file at a remote destination using the homepage as the contents of a file named asperasoft.html:

... url = new"");
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
InputStream inputStream = connection.getInputStream();

FaspManager.getSingleton().addSource(jobId, inputStream, "asperasoft.html");


Additional information about the FaspManager API may be found at: 

Screen Shot 2017-04-02 at 5.33.42 PM.png



Major advances in the FaspStream core software and SDK’s for Java and .NET have been made in version 3.7. Building off of feedback from customers we have added features to Aspera FaspStream to give developers much finer grained control over the internals of the FaspStream API implementation. This includes the ability to set timeout values for all major connection aspects of the FaspStream SDK as well as more control over handling error conditions.

Several new sample applications have been added which demonstrate such things as bi-directional communication including an HTTP-Like POST file example. This is very useful for those applications where you want to have a high-speed data transfer pipeline in one direction with occasional initial or post data transfer (message-like) communication the other direction.

Much better monitoring and control over FaspStream startup and teardown has been added giving developers the ability to take appropriate action as specific actions occur.

The object hierarchy in FaspStream 3.7 has been improved such that you no longer need to access “inner-objects” to carry out certain actions. All actions are now available from the top-level FaspStreamClient and FaspStreamServer classes. This includes things such as both read and write interfaces for FaspStreamClient and FaspStreamServer. No longer do you need to access the FaspInputStream and FaspOutputStream objects - everything is figured out for you on directly.

Modern logging facilities have been added for both the Java and .NET versions of FaspStream 3.7. Java FaspStream now supports the built-in java.util.logging API and .NET FaspStream now uses the log4net API. Abstractions have been built into the FaspStream API to both programmatically control logging within your application as well as control logging through a standard configuration file. For example it is now extremely simple to control logging to a file as well as control console loggers independent of each other. 

Screen Shot 2017-04-02 at 7.06.17 PM.png


Now that all of the major browser vendors have moved away from providing NPAPI support, Aspera continues to ensure we outfit developers with the support they need to support the latest browser versions. It is more important now than ever to move your Aspera Connect-enabled web applications to use asperaweb-4.js.

With Aspera Connect 3.7, Aspera has released several major enhancements that allow developers to create even richer experiences using the Aspera Connect transfer technology. These enhancements include: 

  • Support for more than 100 concurrent transfer sessions.
    • The Aspera Connect GUI displays only the first 100 sessions but the Connect API will return the entire list of active transfer sessions.
  • Individual file status is now reported for each file that is part of a file transfer session.
    • TransferInfo objects returned as part of status callbacks now contain a JSON array of each individual file along with its status, any errors that may have occurred that effect that file, byte counts, etc.
    • In the past only the “current” transferring file and total session status was available.
  • ShowSelectFolderDialog() permission enhancements
    • Prior to Aspera Connect 3.7, when a user selected a folder that was surfaced by a call to showSelectFolderDialog(), the entire folder was required to be transferred - not just a subset of files or folders within the selected folder hierarchy.
    • Beginning with Connect 3.7 any files or folders residing within the folder hierarchy of the folder selected via the showSelectFileDialog() may be transferred. This allows a developer selectively choose the files to be transferred rather than transferring the complete folder. An example use case might be where an application wants to only transfer files of a particular type (images for example) and ignore the rest of the files in the selected hierarchy.


Additionally, Aspera Connect 3.7 has added support for all of the the transfer options included in Aspera Enterprise Server 3.7.2.


The Aspera Command Line Client (“CLI”) has quickly become the tool of choice for headless automation of Aspera transfers including those interacting with Aspera Faspex and Aspera Shares. The latest version of the Aspera CLI includes several capabilities that our customers have asked for in addition to leveraging the latest Aspera core transfer technology.

Over time we will add support for Aspera Files and new features in Aspera Shares 2.0 but our latest release (3.7) includes the following new options not available in previous versions of the CLI: 

  • --remove-after-transfer : Remove source files after successful transfer
  • --overwrite : Specify overwrite method: never, always, older, diff, diff+older
  • --src_base : Preserve directory structure of source arguments below a certain level (base)
  • -c : AES Cipher support: aes128, aes192, aes256
  • -E : Support for file exclude patterns
  • --remove-empty-directories : Remove empty source subdirectories
  • --remove-empty-source-directory : Remove source directory if empty
  • --move-after-transfer : Move source files to archive location after successful transfer
  • -x : Aspera Proxy support


The latest generation of the Faspex API (version 4.0) includes several new features which expand the capabilities of the Faspex platform. At a high-level these new features include:

  • Content Routing
    • Faspex content may now be routed/copied/delivered based a Faspex users “assigned” location(s).



  • Package Staging
    • With this feature, Faspex users have the ability to “stage” a Faspex package.
    • Until a Faspex package is taken out of a “staged” state, it will not be processed or sent.
  • Package Editing
    • All metadata for a Faspex package (including package contents) may be edited both before a package is sent and after it is sent, whether in a “staged” or “live” state.
    • If a package has already been sent and a user has already downloaded a package, they are notified that there is a package update available and anyone subsequently downloading the package will also get the new package.
  • Delayed Send / Go-Live date
    • Packages may now be marked with a “Go-Live” date. This feature allows a Faspex package creator to set a date at which a package will “Go-Live” (or be released).
    • The Faspex background process(s) will “release” packages marked with a “Go-Live” date once that date is encountered.
    • Faspex notifications are sent to package recipients once the “Go-Live” date hits
  • Enhanced REST API’s
    • A new set of Faspex API’s have been created to streamline all aspects of managing, sending, and downloading Faspex packages.
    • Focused around the concept of “packages” from the ground up.
    • Considerable attention to detail has been given to support REST best-practices.
    • All REST API payload and result data now uses a JSON format – No more XML
    • Native language bindings for Java, Objective-C, and .NET (coming soon) have been created, greatly simplifying all aspects of package lifecycle.
    • New Faspex API’s have been created to allow for remote Node browsing – This feature leverages the Aspera Node API but performs the browse operations based on the authenticated Faspex user


Some examples of the new Faspex 4 API’s are listed below. Although the payload is not included in the examples below, note that all payload and results returned are in JSON format:

  • Create Packages
    • POST /api/(users|dropboxes)/{user_id|dropbox_id}/packages
  • Update Packages
    • PUT /api/(users|dropboxes)/{user_id|dropbox_id}/packages/{package_delivery_id}
  • Delete Packages
    • DELETE /api/(users|dropboxes)/{user_id|dropbox_id}/packages/{package_delivery_id}
  • Retrieve a Packages
    • GET /api/(users|dropboxes)/{user_id|dropbox_id}/packages/{package_delivery_id}
  • Package Search
    • GET /api/(users|dropboxes)/{user_id|dropbox_id}/packages
  • Upload/Update Package Contents
    • POST /api/(users|dropboxes)/{user_id|dropbox_id}}/packages/{package_delivery_id}/transfer_specs
  • Transfer History and Search
    • GET /api/(users|dropboxes)/{user_id|dropbox_id}/packages/{package_delivery_id}/transfers
  • Remote Content Upload
    • POST /api/(users|dropboxes)/{user_id|dropbox_id}/packages/{package_delivery_id}/transfers
  • View Package Contents
    • POST /api/users/{user_id}/packages/{package_delivery_id}/files
  • Get Global and Active Metadata Profiles
    • GET /api/metadata_schemas
  • Users
    • GET, POST (create), PUT (update), DELETE (deactivate) /api/users
  • Get All Nodes
    • GET /api/nodes
  • Get Shares for a Nodes
    • GET /api/nodes/node_id/shares


“Aspera's flexible APIs allowed us to quickly complete the system integration and roll out the new service.” Sifei He, Cloud Product Director at BGI