Common Challenges of Building Multiple API Integrations
January 24, 2024
0 min read
Building SaaS integrations doesn’t have to feel intimidating; but let’s face it, it usually does. Many factors—from complex APIs to poor documentation—can make it tough for product teams to scale integrations.
In this article, we'll cover common obstacles SaaS companies face while building multiple API integrations and how to overcome them.
But before we delve into that, let's first discuss what API integrations are and use an example to understand why they can be more complex than you think. (You can skip to the next section to jump quickly into the list of challenges.)
The complexity of multiple API integrations
APIs, or application programming interfaces, enable two applications to connect and seamlessly exchange data. APIs allow these systems to specify how requests are made and data is shared. The convenience of API integrations makes them a popular choice for SaaS developers.
However convenient, APIs are far from simple. Their complexity makes building and maintaining multiple API integrations challenging for engineering teams.
To understand this better, let's consider the HR and payroll integrations landscape.
The need for multiple integrations in HR
Today, an average HR tech stack has seven or more employment systems of record, including human resource information systems (HRIS), payroll software, benefits administration platforms, performance management tools, and so on.
The efficiency of HR processes depends on how effectively these tools communicate with each other. As a result, employers are increasingly prioritizing product integrations as a critical criterion before investing in any SaaS product to add to their HR tech stack.
Therefore, if you are a developer, product manager, or owner of a SaaS tool in the employment tech space, your ability to remain competitive and close more deals depends on your ability to offer seamless integrations across multiple HR and payroll systems.
The difficulty of API integrations
As of 2023, the U.S. has nearly 6,000+ HR and payroll providers. Many of these providers do not have public APIs. And the ones that do have hundreds of variations in their APIs, data formats, documentation, and integration protocols.
Understanding different HRIS or payroll APIs and then planning, building, testing, and implementing dozens or hundreds of integrations can take months or even years and cost millions of dollars—not to mention the ongoing maintenance required for all the connections.
These complexities apply to API integrations across all software categories, not just HR. In the next section, we’lldiscuss in depth what makes scaling API integrations a challenge for SaaS builders.
Note: Meanwhile, if you are building multiple HRIS and payroll integrations, you should check out Finch's unified employment API. With Finch, you can unlock access to data from 200+ HR and payroll providers using just one integration. Learn more.
Common challenges of building and maintaining multiple API integrations
Building API integrations is a complicated endeavor for several reasons. The primary challenges developers face are:
Diversity and complexity of the API ecosystem
Data mapping and consistency errors
Security and compliance issues
Integration partnership challenges
Third-party API updates
Integration maintenance problems
Complex API Ecosystem
Developers find it increasingly difficult to build integrations with a diverse set of APIs for several reasons, such as negotiating lengthy partnership contracts, testing integrations across multiple environments, the cost and complexity of scaling product integrations, and much more. Let’s examine these issues in detail.
While APIs make it easier to connect two systems, the diversity of API providers and integration procedures makes it a nightmare for developers to build multiple API integrations.
Each API provider has different systems built into the API. They may use different technologies, error-handling mechanisms, or rate-limiting protocols and can also have unique data formats—making it further challenging to facilitate seamless communication between them.
Gated APIs and integration partnership challenges
Not all APIs are open for anyone to use—gated APIs require partnership agreements to access
their API keys, documentation, and sandbox environments. The companies that enter these agreements have to undergo security checks, lengthy negotiation processes, and, in some cases, pay additional fees—rendering partnership agreements extremely time and resource-intensive.
Some providers even require a minimum customer count before entering a partnership agreement, posing additional challenges for resource-limited startups that need product integrations to grow their customer base.
Testing across multiple environments
Building API integrations in-house means ensuring each integration runs as intended and is reliable. Testing is crucial to check the stability of each integration and whether it can handle varying data loads under different use cases.
The problem with API testing is twofold:
First, every API provider may not offer testing environments to build against, requiring developers to figure out how to test in production with real customer data.
Second, testing integration against a provider system requires a thorough understanding of how that system behaves, how it defines data, and so on. It requires specific knowledge and expertise that may not be available to a typical SaaS product/engineering team. It can take weeks for a developer to understand the nuances of API testing for a specific provider.
Neither of these options allows SaaS product teams to move quickly.
It’s important to remember that all of the challenges we’ve mentioned apply to every API integration, and most SaaS companies need to integrate with dozens of systems in their space. Scaling your company’s integration catalog is a challenge. Here’s why:
First, building multiple SaaS integrations is time-consuming and resource-heavy. Developers must decode each API, understand documentation and data schemas, write custom codes, and test and implement the integration. Building just one integration—from planning to implementation—can take a few weeks to a month and thousands of dollars. If you have 20, 30, or a hundred integrations to build quickly, it’s definitely not a viable option.
Second, developers’ work is not finished once the integration is implemented; they then need to spend their valuable time maintaining these integrations and optimizing their performance.
Third, integrations are not a core product feature for most SaaS tools, yet integration with customers' existing tech stack is essential to remain competitive and reduce churn. Building dozens of integrations can take valuable time from the engineering team, which could be spent enhancing your core product. Developers often deprioritize integration-related tasks to work on core products or vice versa. Neither benefits the bottom line.
The complexity of diverse APIs also poses to data mapping and consistency for integration builders.
Data mapping and normalization
Normalizing data from multiple systems of record is not an easy task. Here’s why:
First, different providers store data in different formats. They may provide the same information but return it under fields with different names in varying formats.
Second, some providers may not offer the data developers need in a simple format. For example, they may not pre-calculate the values that are required. It forces the developer to collect and calculate values themselves—adding to the complexity of the API integration process and elongating the timeline for completion.
Third, different systems may use different types of APIs. Some providers use SOAP APIs instead of the more common REST APIs. As a result, developers spend more time learning how to integrate in new ways they may not have experience with. This delays integration shipping time even further.
Developers can save hundreds of hours when provided with data in a standardized format. This abstracts away the additional complexity of mapping data in different formats from different systems of record each time a sync happens.
Data consistency and accuracy
Ensuring data quality and integrity is crucial to avoid compliance and security issues as well as to minimize errors in data processing. Data quality in API integration is measured by its accuracy, timeliness, and consistency across multiple systems.
Considering the complexity of data mapping, it is clear that maintaining data quality while building multiple API integrations is a challenge for SaaS product teams.
Establishing clear data standards and validation checks is essential to address this challenge. Also, using a tool to normalize data can bring the dual benefit of ensuring data accuracy and standardization.
For instance, Finch acts as a single source of truth for HR and payroll data, regardless of where the data comes from. As a unified API, Finch normalizes hundreds of variations in employment data into a standard format. Thus, making it easier for developers to read updates and write changes into the employers' primary HR tool—while maintaining data accuracy and completeness.
Security issues in API integrations
Security challenges in API integration include unauthorized access, denial-of-service (DoS) attacks and excessive data exposure.
Data security and compliance
Every organization, regardless of its size, is wary of safeguarding and sharing its data. This is especially true for sectors dealing with sensitive information such as financial data, employment data, or health records.
While it may be manageable to establish and monitor security standards for one or two integrations, it’s nearly impossible to continuously monitor security health for a dozen or more integrations without dedicated resources.
Another solution is to use dedicated integration solutions like unified APIs or iPaaS that are compliant with global standards for security practices like CCPA, SOC2, GDPR, ISO27001, HIPAA, and so on.
Authentication issues (401 unauthorized errors)
Another security issue in API integrations is broken authentication or broken function-level authorization. Authentication errors return an HTTP error code 401.
Complications can also arise from different authentication mechanisms like OAuth, API keys, and access tokens used by different API providers. Developers must familiarize themselves with multiple authentication protocols and implement custom processes for each API integration they build.
For example, if you are building multiple HRIS or payroll API integrations, you must carefully build and manage authentication and authorization. Any unauthorized access or erroneous permissions can lead to disastrous consequences for your end users—employers and employees.
To account for this, Finch's unified employment API not only supports different authentication protocols but also makes it easy for end users to authorize access control. With Finch Connect, employers can select their choice of HRIS and payroll providers and authorize permissions in less than 30 seconds. Learn more about Finch's security practices here.
Challenges of keeping up with third-party APIs
Two of the most common struggles for developers building multiple third-party API integrations are inadequate or incomplete documentation and backward incompatibility.
Documentation discrepancies in API integration are multifold. For example:
Some providers do not make their documentation publicly available, restricting it to approved partners only.
The documentation may not be clear and concise, requiring developers to spend more time finding necessary information. Sometimes, the API documentation may not be available in your preferred language.
Documentation may not be updated with the latest API versioning changes.
API versioning and backward compatibility
APIs are not static—they’re updated over time. API version changes can break the existing integrations or lead to broken endpoints and consistency issues. Therefore, it’s crucial to ensure each API integration has backward compatibility—in other words, they continue to perform even when a new version of the API has been released.
In our experience, developers often find it difficult to contact the API providers when a documentation page returns an HTTP 404 page not found error or a versioning change returns HTTP 301 error code.
To effectively manage API versioning, developers need to create flexible codes for the integrations that can adapt to API version updates and remain functional. They also need to have communication and support plans in place with API providers to stay updated about version changes and preemptively adjust integrations.
Note: Finch makes handling third-party API integrations easier for HR integration developers. For instance:
Finch maintains up-to-date, standardized documentation across providers. It helps developers save themselves the time and effort of dealing with varying quality API documentation by different providers.
Finch adjusts for API version updates for all the integrations on its end, so your developers don’t need to keep tabs on the status of multiple APIs. Check out our developer documentation for more details.
Integration maintenance challenges
Maintaining dozens of integration maintenance indefinitely is a monumental task. You need to constantly monitor the health of each integration for performance issues, error resolution, and rate limits. Let’s examine these issues in detail.
Rate limiting (HTTP 429 error) and throttling
API providers sometimes impose API rate limits and throttling to control the number of API calls, prevent over-usage, and maintain integration stability. This returns an HTTP 429 error code.
To avoid being rate-limited, developers must monitor API usage carefully or use webhooks to receive notifications instead of polling the API connection excessively. Adjusting for rate limits is doable for a few integrations but adds to the complexity of scaling.
API monitoring and error handling
Building integrations is only one part of the equation. Another hurdle is maintaining them for optimum performance on an ongoing basis. Integration performance depends on the time it takes to sync data, the accuracy of the data synced, frequency of errors, and the time it takes to resolve them.
Ensuring reliable integration performance is tricky. API integrations can fail, break, or malfunction for several reasons, such as incorrect parameters, server errors, and network issues. It can also fail due to third-party provider issues such as API versioning or any incident or outages that impact their APIs.
As a result, developers need to continuously monitor these integrations individually. Diagnosing and solving integration performance issues also requires knowledge of the specific API and its nuances. Monitoring individual integration can be difficult, especially when you have dozens of integrations running simultaneously and a relatively small engineering team.
Given that poor integration performance is one of the leading causes of SaaS customer churn, SaaS companies must identify errors on time and promptly resolve them.
For this reason, SaaS builders are increasingly opting for unified APIs like Finch as a go-to solution for scaling customer-facing integrations. Unified APIs allow developers to build and maintain one integration and unlock access to data from hundreds of applications. It’s always easier to deal with one API integration than the nuances of dozens of APIs.
If you are building three or more HR and payroll integrations, consider checking out Finch unified employment API. Connecting with Finch can unlock integrations with 200+ HRIS and payroll providers—covering 88% of the U.S. employer market.
Throughout this article, we have discussed how Finch solves the common challenges in API integration. With more than five million API calls every day and tens of thousands of employer connections, Finch is the trusted HRIS and payroll API solution for several B2B applications.
Introducing Real-time Status Updates with Finch Webhooks
November 20, 2023
0 min read
We're excited to share that Finch now supports real-time webhooks for all customers on our scale plan. Finch Webhooks help you monitor connections and sync jobs, and notify you when data has changed. This helps you keep your applications up to date with the freshest employment data available.
What webhooks does Finch offer?
Finch offers 3 types of webhooks, account update events, job completion events, and data change events.
Account update events contain information about account connections, such as when a connection has been established or needs to be refreshed. Use these webhooks to determine when a new connection is fully set up and ready to begin syncing data.
Job completion events fire when a data sync job finishes running, whether the final state is a success or an error. Use these webhooks to trigger workflows or notify customers when a sync has completed.
Data change events fire when data from a connection has been created, updated, or deleted — after the initial data sync has been completed. You can subscribe for updates on all data, or just for specific endpoints. You can find a demo of data change event webhooks here.
Set up secure, scalable webhooks in our Dashboard
We designed Finch Webhooks to empower our developers to build seamless and secure applications. With webhooks, there’s no need to make repeat data requests to find out what data has changed. Easily configure webhooks in the Dashboard, and start receiving notifications in real time.
Check out the demo below to learn how to set up your first webhook.
Easy setup To set up a new webhook, simply register an endpoint in the Dashboard, and use our documentation to understand the structure of each event type.
Real-time notifications Webhooks make it easier to get notified of updates instantly. Once you’ve set up your webhooks, you’re ready to receive updates in real time.
Scalable and secure As your business grows, so do your needs. Fortunately, Finch webhooks are built to scale—so whether you're handling ten employer connections or ten thousand, performance will remain consistent and reliable. Our webhooks are also signed by Finch so you can verify that the data you're receiving is coming from us.
Request Forwarding enables Finch developers to make direct requests to employment systems, and access any functionality that is natively supported by a provider’s API. Even those outside of the scope of our standardized data models.
With Request Forwarding, you get the benefits of direct integrations with employment systems like Bob, Personio, Gusto, UKG Pro, and more. Data is requested and returned in the provider’s native format, giving you greater flexibility to access unique data in these systems. This also means you can exercise any functionality, read or write, that is supported by their public APIs.
How it Works
Standard Finch API Request
Each of Finch’s 200+ integrations is built to our standardized data model. This data model helps unify the information coming in from each employment system so that developers aren’t required to manage nuances between providers.
When a developer sends a standard request to the Finch API, it goes through two key steps before reaching the data: data transformation and authentication. The data transformation process converts the request from our standardized data model to that of the system where data is stored. The authentication step then confirms that the employer has the correct permissions to access the data requested. Once the data is retrieved, it then moves back through the transformation layer to be returned in the expected format. This whole process ensures developers get a consistent request and response structure to work with, regardless of the system you’re extracting data from.
Finch Request Forwarding
Now, developers have the option to bypass the data transformation step and retrieve data in the original format of the provider. With the raw data exposed by an integration, the data mapping is completely in your control.
Finch enables this by leveraging an employer’s existing secure connection with the provider that was established via Finch Connect, forwards the request to the provider, and then forwards the provider’s response back to your application.
Abacum unlocks new value with Request Forwarding
Abacum, an automated FP&A tool that helps finance teams with revenue forecasting, headcount planning, and OPEX breakdowns uses Request Forwarding to gather expanded data sets from their customers' systems of record. "The ability to perform deep, nuanced analyses on HR and payroll data unlocks a higher level of value for our customers, " said Barbara, Senior Product Manager at Abacum. "Strong performing integrations is one of our main competitive advantages, and we can maintain a great level with Request Forwarding."
“The ability to perform deep, nuanced analyses on HR and payroll data unlocks a higher level of value for our customers. Strong performing integrations is one of Abacum's main competitive advantages, and we can maintain a great level with Request Forwarding."
Ultimately, Request Forwarding gives our developers complete control over the data that matters to them, without building and maintaining one-off integrations. In order to make a request to one of these providers’ public API endpoints, you’ll just need to use our new /forwardendpoint.
Request Forwarding is available now for all customers on a Scale plan. Check out our documentation for a complete list of supported providers, and details on how to get started.
3 trends driving fragmentation in the SMB payroll market
To best serve their SMB customers, technology-first companies are looking to leverage the power of payroll and HR data—but with nearly 6K payroll systems on the market, that can mean building out many tedious integrations. Fortunately, there’s a better way.
Most notable is the seismic shift in focus from productivity to people as employers look to recruit and retain talent amid the Great Resignation, strengthen their work culture and benefits, and foster better relationships with their employees. For innovative companies serving SMBs, meeting these needs requires careful analysis and considerable support from the data tied up in SMBs’ payroll systems.
Unfortunately, comprehensive payroll data is getting harder and harder to access. There are almost 6,000 payroll providers in the U.S. alone, and recent trends are causing that number to grow.
For SMB-focused companies to keep up, they need to understand what the current payroll market looks like, which factors are driving diversification, and how using APIs that span multiple systems can help them access more data, build smarter and faster solutions for SMB customers, and ultimately boost their business. In this post, we break it all down.
A heavily fragmented market
The latest data indicates there are approximately 5,700 payroll providers in the U.S., with a combined annual revenue of around $48 billion.
The top three payroll providers—Intuit Quickbooks, ADP Run, and Paycheck Flex—cover almost half (45%) of SMB employers nationwide. But extending to the top 10 only increases that coverage to 55%. For comparison, the top 10 accounting systems collectively cover 95% of the SMB market.
What’s more, beyond the top three, all other payroll providers each have less than 4% of the total market share, with coverage quickly tapering off. A number of these are newer platforms—like Gusto, Zenefits, and Rippling—that have appeared over the last decade to satisfy evolving SMB needs and a growing demand for self-serve products with transparent pricing.
That means we can expect the industry to grow even more fractured in the coming years, as innovators continue to emerge and respond to changing market conditions.
In particular, there are three trends to watch that are spurring fragmentation in the U.S. payroll market. Let’s take a closer look at each.
1. SMBs typically pick a payroll provider based on their demographics.
A business’s payroll system plays a critical role in its operations, and switching platforms comes at a high cost—so picking the right provider is essential. Still, SMBs often select a payroll provider based solely on demographics, including factors like:
Number of employees: As an organization grows, it encounters a broader and more complex range of compliance requirements and payroll schedules.
Industry: Different industries hire different types of workers (e.g., seasonal, temp, salaried, hourly, apprentice, and interns), each with its own HR workflows.
Only secondarily will SMBs look to the core capabilities and key features of the platform itself—such as options for customization, time tracking, benefits, insurance, and customer support. That means SMBs may not look for the best provider overall, but the best fit for their business.
2. World events are reshaping SMB purchasing decisions.
External circumstances—above all, the lingering effects of the pandemic—also impact how SMBs think about payroll and the support they need from their payroll providers.
Some of the most pressing considerations include:
The competitive labor market, which has made it difficult for SMB employers to attract and keep high-performing employees. Some providers offer a suite of recruiting and retention tools like pay analytics and talent sourcing services to help hire in a tough environment.
Hybrid work models, which are becoming common, especially in white-collar industries where being on-site is less essential to productivity. Some payroll providers offer a range of remote workforce management solutions to onboard and oversee dispersed employees.
New regulations that are emerging to protect employee and contractor rights and bolster workplace safety requirements. Some payroll providers build compliance tools into their platforms, so employers can easily adapt to new rules and avoid hefty penalties.
Industries that have their own regulatory bodies and in-person staffing needs—like food service, hospitality, construction, and agriculture—are particularly vulnerable to shifting conditions and face an even more complex decision when choosing a provider to accom modate them.
3. White-labeled and embedded solutions are powering new, tech-forward platforms.
White-labeled and embedded solutions allow other companies to build payroll capabilities into their existing systems—essentially enabling any platform to become a payroll provider.
White-labeled platforms like iSolved and PrismHR allow HR systems, service bureaus, and professional employment organizations (PEOs) to keep their current branding and service models while providing the underlying infrastructure to power a range of human capital management (HCM) solutions.
Embedded payroll platforms—such as Gusto, Check, Zeal, and Salsa—use an API to embed a payroll application into an existing product. While still nascent, this market has the potential to expand across vertical SaaS, the gig economy, HR tech, and fintech.
As this technology advances, it’s becoming easier for new companies to add payroll to their list of services and capabilities—and harder for a single provider to win a market majority.
The problem with payroll fragmentation
Market fragmentation means businesses serving SMBs have to integrate and coordinate with multiple payroll providers to cover a sufficient swath of their customers. It’s hard enough to build and maintain an integration with one platform—let alone hundreds or thousands.
Integrating with the top one, three, or ten payroll providers might allow a company to cover half of their customer base. But to efficiently serve the other half—or tap into new regions and industries—would require many incremental builds, draining time and resources.
To tackle this coverage issue, many fintechs, benefits platforms, and other B2B companies are turning to digital solutions that take a more comprehensive approach to payroll data and roll hundreds of payroll integrations into a single platform. That’s where Finch comes in.
How Finch can help
Finch’s universal API connects to an extensive network of payroll systems, and we are continually adding new integrations. Right now, we have compatibility with over 150 systems, and that number is always growing.
That means, with Finch, product teams designing solutions for SMBs don’t have to worry about building any integrations in house or reconciling inconsistent data outputs from different systems—they get secure, standardized, and effortlessly scalable access to the fragmented payroll market right out of the box.
Build vs. Buy: Leveraging Employment Data Via HRIS and Payroll Integrations
July 27, 2022
0 min read
We’re excited to announce our latest whitepaper, Build vs. Buy to address the question:
Should I build employment integrations in-house or outsource them?
If you’re asking yourself this question, you already know that data connectivity has the power to transform every industry in the world—and few businesses are in the dark when it comes to understanding the importance of breaking down the data silos currently impeding their productivity and innovation. In turn, B2B applications are hurrying to bridge the chasms between the systems in their customers’ tech stack. Their goal? To create superior user experiences and unlock automation and insights that set them apart from their competitors.
Increasingly, the basis of those bridges is API integrations, and one of the most important datasets to access is housed in employment systems like HRIS and payroll. Determining how to approach employment system integrations is a critical decision for any business, and different business scenarios dictate different considerations as you explore your integration options.
Maybe you’re at one of the following stages:
Launch — You are starting from ground zero and need to decide whether to buy or build in the first place.
Scale — You already built a few key integrations in-house and are trying to determine if outsourcing remaining integrations and their maintenance would be a more prudent next move.
Status Quo — You already have an adequate data sync solution, fueled by a flat-file feed and hodgepodge of APIs, that meets your basic needs and are wondering why you should entertain the idea of outsourcing integrations at all. Or perhaps you even recognize that digital transformation is ultimately necessary but wonder if it’s an initiative you can keep internal.
In Finch’s latest whitepaper, Build vs. Buy we explore all of the considerations at each stage and more to help you arrive at the best integration approach for your B2B application.
Team up with Finch
Finch does the hard work of integrating with HRIS and payroll providers to facilitate the secure, permissioned flow of critical business data. Our dynamic, unified API offers read-and-write access and abstracts away inconsistencies across systems for optimal usability no matter the source.
Finch is quickly becoming the API of choice for employment system integrations because we are:
Developer-friendly: We focus on developers and empower them to create world-class solutions.
Reliable: Our API does the best job of interacting with and maintaining connectivity with employment systems.
Secure: Finch is a pass-through system, and is SOC2 Type 2, CCPA, and GDPR compliant.
Efficient: Finch connects you with 150+ HRIS and payroll systems through one API, 4x more than any other platform.
Enterprise-ready: Our technology is built for large-scale synchronization with thousands of employers.
Reach out to our team to explore ways to access employment data with our unified API by contacting us here.
We’re excited to announce the beta launch of our new unified ATS API! Applicant tracking systems (ATS) capture the candidate lifecycle, starting at the first email interaction all the way through the offer process. The new API supports the candidate, applications, jobs, and offers data models.
Today we’re going live with our first ATS integration, Lever, a platform trusted by 5,000+ employers around the world, with additional integrations planned in the near future. The ATS API launch is one of many steps towards Finch’s ultimate goal to power talent and employment innovation via an open ecosystem.
ATS houses the process and insights into an organization’s recruiting pipeline. For applications that help organizations find, hire, and close candidates, having seamless access to the data housed in ATS is core to delivering a high-impact product experience. Over the last several months, our customers have repeatedly requested access to ATS integrations as they look to expand their products to encompass the candidate lifecycle.
Finch’s ATS API provides a comprehensive view of the entire recruiting funnel broken down into four data models:
Candidates — Gather basic candidate information like name and contact information.
Applications — Get more detailed information about the applications a candidate has, such as the position they are applying to and the current stage of the application process.
Jobs — Pull all of the job posting details an employer manages, including the associated departments and applications.
Offers — View current and past offers initiated and managed through the ATS.
Unlock high-impact use cases
HRIS, Payroll, and ATS platforms capture a large portion of the employee lifecycle and are core sources of truth for people and talent teams. ATS data access unlocks deep insights into the hiring process and the upcoming changes to a growing organization.
We’re excited to support a wide range of use cases across the following categories, and more:
Compensation management platforms can pull jobs and offers data to provide hiring managers and talent members key insights into compensation expectations.
Candidate sourcing products that focus on driving top-of-funnel volume can track candidates through various phases of the interview process to calibrate the relevance of sourced leads.
DEI solutions that help employers build more diverse and inclusive teams can capture candidate data to identify biases in the hiring process.
Background check providers can track candidates at the final stage and initiate checks as soon as an offer is issued.
Job boards can automatically post new jobs as they’re created and track candidates that apply through the entire process.
ATS can also be paired with Finch’s HRIS and Payroll API to track a candidate’s progression through the interview process and trajectory within the company once they start. Best of all, it’s now all available under Finch’s unified API for employment data.
SFTP vs API: Which integration method is best for employment data?
November 9, 2022
0 min read
In our latest whitepaper, we explore SFTP vs API integrations and discuss which is right for your business.
It’s no secret that data connectivity has changed the way businesses operate. It seems that every week, there is a new app that plugs into the systems businesses use every day. These innovations have changed the game for users, making interoperability between systems a need-to-have. For software providers, flexible and plentiful integrations are more essential than ever.
Why Employment Data Transfer and Integration Methods Matter
Employee and HR data has traditionally been one of most challenging use cases for data transfer. Employment data, the bulk of which is usually stored in HRIS and payroll systems, must be handled carefully and securely in order to abide by compliance rules and regulations protecting the collection, storage, and usage of sensitive, personal data.
So what is considered employment data? Employment data is any information about a company and the individuals within it. More specifically information about the company itself (EIN, legal name, HQ address), the company org chart (employee count, managers, departments), or about individuals (preferred name, contact information, employment status, income and pay history, benefits data, etc.).
Businesses rely on employment data to manage their workforce effectively. It’s essential for them to keep this data up-to-date and organized throughout all of the systems they use each day. Any software providers that want to sell to businesses must think strategically about how to collect this employment data from various sources of truth in an organization. While the majority of this data is housed in HRIS and payroll systems, there are thousands of potential systems to consider. There is also no standard way of categorizing or sharing data between systems, which means the transfer of this data is usually (at least partially) manual.
B2B applications looking to leverage the power of this employment data often consider two integration approaches—SFTP vs API. While SFTP has been more ubiquitous historically, an increasing number of platforms are looking to APIs for their scalability, security, and speed.
SFTP vs API vs Integration: Which is Right for You?
SFTP and API are two possible methods of integration between systems. Before diving into the benefits of an SFTP integration vs an API integration, let’s quickly define each method.
What is SFTP?
In order to understand SFTP, you need to understand what FTP is. FTP stands for a file transfer protocol, which supports the transfer of files between a client and a server. SFTP, or Secure File Transfer Protocol, is a process that uses shell encryption to allow businesses to send and receive sensitive information such as employment data in confidence. SFTP emerged in 1997 as a way of transferring data between parties securely. It requires data to be updated manually (via flat file, CSV, JSON, etc.), encoded, then transmitted through a secure channel between two platforms. You receive an email notification when the file is ready to download.
Because an SFTP integration is convenient for processing many files quickly, it’s often used for bulk file transfers. It also allows businesses to send and receive a wide variety of files. SFTP integrations only need a single connection to initiate the file transfer, and an internet connection is unnecessary.
However, SFTP has its downsides. First, it relies on manual data entry, which must be constantly validated to avoid errors. This is a tedious process that wastes time and resources. Additionally, SFTP doesn’t allow for the transfer of data in real time. The moment a file is uploaded to the server, it is theoretically out of date. Depending on the use case, this can limit the usefulness of data sharing altogether. If accuracy, timeliness, and speed are essential, SFTP falls short.
What is an API ?
APIs, or Application Programming Interfaces, are ways for two applications to communicate with each other. APIs standardize a communication pathway between software to exchange data and other information regardless of the underlying programming languages they are built on. APIs make it easy to push and request data instantly, providing real-time visibility into data shared between systems. Once an API is implemented, there is no manual download, restructuring, or error checking that needs to be done. If implemented correctly, the data flows seamlessly between systems.
The Downsides of SFTP vs API Integrations
So why API vs SFTP for the transfer of data? We outline just a few reasons below. For the full explanation, make sure to download our whitepaper.
SFTPs and APIs both make it possible to transfer data between systems securely, however, APIs have a few key strengths over SFTP, especially when used to transfer employment data. Here are 3 reasons to consider API vs SFTP:
1. Improve data security
Even SFTP lacks security controls to handle today’s cyber threats. Recent research reveals that more than 400 million files from FTP servers are publicly available online, and the average cost per lost or stolen record is $146 USD. When files are exposed, SFTP does not log security violations or authenticate users – basic capabilities you need to help detect and stop breaches. Encryption is also an afterthought requiring extra steps and IT expertise, making it difficult, expensive and time-consuming to send files safely.
2. Gain real-time access to employment data
With APIs, you can get instant access to all the information you need. A live and continuous connection means that your application can constantly refresh the sync, meaning that you will always be working with the most recent version of your data. This way different teams within your company can collaborate effectively since they have access to the same set of information.
3. Improve the customer experience and reduce errors
One of the key downsides of SFTP is the need for employees to manage sensitive data manually. When downloading, updating, and re-uploading data files, there are many opportunities for errors to be introduced to the system. SFTP then allows crucial issues to perpetuate. When and if errors are found, they require several calls and emails with multiple parties to correct. This is not only frustrating for customers, it drains your HR administrators time and resources, and introduces errors that can wreak havoc on your systems.
Which Method is Best for You?
Download our SFTP vs API whitepaper for details on which method is best for you based on your unique business needs.
In it, you’ll find:
The differences between SFTP integrations and API integrations
Pros and cons of implementing each
Ideal scenarios for implementing SFTP integrations
Examples of innovative use cases powered by APIs
How Finch can help
If you’re interested in exploring an API integration for your application, Finch’s dynamic, unified API offers read-and-write access and abstracts away inconsistencies across systems for optimal usability no matter the source. We also handle routine maintenance, bug fixes, and the hard work of keeping up to date with the latest HRIS and payroll platforms, allowing your engineering team to focus on developing the differentiating features that set your application apart from the competition.
Finch is the API of choice for employment system integrations because we are:
Comprehensive: Finch integrates with over 200 employment systems (more than 4x the competition)
Developer-friendly: We focus on developers and empower them to create world-class solutions.
Reliable: The Finch API does the best job of interacting with and maintaining connectivity with employment systems.
Secure: Finch is a pass-through system, and is SOC2 Type 2, CCPA, and GDPR compliant.
Efficient: Finch connects you with 180+ HRIS and payroll systems through one API—4x more than any other platform.
Enterprise-ready: Our technology is built for large-scale synchronization with thousands of businesses.