What is CI/CD Sync?

CI/CD Sync is a groundbreaking feature within Document360’s API documentation that enables teams to synchronize their API documentation with their CI/CD pipelines effortlessly. By integrating your CI/CD tools directly into Document360, you can now automate the process of updating and maintaining your API documentation, ensuring that it remains up to date with your latest code changes. This seamless synchronization empowers your team to work more efficiently, reduce manual errors, and improve overall development productivity.

Stay Agile, Stay Updated: Automate API Documentation with Seamless CI/CD Integration

Introducing d360, our latest command-line tool designed to revolutionize the way developers manage API documentation. Seamlessly integrated with CI/CD pipelines, d360 enables developers to effortlessly import or resync their API definitions, automating the documentation process. Say goodbye to outdated documentation and welcome a future where your API documentation is always up-to-date and perfectly aligned with your API code.

Please follow these clear instructions to harness the full potential of d360 and experience the smooth integration that drives unparalleled efficiency.

Access the API documentation module within the Document360 knowledge base portal. Click on the ‘New’ button and proceed to create a new API. Choose the ‘CI/CD’ flow as your designated source of API reference.

Leverage the d360 npm package to seamlessly upload or synchronize your API documentation.

Harness the power of our command-line tool, ‘d360’, to establish streamlined workflows that effortlessly synchronize your API documentation with Document360. Please keep in mind that the API key generated below is exclusively valid for the specific project.

Launch the Node.js application on your Windows PC or laptop. Install the d360 npm package by executing the command ‘npm install d360 -g’.

Once the d360 package installation completes, you will see the Node.js command prompt window appearing as depicted below:

Copy the command provided in the Document360 knowledge base portal and paste it into the Node.js command prompt for execution.

Note:

• • Kindly exclude the command ‘npm install d360 -g &&’ when executing the above command. As this method utilizes the ‘file URL,’ it is imperative to provide the precise URL of the OpenAPI specification file.
  • If the file is stored locally, please substitute the file path URL with the actual location of the file on your machine.
  • In the case of the file being hosted on your GitHub repository, kindly provide the raw URL of the JSON or YAML file.
  • For performing a resync, employ the command ‘d360 apidocs: resync’.

Key Benefits

Real-Time Documentation Updates

With CI/CD Sync, your API documentation automatically reflects the changes made in your codebase in real time. Gone are the days of manually updating your documentation after each code modification. This feature ensures that your developers and other stakeholders always have access to the most accurate and up-to-date documentation, eliminating confusion and reducing the risk of using outdated information.

Improved Collaboration

Effective collaboration is crucial for the success of any development project. CI/CD Sync facilitates smoother communication and collaboration between developers, technical writers, and other team members involved in the documentation process. Providing a shared platform for both code and documentation, fosters a better understanding of the system’s functionality, resulting in enhanced teamwork and streamlined workflows.

Time and Effort Savings

Manually updating API documentation can be a time-consuming and error-prone task. With CI/CD Sync, you can save valuable time and effort by automating this process. Every time your CI/CD pipeline runs, Document360’s integration automatically extracts the relevant information from your codebase and updates the corresponding API documentation. This automation not only eliminates the need for repetitive manual work but also reduces the chances of inconsistencies between the code and documentation.

Unleash the power of your product with comprehensive API Documentation!

As technology continues to evolve, APIs (Application Programming Interfaces) have become an essential part of modern software development. They allow different applications to communicate with each other, exchange data, and perform various tasks seamlessly.

With our latest product update, we are excited to introduce comprehensive API documentation that will help you get the most out of your product. Whether you are a developer or a business owner, our API documentation will provide you with all the information you need to integrate your product with other systems and platforms.

Our API documentation is designed to be user-friendly and easy to navigate. It includes detailed information on how to use each API, as well as examples and code snippets to help you get started quickly. You can also find information on authentication, error handling, and other important topics related to API integration.

 

By providing comprehensive API documentation, we aim to make it easier for you to leverage the power of your product and expand your reach. With our API documentation, you can seamlessly integrate your product with other systems, automate tasks, and streamline your workflows.

 

Never struggle with tags again: Introducing our AI-Powered tag recommender!

Tagging content is a necessary task for many content creators, but it can be time-consuming and sometimes challenging to produce the right tags. With our latest product update, we are excited to introduce an AI-powered tag recommender that will help you streamline your workflow and ensure that your content is properly tagged.

Our tag recommender uses advanced machine learning algorithms to analyze your content and suggest relevant tags based on its content, context, and keywords. This means that you can spend less time manually tagging your content and more time creating high-quality content that resonates with your audience.

AI tag recommender is designed to be user-friendly and easy to use. You can simply upload your content, and our AI-powered tool will analyze it and provide you with a list of recommended tags. You can choose to accept or reject these tags, or even add your own custom tags to further refine your content.

Test with confidence: Introducing the Document360 sandbox.

Our Sandbox provides a safe and isolated environment where you can test and experiment with new features without risking damage to your live site or data. This means that you can try out new ideas, integrations, or workflows without worrying about causing any disruptions to your live environment.

The Sandbox project comes with a 14-day trial period. Team accounts associated with a paid project can create the Sandbox project.

So, whether you are working on a new integration, feature, or customization, our Document360 Sandbox can help you develop and test with ease.

Protect your knowledge base from unauthorized access with X-Frame options.

As the internet evolves, the risk of unauthorized access to your website’s content is increasingly becoming a concern. One of the potential avenues for attackers is through embedding your website content, such as a Knowledge base, in an iframe on a malicious website.

To address this issue, X-Frame Options is a security feature that provides an additional layer of protection for your Knowledge base. When enabled, X-Frame Options prevents your website’s content from being displayed in an iframe on another website. This way, even if an attacker manages to embed your Knowledge base in a malicious website, the content will not be visible to the attacker’s users.

By preventing unauthorized access to your Knowledge base, X-Frame Options protects your customers’ sensitive data and ensures that your website is secure.

Boost your Knowledge base security with a content security policy (CSP)

In today’s digital landscape, security is more important than ever. That’s why we’re excited to announce the release of the Content Security Policy (CSP) for Document360. With CSP, you can easily manage and prevent external CSS, scripts, and frames from being embedded in your Knowledge Base, ensuring that only authorized content is displayed to your users.

CSP works by specifying the sources of content that are allowed to be loaded on your website. This allows you to prevent malicious content from being loaded, reducing the risk of cross-site scripting (XSS) attacks and other security vulnerabilities.

Overall, CSP is a powerful tool that can help you take your Knowledge Base security to the next level. With its easy-to-use interface and customizable settings, you can rest assured that your content is safe and secure from potential threats.

Many more enhancements and improvements

Single Sign-On – The split Enterprise SSO module provides more flexibility in configuration, which makes it easier for customers to configure SAML, OpenID, and JWT at the same time. This feature streamlines the login process and enhances security.

Team accounts idle timeout – You can now set the desired time duration in the Team account idle timeout section of SSO configuration. This feature helps to conserve resources and ensure that inactive accounts do not remain logged in.

Export performance analytics – The export to CSV option for Performance analytics data helps customers to analyze and export data more efficiently. This feature saves time and enhances the reporting capabilities of Document360.

Knowledge base assistant – The default language setting for the Knowledge base assistant improves the user experience for customers. This feature ensures that the assistant opens in the language of the customer’s browser, which reduces confusion and makes it easier to use.

URL mapping – The URL mapping feature allows customers to define the Knowledge base assistant behavior for URLs that do not have mapping configured. This feature enhances the user experience and helps customers find the information they need more easily.

Localization languages – The addition of new languages in the localization module enhances the accessibility of Document360 for customers in different regions. This feature makes it easier for customers to create and manage content in their preferred language.

Elements of REST API design

A REST API is built around three players:

1. Client-side

On the client side, we have already met some of the commands. Very few client-side developers will issue these commands directly. You might test them in a sandbox using cURL but more likely, you will use a program library. The most ubiquitous client-side programming environment is JavaScript: The fetch() call handles HTTP/HTTPS requests. There are associated routines for setting up and parsing JSON files. A good starting resource for this is MDN web docs – JavaScript.

Some API suppliers provide dedicated libraries for client-side developers that effectively encapsulate the HTTP REST API calls. That can work well for commercial-style APIs we all know. It may be less effective for B2B APIs that require or return vast quantities of data.

2. Server-side

What happens on the server side is the key to everything and there are no hard and fast rules. This is the “80% commonsense”. The server must supply information or solicit user responses using the REST API commands as the base of the user interface. A server-side developer can do a substantial amount of design and testing using a local Node.js installation. Node.js allows you to set up a server on your development machine (https://localhost:<port_number>) for development and testing. See Node.js as a starting point.

3. Resources

• • • Resources are entities that exist on the server, accessible through HTTP GET commands. Sometimes a resource is not a database object, but a backend procedure to be called that carries out the request with any client-supplied data.
    • A resource may be created by a POST command. It may duplicate an existing resource.
    • A PUT command will update an existing resource or create a new one if there is nothing to update
    • To update a resource (say a single field in a database) without replacing it, use the PATCH command
    • The DELETE command will delete a resource

Importance of good API design

1. The good

A good API design will attract users; a poor API design will put them off and make them look elsewhere. If your API is part of a commercial offering, then that translates into profit or loss.

2. The bad

At the technical level, there are further considerations: Your API may look great, be easy to use and have everything going for it – except that it is painfully slow. The slow performance will also put off users translating into a loss of revenue.

3. The Ugly

And what happens if all else is good but the server-side programming style is a “spaghetti code”? Bug corrections are difficult and updates become a nightmare. Poor server-side coding will result in increased maintenance costs.
There are many commercial offerings that assist with API design but again, there is no substitute for common sense.

API design best practices

Ensure that the API scales

The API must solve real-world challenges: Test it under load and with excessively long output.

Use an international design standard

The OpenAPI v3 spec is a good start. Look here, OpenAPI Specification and also here: Swagger Editor.

As simply as possible, but not any less

This is a style issue, but it can affect performance: When responding to a query, provide all the information required but no more. If you are required to provide three fields out of a large record, then a JSON file of all records containing those fields is overkill and even counterproductive. It will slow the response and may even cause a bottleneck situation. It may also lead to a buffer overflow on the client side.

Make use of REST

There are “devices” to bypass REST the most common being methods to maintain state. The most well-known are cookies. They have their place and most sites use them, typically to supply session user credentials for each request. Going outside the REST convention may even be a security risk.

Endpoint paths should be written with nouns rather than verbs

This endpoint, https://www.example.com/customers uses a noun – customers. The next kind of example, https://www.example.com/listingCustomers should be avoided. The only verbs in REST API are the GET, POST, PUT, PATCH, DELETE, etc commands.

Use HTTP methods for CRUD functions

The acronym CRUD stands for Create, READ, Update, and Delete. The corresponding HTTP methods should be used and not bypassed using “smart” programming tricks. You can access a remote database without going through HTTP; don’t it’s not platform agnostic.

Use with HTTP response status codes

The HTTP response status codes are documented here: HTTP response status codes.

HTTP response status codes indicate whether a specific HTTP request has been successfully completed. Responses are grouped into five classes:

1. 1. Informational responses (100 – 199)
   2. Successful responses (200 – 299)
   3. Redirection messages (300 – 399)
   4. Client error responses (400 – 499)
   5. Server error responses (500 – 599)

In many contexts, we will require a 200 response indicating success. 400 responses can often be corrected on the client side and the request resubmitted. 500 responses may require a ”Comeback later” action. An exception is 511, Network Authentication Required issued by a proxy controlling server access. It means that the client credentials were incorrect.

Add filtering, sorting, and pagination

In a GET query, all three are accomplished by adding parameters after the endpoint. There is no standard method and much depends on the backend developer. See REST API Design: Filtering, Sorting, and Pagination.

One interesting method of pagination is based on the following paradigm:

1. 1. With the GET query, supply a required page length in lines.
   2. The GET returns the first page of data and a special continuation URL, all in a JSON file.
   3. Do repeat GETs using the continuation URL until there is no further data.

Enforce security

Enforce the use of HTTPS for data transfer, rather than HTTP. This is a large topic well beyond the scope of a short blog. As a starting point, look here: Content Security Policy (CSP) here: Best practices for REST API security: Authentication and authorization, and here: REST API Security Essentials

From the last link, we have a quick checklist:

1. 1. 1. Keep it Simple. Secure an API/System – just how secure it needs to be.
      2. Always Use HTTPS. Always use SSL.
      3. Use Password Hash. Always encrypt passwords. Never send them in clear text.
      4. Never expose sensitive information on URLs. Usernames, passwords, session tokens, and API keys should not appear in the URL, as this can be captured in web server logs, which makes them easily exploitable.
      5. Consider OAuth for authorization.
      6. Consider Adding Timestamp in each request. Do it in a custom HTTP header.
         Input Parameter Validation. We mentioned this above. Reject the request if parameter validation fails.

Add Cache Data

Caching stores copies of frequently accessed data. Caching response data can

• • • Reduce bandwidth usage
    • Reduce response latency
    • Reduce load on servers
    • Temporarily hide network failures

GET requests are automatically cached. PUT and DELETE are not.
Caching can be controlled using cache control headers in a request. See a tutorial on caching here: Caching REST API Response.

API Versioning

Versioning is required for these scenarios:

• • • Bug correction
    • Adding new features
    • Full new release

A typical versioning scheme is based on a three-digit code:

<Major-Release>.<Minor-Release>.<Maintenance-Build-Level>

Bug correction must not make any changes to the API. It is transparent to the API user. It increments the Maintenance-Build-Level.

Adding new features may not change the existing API calls in any way. The API user is free to use them or not. The Minor-Release number is incremented.

A Major-Release may not necessarily be backward compatible. That requires that the previous release remain available at least during a known deprecation period.

All this leads to the issue of how the version number should be included in an API call so existing client code is not broken. Here is one approach to the subject: How to Version a REST API. Another succinct description is here: Four REST API Versioning Strategies.

Define the desired capability and how to obtain it while adhering to current standards

Usually, you would use the OpenAPI standard. You can use Swagger  to prototype the API following the standard. Here is our first exposure to the need to carry out the design and implementation iteratively with defined project milestones to assess progress. This is an important project management issue outside the scope of an informal blog.

Consider building good client-side implementations rather than just network access

This is basically the difference between using a client-side SDK (Software Development Kit) and a raw cURL command line request. Most of the client-side programming environments supply such SDKs as built-in libraries or packages. JavaScript fetch() API does it, although it needs a fair amount of “setup” for a call. There are several commercial offerings that package or replace the fetch call to make life easier for the developer. See, for example, 10 Best JavaScript HTTP Request Libraries.

Focus on use-cases

This is a documentation issue. Many CCMSs (including Document360) provide a three-way split window with a brief ToC on the left, documentation text in the middle, and sample code on the left, an option with a choice of developer language.
If possible, the sample code should provide non-trivial results.

Some api documentation tools provide a sandbox in which you can try real-life HTTP requests. Alternatively, the sandbox may have to be linked to the CCMS documentation tool.

Also Read: gRPC vs REST: What’s the difference?

Common API design mistakes

Here are some of the common API Design mistakes:

• • • • Don’t use an excessive number of endpoints. Instead, consider parameters like {some_spec}
      • Use the correct HTTP command (PUT, POST, UPDATE)
      • Validate input data on the client-side
      • Ensure that the API is scalable
      • Ensure that the API is secure (use HTTPS rather than HTTP)
      • Avoid polling for repeated requests. Use webhooks.
      • Use HTTP response codes with care and ensure that you have good error handling
      • Failure to maintain API documentation during development
      • Failure to meet heavy load: Response time

What is a FinTech API?

Let’s break it down. The Oxford dictionary defines FinTech as “computer programs and other technology used to support or enable banking and financial services.” An API is an abbreviation for Application Programming Interface. APIs define the rules software components follow to interact and communicate programmatically. FinTech APIs are a specific type of API that allows businesses to integrate banking and financial services components into applications.

You have likely interacted with a FinTech API without knowing it. For example, if you have ordered takeout, the app you used to place an order likely (almost certainly) used a payment processing API to validate and process your payment. Another example could be a personal finance application that uses an Open Banking API to retrieve your account balances and analyze your expenses.

What are BaaS and open banking?

FinTech is closely related to another concept, Banking as a Service, or the BaaS model. In the BaaS model, a BaaS platform exposes APIs for FinTech businesses, digital banks, or third-party providers to access the information they need to integrate financial components into their applications. The third party pays the platform a fee in exchange for access to data and functionality. This practice is known as Open Banking.

After subscribing to a BaaS platform, a FinTech business builds new functionality “on top” of an existing financial institution’s platform. New functionality includes new banking products or financial data aggregation from many accounts.

FinTech APIs allow financial institutions to make their data available without revealing how their internal systems operate. A benefit to subscribers is their third-party applications can leverage the financial institution’s existing security and compliance standards.

The types of FinTech APIs

There is a broad range of financial services. And so, many FinTech APIs are available. The most common FinTech API types are financial data providers/aggregators, payment processors, investment brokers, regulatory tech (RegTech), and KYC (Know Your Consumer) APIs.

Financial data providers and aggregator APIs

These APIs provide financial data to third-party applications, including accounts and transactions, customer profile data, and account statements.

Think of data providers as traditional banks. Traditional banks only allow you to access data for that bank. Almost all banks have APIs, including Citibank, Discover, Wells Fargo, and Synchrony.

Data aggregator APIs, on the other hand, are more flexible because they allow access to data from many banks. Aggregators let developers combine personal banking, investment, and debt management into the same interface. One of the top financial data aggregators is Plaid.

Since financial data providers are limited to one bank, they have fewer use cases than non-bank aggregators. However, data providers (traditional banks) are known for their robust security.

Payment processor APIs

Payment processing APIs are among the fastest-growing types of FinTech APIs. A payment API allows applications to connect to a payment platform to validate and process payment transactions. You can use these APIs to create an interface with a payment solution without needing to create one. Examples of payment processor APIs include Stripe, Square, Paypal, and Adyen.

A key reason businesses use payment processors to process their transactions is security. They can build applications that piggyback off an existing payment platform’s infrastructure for authentication and fraud detection. Businesses use payment APIs because, without them, they would need to properly store and secure cardholder data to protect them from breaches. Payment technology requires PCI compliance (​​Payment Card Industry Data Security Standard) and maintenance of PCI security standards over time. And, not to mention, payment processors offer tokenization and P2PE (point-to-point) encryption.

Investment APIs

There are two primary types of investment APIs: brokerage and stock market APIs.

First, let’s discuss brokerage APIs. Traditionally, brokerages were walled gardens. There was no way for a third party to build off a brokerage’s infrastructure to access user data and create new functionality. Investment brokers are financial institutions that expose their data to third-party applications through APIs. Brokerages allow applications to use APIs to buy and sell securities on behalf of users. Examples of brokerage companies offering APIs are Interactive Brokers and Binance.

The next type of investment API is the stock market API. This type of API does not offer the ability to buy and sell securities. Instead, it focuses on providing rich stock data to users so they can make informed investment decisions. Examples include Yahoo Finance, Alpha Vantage, and Quotient. CoinAPI offers market data for the cryptocurrency space.

RegTech APIs

Regulatory technology, referred to as RegTech, is a technology aimed at helping businesses maintain regulatory compliance. Before RegTech, analyzing and synthesizing regulatory documentation into actionable obligations was a manual process. RegTech is seeing massive growth due to increased regulations, particularly in the financial sector, which kickstarted after the 2008 financial crisis as governments attempted to regain the public’s trust. RegTech is an attempt to help businesses deal with the burden of compliance.

In the past, compliance workers needed to sift through regulatory documents from many separate regulatory agencies to monitor updates that may affect compliance. Documents included regulatory websites, press releases, and RSS feeds for each regulatory website. Compliance workers needed to synthesize the data into an actionable plan to meet new regulations.

Developers can use RegTech APIs to build interfaces that only display relevant regulatory information to the user. Not only does RegTech allow you to collect regulatory information, but it turns data into actionable compliance obligations. Artificial Intelligence (AI) is central to this capability and is at the heart of RegTech. A prominent RegTech platform built around AI is Ascent.

KYC (Know Your Customer) APIs

According to Swift, a leading provider of financial messaging services, “Know Your Customer (KYC) standards are designed to protect financial institutions against fraud, corruption, money laundering, and terrorist financing.”

Businesses use KYC APIs to verify the identity of users, monitor user activities, and verify payment sources to prevent fraud and corruption. Features include analyzing digital footprints, verifying documents, and performing anti-money laundering checks. Some APIs, like those offered by Onfido, offer verification using biometrics, video, and e-signatures.

Also Read: What is Open API? Advantages, Disadvantages & Examples

Advantages of using FinTech APIs

Reduced cost and increased development speed

FinTech APIs reduce development costs and increase development speed because you no longer need to build financial components like payment gateways into applications. Instead, you can access a BaaS platform’s data and functionality through an API. Development speed is also faster because you do not need to debug services offered by BaaS platforms.

Improved customer experience

API developers can use FinTech APIs to improve the customer experience by focusing on the core features that make their applications unique. Instead of reinventing the wheel, they can build functionality on top of an existing BaaS platform to provide personalized experiences to users.

Also, check out our article on how to create an enchanting API developer experience with documentation

Leverage security infrastructure

FinTech APIs allow developers to leverage a BaaS platform’s existing security infrastructure. In the realm of payment processor APIs, for example, you can leverage authentication, fraud detection, cardholder data storage, PCI compliance, and P2PE encryption.

Automate compliance

RegTech APIs allow you to automate compliance. They can analyze regulatory information from multiple sources to produce actionable obligations specific to your business.

Prevent fraud

KYC “Know Your Customer” APIs specialize in verifying the identity of users to protect financial institutions from fraud and other illegal activities. In addition, they verify payment sources and ID documents.

The Best FinTech Platforms by Use Case

Financial Data Providers and Aggregator APIs

• Plaid API – Best for Connecting Multiple Accounts

The Plaid API is a financial data aggregator that allows you to connect accounts from multiple financial institutions into one interface.

Plaid‘s API lets you analyze users’ financial data and perform tasks like identity verification and accessing financial transactions and account balances.

As an aggregator, Plaid allows you to gain insights and spot patterns in a user’s preferences and behavior. Using this data, you can create personalized experiences to market, sell and support the user more effectively. A bonus is that Plaid, like other aggregators, provides authentication for all accounts accessed through the platform.

• Citibank API – Best bank-specific provider

The Citibank API is a financial data provider, not an aggregator. As a provider, Citibank only supports transactions related to that bank. Citibank is a good choice if you only need to access Citibank customers’ data.

The Citibank API allows you to access a user’s accounts and transactions, profile data, and retrieve customer statements.

Payment Processor Platforms

• Stripe – Best for eCommerce

According to the Forbes article “The 11 Biggest Fintech Companies In America 2019”, the payment processor Stripe is the largest FinTech in the United States and is worth 22.5 billion USD. Stripe focuses on eCommerce and POS transactions to a lesser extent. Stripe is both a payment processor and a payment gateway.

Stripe is known for its excellent developer resources, including thorough documentation, use cases, and code tutorials. Stripe supports credit and debit card transactions, Google Pay, Apple Pay, account routing by currency, ACH, and invoicing.

One disadvantage (for some) is that Stripe requires you to use their payment gateway, unlike some more flexible payment gateway providers.

• Square – Best full-service payment platform

Square‘s features make it suited for both eCommerce and brick-and-mortar businesses. If you need to support brick-and-mortar, you may choose Square over Stripe.

Square offers a host of APIs to access different functionalities within Square’s platform. Even though the platform is large and complex, you can find the APIs you need by using their API explorer to filter by component.

Square has more features than Stripe and is considered a “full service” payment platform. In addition to processing card transactions, Square supports loyalty programs, marketing, loans, inventory management, and more.

Investment Platforms

• Interactive Brokers – Best full-service brokerage

Interactive Brokers is a full-service investment platform that allows you to access market data and execute stock buys and sells on behalf of users through its API. If you are looking for a platform with the full capabilities of a brokerage, then Interactive Brokers is a good choice.

Interactive Brokers has two primary APIs, the Client Portal API and Trader Workstation (TWS) API. The Client Portal API allows you to trade, monitor and manage a user’s IBKR account on their behalf. The Trader Workstation (TWS) API lets you automate trading strategies, access market data, monitor accounts, and view portfolio performance.

Using Interactive Brokers APIs, you can build trading applications and software, access securities data, and use the IB SmartRoutingSM to locate the best stock, option, and combination prices at the time of trading.

• Polygon Stock API – Best rich stock data

Unlike Interactive Brokers, Polygon Stock API is a stock market API, not a full-service brokerage. This API is a good choice if you only need high-quality stock data without needing to buy and sell securities.

Some of Polygon’s key advantages are low latency data APIs and nanosecond timestamp data. Polygon has low latency because its data centers are connected to NASDAQ, BATS, NYSE, IEX, and other exchanges. Polygon advertises that it can bring institutional-level data not accessible by most retail traders due to its connection to the top stock exchanges.

Unlike many stock data providers, Polygon timestamps data down to the nanosecond. Many other providers have millisecond timestamping. Timestamping on this scale allows for more granularity when analyzing historical performance.

• CoinAPI – Best for cryptocurrency market data

CoinAPI is a notable mention as a market data provider for cryptocurrency markets.

RegTech and KYC

• Ascent – Best for regulatory compliance automation

Ascent‘s goal is to automate the compliance lifecycle for its clients with the help of artificial intelligence (AI). Ascent is a good choice if you want to leverage AI to generate actionable compliance obligations.

Ascent helps you monitor regulatory changes by analyzing regulatory information relevant to your business. It then synthesizes the information into actionable obligations for your business to execute. Ascent allows you to integrate its data insights into your existing GRC tools or workflows. You can then manage your compliance lifecycle in your GRC tool and map Ascent’s data to policies, controls, and procedures.

• Onfido – Best ID Verification Platform

Onfido is a verification platform that can run KYC (Know Your Customer), AML (Anti-money laundering), and anti-fraud checks to ensure compliance with the latest regulations.

One of Onfido’s features is its database of over 2,500 ID document types from the majority of countries in the world.

Onfido supports video verification, biometrics, and AI that can accept or reject applications.

Also Read: Internal vs. External APIs – Does it Matter?

Unify your API Documentation and Knowledge Base

Document360 is an enterprise-level documentation tool specifically designed to meet the unique needs of FinTech businesses. This revolutionary platform transforms how you generate API documentation, providing a unified solution that seamlessly integrates your knowledge base and API documentation.

Document360 simplifies your documentation workflow by providing a comprehensive platform that combines API documentation and knowledge base capabilities. This integration eliminates the need for separate tools, allowing your technical writers to efficiently manage both aspects within a single platform.

By utilizing Document360, you not only enhance the experience for your users but also reduce their cognitive load. The consistent user interface across the knowledge base site and API documentation site ensures a seamless and familiar experience, enabling users to navigate effortlessly between resources. Say goodbye to the frustration of learning different interfaces and embrace the simplicity of a unified platform.

Furthermore, Document360 eliminates the overhead associated with procuring and customizing multiple tools for API documentation and knowledge base. Technical writers no longer need to invest extra effort in customizing the homepage and aligning the look and feel of separate sites with your brand guidelines. With Document360, these customization tasks are performed only once, saving time and resources.

Streamline Support

By leveraging Document360, you can adopt a user-centric approach to documentation that directly addresses the challenges faced by FinTech businesses. With this solution, you’ll experience a significant reduction in customer support tickets, enabling you to merge your API documentation with a comprehensive self-service portal of product knowledge. This cohesive environment streamlines the support process, empowering users to find the information they need quickly and efficiently.

Context-sensitive Help

A notable feature is the “context-sensitive” HELP functionality, which provides users with relevant support articles based on their location within your website or product. This innovative approach eliminates the need to navigate to separate pages, ensuring a seamless and intuitive experience that minimizes disruptions.

Traditional approaches, such as adding a knowledge base widget without contextual help, introduce friction and hinder the user’s ability to find assistance within the application. Additionally, when help content opens in a separate tab, it can create a disjointed user experience.

In contrast, Document360 addresses these concerns by providing contextual help directly within the product. Users no longer need to leave the application to seek assistance. This integration ensures a smoother workflow and enhances user satisfaction by delivering timely and targeted support without unnecessary distractions.

Harness User Insights

Document360 empowers you to gather valuable analytics data, providing deep insights into user behavior. Understanding where users struggle to find answers allows you to proactively address their concerns, reducing support tickets and enhancing customer satisfaction. The analytics data collected from user interactions within the Document360 knowledge portal enables you to refine your support process and ensure optimal user experiences continuously.

Key Features

Some key features of Document360 for FinTech Businesses:

• Seamless Swagger/OpenAPI Integration: Effortlessly incorporate API references using OpenAPI V2 and V3 specifications. Document360 intelligently reads and fetches precise details from your existing OpenAPI files, ensuring accuracy and consistency important to FinTech.
• File URL Import: Simplify API documentation creation by directly entering the URL of your hosted OpenAPI Specification (OAS) file. Document360 supports seamless import from Git Repositories, making it convenient to keep your documentation up-to-date and secure.
• Enhanced Search Functionality: Enable developers to swiftly locate endpoints, reference documentation, and schemas with Document360’s powerful search feature. This streamlined search capability ensures FinTech businesses can quickly find the information they need, boosting productivity and efficiency.
• Comprehensive API Reference: Experience a user-friendly interface that allows developers to experiment with API calls directly within Document360. Gain real-time information, including error codes and header details, tailored to the intricacies of the FinTech ecosystem.
• Interactive “Try It” Functionality: Provide an immersive experience for your users by enabling them to execute requests right from their browsers. Document360’s “Try It” feature allows users to visualize responses from your API, promoting seamless integration and development.
• Manual Editor for API Reference: Create visually stunning and interactive API reference sections using Document360’s intuitive manual editor. Customize the layout to present information in a captivating and easily understandable format specific to FinTech use cases.
• Instant Code Sample Generation: Simplify developer workflows by offering real-time code sample generation. Document360 empowers developers with instant code examples tailored to the intricacies of the FinTech industry, saving valuable time and effort.
• Resync Functionality: Keep your API documentation consistently updated with Document360’s effortless resync feature. Seamlessly synchronize changes made to your API, ensuring that your documentation accurately reflects the latest updates in the ever-evolving FinTech landscape.
• Log Tracking: Gain complete visibility into the recorded steps of your API with Document360’s comprehensive chronological log feature. Track details such as source type, date, and status to effectively monitor and analyze the usage of your FinTech.

With these industry-specific features, Document360 equips your FinTech business with the tools to create robust, user-friendly, and compliant API documentation. Drive collaboration, accelerate adoption, and stay ahead of the competition with Document360’s cutting-edge documentation solution.

What is the significance of a DevPortal?

So, why should a company invest time and money into enhancing its DevPortal? A good developer portal conveys the value of a platform and its services. It describes how it solves specific business challenges without using marketing/advertising hyperbole.

While API documentation is often associated with developer portals, a DevPortal is not just a place where developers access their API reference documentation. The DevPortal should allow all business stakeholders (technical or non-technical) to learn about and experience a platform.

In the next section, we will explore these characteristics.

What makes a good DevPortal?

The following are characteristics of an effective DevPortal.

Unifies solutions

While API documentation is an important aspect of a DevPortal, it is not the be-all and end-all. Developer portals ideally act as a central resource for all interfaces to a company’s products and services. They may not be limited to just APIs / services. Other interfaces include GUIs, no-code interfaces, and low-code interfaces like widgets for users without access to developer resources.

While REST APIs are a focus of developer portals, other kinds of APIs can be documented such as Internet of Things (IoT) APIs, voice assistant APIs, GraphQL APIs, or native library APIs. Oftentimes a company will have a range of services, not just a REST API. It is possible to see dozens of APIs of different types documented on a DevPortal. Other technical solutions made available on DevPortals besides APIs are client libraries or SDKs. Sometimes a DevPortal can also showcase solutions built by developers

Also Read: REST vs. SOAP: What is the difference?

Clear business model

The user should be able to understand the platform industry and a broad overview of the services it offers. Solutions should be categorized by area or specific business challenges they solve. The user should be able to develop a mental map of all solutions on offer and how they fit together in a unified platform.

How services relate to each other in the bigger context can be communicated through text, visual graphics, or the structure of the developer portal itself.

Up-front pricing

The customer should understand a platform’s pricing model very early on. The pricing structure should communicate how it solves particular problems and the differences between the pricing plans.

The DevPortal should answer questions like:

• How are the API products monetized (direct vs. indirect)?
• What are the differences between the available pricing plans? Are there plans for pay-as-you-go, self-service, or freemium?
• Are they any rate limiting restriction per pricing plan?

Pricing plans relate to the onboarding process because users are often allowed a limited number of features before they must pay. Transparent pricing facilitates the transition from a potential customer to an actual customer.

Content “layering”

Layered architecture is a concept borrowed from software development that can be applied to content organization.

Here is an example of how a DevPortal can be layered:

• The top layer of a developer portal would be the landing page the user understands the business model, an overview of services/solutions offered, and common use cases.
• The middle layer would be the solution categories that group solutions according to the business challenges they solve.
• The bottom layer would be the documentation for those solutions, including any getting-started tutorials and API references.

Of course, these are only examples. Other layers may be necessary depending on the business.

A layered architecture allows for consistency across solutions. The user learns what information to expect from each section.

Similar to the main landing page, each solution should have its landing page that communicates the value of the solution. A solution page provides quick access to the solution overview, use cases, onboarding details, getting started, and technical reference material.

Using a layered architecture that separates the different components of the platform allows for extensive use of linking. You can link to technical sections from business sections, and vice versa. For example, a business analyst that reads solution overviews may only want to view business information while also having the ability to learn more by clicking a link to the technical documentation. Linking also allows developers to jump to technical details rather than being stuck reading business material.

Consistent design

Design elements, when done correctly, go beyond aesthetics. Design elements promote usability and go together with the quality of the content. A well-designed developer portal has design elements that support the user journey as they discover, learn about, and interact with a platform.

An effective design reinforces the overall brand. A brand not only determines the aesthetic choice but also how the content is written. Documentation should be written using the same style and tone with consistency across all solutions.

Findability

How easily the user can discover the solution to their business challenge is the primary aim of a DevPortal. The process of finding information on a DevPortal should be frictionless.

The “findability” of information in the developer portal is determined by its structure and search/filtering capabilities. DevPortals should structure their documentation portals so users can easily see the range of solutions available. It should be easy to filter solutions by category to narrow down the list of possibilities and remove noise.

From within the API reference, you should be able to search and filter by resources, endpoints, parameters, and schemas.

Caters to non-technical users

SaaS companies also understand there are different ways to consume a technical product besides building an app that leverages a service from the ground up. For example, a platform may provide widgets you can easily add to your website with minimal coding. No-code or low-code solutions break down the barriers to who can experience the value of the technical product.

The best DevPortals have onboarding journeys for each competency level. For example, a technical user can build an app from scratch whereas a non-technical user can download a template to begin experimenting with.

Onboarding

The onboarding process is usually a user’s first experience using a solution. If there is friction in the onboarding process, a prospective customer may give up before fully demoing the API. After setting up your account and retrieving credentials, the Get Started section walks the user through an end-to-end process of interacting with the solution, such as an API.

API Reference

An API reference is a concise and detailed guide read by developers to understand an API. Effective API reference pages allow developers to quickly locate information for resources, endpoints, fields, or schemas using a combination of searching and filtering.

A try-it-out feature provides a hands-on way of interacting with an API. The most advanced DevPortals automatically populate try-it-out widgets with a user’s credentials based on their account details.

Community

Community is often first-level support for troubleshooting issues. Many dev portals have community pages. Some companies use tools like Discord channels or public Slack channels to host discussions under different categories.

If a user can find an answer by posting a question to a message board, they do not need to contact support. If a company is involved in the community, it can log the issue as either a bug or documentation improvement.

Communities can go beyond just discussion forums. They can lead to small meetings or large conferences that promote a platform.

Updates

Regularly posting updates as a platform evolves is a signal for reliability and trustworthiness. Release notes, statutes, and changelogs are all examples of supplemental documentation that keep the user informed of the latest changes.

DevPortal Best Practices

There are many steps to building a DevPortal before any line of code is written. Assuming the business model is solid, developer experience (DX) design should be conducted to align all aspects of the portal to provide the best experience to users.

Clarify business model

The structure of the DevPortal should reflect the structure of the business and its solutions. The user will be lost if a DevPortal does not communicate the business structure well.

Keeping the portal up-to-date requires collaboration across the organization and will not succeed by relying on one team. All teams are responsible for keeping their domain up-to-date and responsive to feedback.

Conduct Developer Experience (DX) design

Developer portals are closely related to the concept of Developer experience (DX). Unlike normal User Experience design, DX is tailored to developers who use technical products often without a GUI like APIs, client libraries, or SDKs. Since there are no user interfaces, documentation must tell the developer how to interface with the product. Documentation to a large extent plays an important role in how a developer or other business stakeholder “experiences” a technical product.

In the same way, companies hire UX designers, they should hire DX designers to craft the experience of developers using the DevPortal. A DX “strategist” is a central role to manage the lifecycle of the developer portal. The DX strategist oversees changes to processes, standards, and tooling that flow out to individual solutions teams. This strategist ensures the design, aesthetics, structure, and content work together to create a pleasing experience for the developer.

The strategist creates the personas of the people visiting the portal and crafts user journeys to meet their needs. For example, there would ideally be separate onboarding user journeys for technical users and non-technical users.

Structure the portal

When establishing the information architecture, you must determine which information is required across all solutions. For example, each solution requires onboarding, use cases, and API reference in a particular order. If documentation is uniform across solutions, the DevPortal user knows what to expect.

A layered architecture, coupled with linking, will make navigating from the top layer (business details) to the bottom layer (technical details) easier, and vice versa.

Establish governance program

Many times, each solution is managed by a separate team. To provide a consistent experience across the portal, standards must be established that promote the consistent organization of content and writing guidelines.

Establishing a governance program requires collaboration to develop standards as well as buy-in from the separate business units to fully complete the program. Each team should be responsible for adhering to these standards and held accountable. A governance program should align language and tone, style and formatting, and organization of content from business material to API reference. Finally, a governance program should reinforce branding.

Reduce the learning curve through onboarding

After communicating the value of the business as a whole, the user should be immediately guided toward separate solution pages where they can try out APIs, services, client libraries, or SDKs. The front and center of these pages should be a link to onboarding procedures so they can experience the product as soon as possible.

For the Get Started tutorial, pick a simple use case that the user can follow to understand the solution from start to finish.

Properly document API reference

Are all the API components accurately documented? Is each resource documented? Are individual endpoints and schemas described fully? Does every field description state its purpose, the effect of chosen values, and interactions with other fields in the system? Are definitions for the same field standard across the spec? The content of the API reference should follow an API style guide that determines standards for all components of the API. Following a style guide ensures consistent and complete documentation across the API reference. Without accurate and detailed reference information, all the flashy features are useless.

Documenting technical reference information is often the first step to improving overall documentation because the technical information must be solid before writing tutorials.

Configure search / filtering

A DevPortal can have dozens of pages corresponding to separate solutions. Along with a clear site structure, having a robust search can improve discoverability so the user can find the solution that solves their particular business issue.

There should be an API Explorer where the user should be able to search and filter a list of solutions offered.

It is important to have a robust search in API reference docs. The search bar on an API reference should allow for a granular search of all components making up the API.

Establish community

From early on, you should think of ways to foster and grow a community around your business’s solutions. This is both a long-term strategy for support and also for the adoption of your products.

Other subtler forms of community are asking developers to sign up for newsletters that keep the communication line open.

Initiate a feedback loop

There should be many opportunities on a DevPortal for a user to provide feedback. For example, each API reference section provides a rating mechanism with the option to provide free-form feedback.

Another source of feedback is community. A community actively using a product that posts is a source of feedback without even having to ask for it.

Provide case studies and references

Case studies are convincing when they are coupled with testimonials of clients that use the product. Case studies can be common business challenges and how they are solved using a platform. A user may relate to a case study and immediately see how they can use the tool to solve a problem they are facing or to accomplish a certain task.

Also, check out our blog on API documentation checklist

Regularly post updates and statuses

Regularly posting updates as a platform evolves is a signal for reliability and trustworthiness.

Also Read: What is Open API? Advantages, Disadvantages & Examples

Best DevPortals

The following are the best DevPortals by category.

Best API Reference: Stripe

Stripe is a payments processing platform with a well-designed and intuitive API reference.

API reference docs must allow developers to locate the information they need quickly amongst the sea of technical details.

Stripe is a one-page website that allows you to quickly navigate to different sections either by clicking the left nav links, scrolling down the page, or performing a search.

Some of Stripe’s API reference features include:

• Collapsible content – Almost all content is collapsible, including field descriptions, tables, schemas, etc. This way you can focus on the information you need without excess clutter.
• Switchable programming languages – You can change the programming language of code samples globally with one button. In addition, you can also easily copy code samples by clicking a copy-to-clipboard button.
• Developer-friendly dark mode – This is a great feature for developers who prefer a dark background that looks like a code editor.
• Extensive Linking – Whenever an in-depth explanation is required, the API reference provides a link to the conceptual documentation for background information and tutorials.
• Multiple feedback points – You can provide feedback for each section, including writing free-form text after giving a rating.
• Advanced search and filtering – Stripe’s advanced search lets you field on almost all components of OpenAPI.

Best findability: Visa

The Visa Developer Platform lets you leverage the power of the Visa network using APIs.

What makes this platform stand out is how easy it is to filter the available APIs and services to find the one you need. From their Product Browser, you can filter the list of APIs by several categories. Filtering allows you to quickly locate the APIs that solve your particular business challenge.

In the filtered list, each API “card” contains a short description of the service, followed by links to the Overview or Docs pages for the API. The Overview contains general business information, whereas Docs contain the API reference. You can then locate the documentation you need quickly based on whether you need to onboard or wish to view technical references.

In addition, you can locate use cases that apply to your situation from the Use Cases page with testimonials and case studies.

Also Read: Internal vs. External APIs – Does it Matter?

Best coding tutorials: Fiserv

Fiserv’s developer portal shines when it comes to step-by-step examples of how to implement Fiserv’s APIs.

“Recipes” are tutorials for different use cases with code samples in various languages. Each recipe walks you through the process of completing a specific task, and each step in the process has annotations that provide more context.

The recipes shine when accessed from within the main documentation. The main documentation links to specific recipes whenever a step-by-step guide is necessary. This integration of code samples within documentation makes Fiserv’s platform very use-case driven.

Best for non-technical users: platformOS

platformOS is a development “platform as a service” that emphasizes performance, reliability, flexibility, security, and scalability with many use cases.

platformOS is one of the most accessible platforms because it caters to users of all technical levels. It classifies 3 different types of users: non-technical users, semi-technical users, and technical users. Each user type has its onboarding journey.

• Non-technical users can click 1-click install to register an account and follow an easy setup wizard that creates a demo blog site.
• Semi-technical users can click the Sandbox link to clone a demo site from GitHub. They can then follow the Hello, World! guide to understanding the basics for sending requests and reading responses.
• Technical users can dive right in by clicking Build your first App to create an app using the platformOS platform. They can follow the documentation to set up their dev environment and then deploy and test their app.

platformOS allows non-technical users to experience the platform while providing a fast route for technical users to build an app from the ground up.