Nautilus - Card Integration Accelerator

Nautilus is a system designed for the rapid development of card issuing wallets. It expedites the integration of payment cards into a wallet, featuring a payment processor-independent data feed, transaction simulator, and test engine.


When building a card issuing digital wallet the most complex task is integrating with payment cards. This integration is achieved by connecting the wallet to interfaces exposed by a payment processor. There are two interfaces to connect to:

  • Card creation and control, and
  • Transaction data and processing.

While connecting to a payment processor API for card creation and management (including tasks like generating the card, retrieving its PIN, and modifying its status) is usually a quick and straightforward process, integrating with the transaction data feed is a more intricate task. This often extends over several months, presenting numerous challenges along the way.

Nautilus is our solution to this challenge. It is designed for startups developing their product from the ground up, as well as established issuers which are looking to further expand their operations or increase the quality and flexibility of their solution, and for independent suppliers and white label producers which are developing fintech products for external entities.

We offer our clients a quick, easy, cost-effective and comprehensive solution for integrating into the transaction data feed, irrespective of the payment processor. Nautilus provides all the tools needed to make card integration as frictionless as possible.

Nautilus acts as an intermediary service between the wallet system and the payment processor, converting transaction data from the payment processor into a more user-friendly format for the wallet system. Additionally, its back office enhances the capabilities of a payment processor with advanced transaction simulation and testing functionalities.

As an intermediary between the wallet system and the payment processor, Nautilus ensures that the data reaching the wallet maintains a consistent structure, regardless of a specific payment processor. This makes wallets that are integrated with Nautilus independent from payment processors, allowing them to easily work with multiple different payment processors simultaneously, or to migrate from one payment processor to another seamlessly and without any downtime.

The advantages of Nautilus become particularly obvious during the development phase. In production, transaction data is generated by the actions of cardholders. However, in the development stage, where no live cards are issued, and thus no transaction data is received, Nautilus offers a variety of transaction simulators that can replicate cardholder actions, such as purchases or credits. However, the card control API is typically accessible in the payment processor's test environment, even though it doesn't manage any real cards.

The lack of transaction data during development makes working on transaction processing in the wallet system extremely challenging. Transaction data is not only complex, but developers also lack the means to test and verify the proper functioning of their work in compliance with regulations and rules. In production, even a minor error in processing transactions can become exceedingly costly, especially considering the large number of issued cards.

As Nautilus serves as the source of transaction data for the wallet and features a built-in card transaction simulator, clients using Nautilus for wallet development gain access to transaction data in a manner equivalent to production.

Using one of the many transaction simulators in Nautilus, it is possible to execute any real-life transaction scenario. It is also possible to simulate many corner cases (which you cannot trigger in real life, but you still face in large numbers when you have a system with many cards). Besides the simulator, Nautilus has a built-in test engine that can be used for automatic test execution and for monitoring wallet’s balance keeping calculations.

Nautilus can be used completely without a payment processor during development making it an ideal product for wallet companies hesitant to choose a payment processor or the companies that need to minimize expenses. Nautilus’ simulator and test engine can be used while developing the main logic of your wallet and your product (because that is where the main complexity is located), while simply stubbing all the card control operations. Once the rest of the product is developed, you can choose the payment processor and implement the card control operations (which is simple enough and does not take much time).

One Stop Solution

Nautilus contains everything you need to quickly integrate payment cards transaction data into your digital wallet. It packs together a payment processor-independent transaction data feed, and all the tools needed to quickly, and more importantly, reliably integrate the transaction feed into the wallet. Additionally, Nautilus offers testing tools to enhance the quality of your wallet by enabling testing of scenarios that were previously impossible to assess. Among other things, Nautilus includes:

  • Transaction simulator, which can execute many different types of card transactions,
  • Test engine, able to execute many test transactions automatically while monitoring wallet’s responses,
  • Transaction browser, for inspecting transaction data in real-time,
  • Reports, useful to monitor the wallet’s performance in production and to use as a model for building the wallet’s reports.

The Transaction simulator can be used both as a development tool to check how the wallet handles certain transactions, and as a tool to demonstrate the full product without any real cards or real money, since the data coming from the transaction simulator is completely equivalent to the data coming from any real-world transaction source.

How to use Nautilus

Nautilus is delivered as a service, and it is managed by our team on our servers. You can control the behavior of Nautilus and the transaction data feed for receiving transaction data by using Nautilus back-office, and your systems (wallet and other) can use Nautilus API.

Once you sign up for Nautilus, we create a dedicated subdomain for your company on our servers; we set up a dedicated Nautilus instance for you and we create an account for your main user (admin). This user has access to the back office and can manage additional users for your company. The number of active users depends on your subscription (you can have more users, but the number of active users depends on your subscription plan).

Upon acquiring Nautilus, you'll be provided with dedicated URLs and credentials to execute Nautilus API calls. These calls, essential for registering cards and managing currency setups for card products (which roughly correspond to BINs), should be integrated into your system. Your system should invoke these API calls whenever a new card is ordered or when the BIN setup undergoes changes.

To receive transaction data from Nautilus, you need to implement the interface prescribed by Nautilus. This interface consists of around 20 endpoints, which sounds like a lot but is quite straightforward. We will provide samples in the programming language you are using to help you complete this step faster.

Once you have access to the back office and you have implemented Nautilus API and transaction data feed, you can use Nautilus to drive the development of your wallet.

Transaction Data Abstraction Layer

Nautilus functions as an intermediary between the card processor and the card issuer. It receives data from the processor, transforms it, and then forwards the transformed data to the issuer. The key advantage is that Nautilus's output data format is independent of any connected payment processor, essentially serving as a transaction data abstraction layer.

Nautilus simplifies transaction data, offering a structured format compared to traditional payment processor data. Moreover, Nautilus exports data to multiple endpoints instead of just one, accelerating integration significantly. (even if we ignore the fact that Nautilus comes with the tools that payment processors lack).

Since the output data format does not depend on any payment processor, it means that Nautilus can be used during development even without any payment processor, allowing for a quick start of the development process.

Decoupling from Payment Processors

Nautilus transforms transaction data from a payment processor-specific format into a payment processor-independent format, eliminating the dependency of wallets on a specific payment processor. This consolidates transaction data into one well-defined component within the wallet, rather than scattering it throughout the wallet.

Isolating transaction data from the main wallet programming makes the wallet independent of payment processors. This independence facilitates easy expansion, territorial moves, and the ability to work with additional payment processors or switch seamlessly from one payment processor to another without downtime.

Transaction Simulator and Test Engine

The built-in transaction simulator allows you to create multiple virtual shops, ATMs, or online stores in different countries, each accepting different currencies (Nautilus fully supports DCC). This enables the generation of transactions for debugging and verifying the wallet's behavior without the need for real cards or money, ensuring thorough testing even before going live.

The internal test engine can automatically generate transactions based on saved scenarios. This feature is particularly useful for quickly generating numerous transactions, either to automatically test the wallet's behavior (e.g., in regression testing) or to assess the wallet's performance in handling transactions in parallel (stress testing).