Product

We’re pleased to announce the Finch API Explorer: a new interactive tool that allows developers to interact with our API endpoints directly from the Dashboard. This tool is especially important in the employment space, where testing different scenarios with pay and organization data is essential to a successful integration. 

What began as an internal tool to accelerate our own development operations has evolved into a powerful feature for our external developers. Keep reading to explore the benefits of the API Explorer in greater detail. 

Finch's API Explorer Features

1. Democratized API access

The API Explorer democratizes access to our API by removing traditional technical barriers. Team members across different roles can now make API requests directly from the developer Dashboard without the need for access tokens or using external tools like cURL or Postman:

• Non-engineering team members can validate data formats without developer assistance.
• Support teams can quickly reproduce and debug customer issues.
• Sales engineers can demonstrate API capabilities in real-time.
• Quality assurance teams can test various data scenarios efficiently.

Whether testing a deduction request or checking company data, any authorized user can interact with the API through an intuitive interface. This is particularly valuable for sandbox environments, where teams can easily test and validate their integration without additional setup.

2. Seamless authentication and access control

Our API Explorer is deeply integrated with the Finch developer Dashboard, eliminating the need for manual access token management. When developers log into the dashboard, they can immediately start making API calls — no additional authentication required. We've also implemented role-based access control, ensuring that only admin users can access the Explorer, providing an extra layer of security. Every request made through the Explorer is recorded in the activity tab, making it easy to track and audit API usage.

3. Real-time API specification sync

The Explorer is dynamically generated from our OpenAPI specification, ensuring it's always in sync with our latest API changes. When we add new endpoints, update parameters, or modify response schemas, these changes are immediately reflected in the Explorer. This automatic synchronization means developers always have access to the most current API interface without requiring any updates to their tooling.

4. User-friendly JSON builder

One of our key goals was to make API interaction accessible to developers of all technical levels. Our JSON builder translates the OpenAPI specification into an intuitive form interface:

• Field types and validations are automatically enforced based on the schema.
• Dropdown menus are populated with enumerated values from the spec.
• Complex nested objects and arrays can be built with simple clicks.
• Real-time validation ensures requests are properly formatted before sending.

Here's how the builder transforms complex JSON into an intuitive interface:

And here is the resulting code:

{
  "legal_name": "New legal name",
  "entity": {
    "type": "corporation",
    "subtype": "c_corporation"
  },
  "primary_email": "new@email.com",
  "primary_phone_number": "1234567890",
  "ein": "23456",
  "locations": [
    {
      "line1": "Line 1",
      "line2": "Line 2",
      "city": "City",
      "state": "State",
      "postal_code": "12345",
      "country": "US"
    }
  ],
  "accounts": [
    {
      "routing_number": "12345",
      "account_name": "12345",
      "institution_name": "12345",
      "account_type": "checking",
      "account_number": "2345"
    }
  ]
}

5. Context-aware operations

A unique feature of the API Explorer is its contextual awareness. When a sandbox app is selected in the developer Dashboard, the Explorer dynamically adds sandbox-specific endpoints to the list of operations, providing clarity and precision for developers.

Tackling technical challenges

Creating a robust API Explorer has its challenges. Here are some key areas where we had to innovate:

1. Parsing and understanding our OpenAPI specification

The first challenge was parsing our OpenAPI specification. While there are existing tools like @apidevtools/swagger-parser, we opted for a simpler, custom solution that gave us more control over the parsing process.

One key challenge was resolving $ref pointers in the OpenAPI spec. These references allow schema definitions to be reused across the specification, but they need to be resolved first. Here's our straightforward solution:

const resolveRef = (ref: string, spec?: OpenAPIV3.Document) => {
  const [, ...pathToSchema] = ref.split('/');
  return _.get(spec, pathToSchema, {});
};

This simple function handles resolution of references by following the path specified in the $ref pointer. The callers of this function also handle the recursive resolution of nested $ref pointers. While more complex solutions exist, this approach proved sufficient for our needs and kept our dependency footprint small.

2. Creating the JSON builder

The JSON Builder posed unique challenges, particularly in handling nested objects, arrays, and schema validations. Using React and react-hook-form, we developed a recursive component that dynamically renders form fields based on the schema. Here’s how it works:

• Dynamic Input Types: Adjusts inputs for strings, numbers, booleans, enums, and more
• Array Support: Adds or removes array elements dynamically
• Nested Object Handling: Renders subfields for complex objects
• Schema Switching: Allows toggling between multiple schema types when applicable

Here's a snippet of the JSON Builder implementation:

export const JsonBuilder = ({
  jsonSchemas,
  propertyKey,
  formPath,
  deleteField,
}: {
  jsonSchemas: JsonSchemaSelections;
  propertyKey?: string;
  formPath: string;
  deleteField?: () => void;
}) => {
  const { register } = useFormContext();
  const [schema, setSchema] = useState(jsonSchemas[0]);

  return (
    <FieldContainer
      propertyKey={propertyKey}
      formPath={formPath}
      deleteField={deleteField}
      setSchema={setSchema}
      selectedSchema={schema}
      schemas={jsonSchemas}
    >
      {schema.type === 'object' ? (
        <Stack>
          {Object.entries(schema.properties).map(([key, value]) => (
            <JsonBuilder
              key={key}
              jsonSchemas={value}
              propertyKey={key}
              formPath={`${formPath}.${key}`}
            />
          ))}
        </Stack>
      ) : schema.type === 'array' ? (
        <ArrayInput propertyKey={propertyKey} formPath={formPath} schema={schema} />
      ) : (
        <Input {...register(formPath)} />
      )}
    </FieldContainer>
  );
};

3. Request proxying and security

Security was a top priority when implementing the request proxy. Our approach includes:

1. Schema Validation: Each request is validated against the OpenAPI spec to ensure only valid operations are allowed.
2. Request Logging: All requests are logged alongside the authenticated user for audit purposes.
3. CORS Protection: The proxy endpoint only accepts requests from our developer dashboard domain, preventing unauthorized access from external sources.
4. Role-Based Access Control: Only users with admin role and appropriate permissions can make proxy requests, ensuring controlled access to API operations.

This multi-layered security approach ensures that the API Explorer remains both powerful and secure, giving access only to authorized users while maintaining a comprehensive audit trail of all operations.

4. Optimizing performance

We implemented several optimizations to ensure the API Explorer remains responsive:

• Lazy loading of operation details
• Memorization of resolved references
• Debounced validation for form inputs
• Progressive loading of large response data

Future enhancements

We're thrilled to see how developers will leverage the API Explorer feature to streamline their integration processes and explore the full capabilities of the Finch API.

Provider requests recording

The internal version of the API Explorer includes a powerful request recording feature, capturing all external requests made during the lifecycle of a Finch API call. This provides invaluable insights into how Finch interacts with various payroll and HRIS, making debugging and optimization much more efficient. We're exploring ways to make this feature generally available to all Finch users in the future.

Smarter field population

We're developing intelligent field pre-filling based on previous API calls. For example:

• Using the /employer/directory endpoint responses to populate individual ID dropdowns for /employer/individual, /employer/employment, and /employer/benefits/{benefit_id}/individuals endpoints
• Preserving frequently used field values across operations

UI refinements

We're continuously working to simplify the interface while maintaining its power:

• Collapsible sections for large request bodies
• Better visualization of nested array structures
• More intuitive handling of complex objects
• Improved error message displays with actionable fixes

Develop with Finch

Building the API Explorer has been a transformative journey for Finch, empowering both our internal teams and external developers to interact with our API seamlessly. By leveraging the OpenAPI spec and thoughtful design, we’ve created a tool that democratizes access to API development while maintaining high security and usability standards.

As we continue to refine the API Explorer, we look forward to making API integration even easier for our users. Stay tuned for updates!

Not a Finch developer yet? Contact our Sales team to learn how we can help you integrate with more than 200 HRIS and payroll systems, or try our API yourself.

We’re excited to announce new platform features focused on the Retirement sector, including a robust sponsor onboarding experience, universal compatibility for TPA and recordkeeping systems, and expanded data fields. These features will enable TPAs and recordkeepers to adopt Finch out of the box with their current workflow and systems without any engineering effort, allowing them to work more efficiently, eliminate administrative bottlenecks, and reduce overhead costs while focusing on delivering best-in-class service to plan sponsors.

‍

Recordkeepers and TPAs need reliable access to timely, accurate, and standardized employer data, but for decades, the primary means of collecting this information has been through SFTP connections or manual processes. Both methods are time-consuming, costly, and impossible to scale, and retirement providers feel the strain. A 2024 survey conducted by the SPARK Institute found that 93% of recordkeepers view payroll integrations as important, a view that’s supported by their survey data for the last 3 years.

Our platform offers an alternative. By bridging the gap between plan management platforms and sponsors’ payroll systems, recordkeepers and TPAs are able to securely, easily, and automatically access census and payroll data directly from the employer’s source of truth. 

Finch is the industry leader with the most extensive payroll provider network, covering 80% of U.S. employers. Our automated data refresh and 360° payroll integration capabilities streamline deduction management, while our secure, scalable API infrastructure meets SOC2 and HIPAA compliance standards — enabling recordkeepers and TPAs to confidently manage payroll data and expand effortlessly.

Our years of experience in the Retirement sector have shaped the features we built specifically for this industry. Finch is already used by more than 40 leading recordkeepers and TPAs, including Ameritas, ePlan (Paychex), Human Interest, and Betterment. Our platform serves 45,000+ employers and more than 5 million employees, establishing Finch as the trusted choice for seamless payroll connectivity.

Today, we’re excited to share that we’re taking the product a step further, introducing new features, including a more robust sponsor onboarding experience, direct support for TPA and recordkeeping systems, and expanded data fields that are critical to retirement plan management.

Enhanced sponsor onboarding experience

We’ve implemented new capabilities to our embedded employer onboarding experience, Finch Connect. Recordkeepers and TPAs can embed the Finch Connect workflow into their system or invite sponsors using a secure link. In minutes, plan sponsors can connect their payroll provider to send census and pay data to their retirement provider. 

Now, sponsors will also be able to use Finch Connect to map data like source codes and pay statement classifications to meet the specific needs of their retirement plans. Through our recently improved Dashboard, plan administrators can easily track the status of each connected sponsor and ensure data is flowing seamlessly.

Universal recordkeeping and TPA system support

With expanded support for leading recordkeeping and TPA systems, Finch is now compatible with PensionPro, ASC Retirement Plan Software, FIS Relius, and SS&C Technologies. Retirement providers using these systems can use Finch to automatically pull sponsor data directly into the platform.

We’ve also expanded our product offering to include custom Flat File support for any system, no development work required. Recordkeepers and TPAs can create a custom file format and have their sponsors’ data delivered by Finch in a CSV file to their SFTP location. Through Finch’s unified API, the data is standardized, meaning it is always delivered in the same format, regardless of the payroll system it came from. These files are automatically delivered with each pay run, ensuring recordkeepers and TPAs always have the most up-to-date data — even without building an API integration. 

Expanded field support

Finch now supports fields for Rehire Date and Pay Group or Division across payroll systems. This information, essential to retirement plan administration, is often difficult to access, leaving a critical data gap across most connectivity solutions. 

Rehire Date data allows recordkeepers and TPAs to accurately track employee tenure, ensuring plan participants are eligible and accurately vested, even with service breaks. With Pay Group data, contributions align seamlessly with each payroll cycle, supporting compliance and enhancing service quality. This empowers recordkeepers and TPAs to deliver more precise, compliant retirement management across diverse payroll platforms.

The future of connectivity in retirement

Our vision is to deliver complete data connectivity across all retirement systems and payroll providers so recordkeepers and TPAs are empowered to automate routine tasks and provide better service to their customers. To achieve this vision, we’ll focus on three core tenets as we continue to evolve our retirement product:

• Continued network expansion: We’ll continue to expand our integrations across HRIS and payroll providers and retirement software systems, including new direct integrations with major recordkeeping systems. Our goal is to power 100% of the connectivity any recordkeepers or TPA needs.
• Expanded 360° capabilities: We’re advancing support for custom flat files, allowing deductions to be written back across payroll providers without the need for engineering resources.
• Increased Dashboard observability: As the product evolves, the Finch Dashboard will provide deeper visualization of sponsor data and a clear view of the health of all sponsor connections. 

We look forward to working hand-in-hand with our existing retirement customers to inform our product roadmap.

“Collecting census and pay data from sponsors used to be a challenge because we had to spend so much time sifting through the data, making sure it was accurate, and transforming it into our standard format. Now that we’ve automated the process, we’ve eliminated administrative bottlenecks, reduced our overhead costs, and improved service quality for our clients,” said Chandler Julian, Director of Recordkeeping at NestEggs. “Thanks to Finch democratizing access to critical employment data, we're now able to deliver the kind of seamless integration experience that our clients expect from their service providers."

“Thanks to Finch democratizing access to critical employment data, we're now able to deliver the kind of seamless integration experience that our clients expect from their service providers."

Get connected through Finch

Finch makes it easy for recordkeepers and TPAs to securely, easily, and automatically access sponsor census and pay data directly from the payroll system and make deferral changes for the sponsor. Designed with the retirement industry in mind, Finch can be customized to meet the unique needs of your business and sponsors.

If you already are a customer, please reach out to your Account Manager to get access to these new features. To learn more about what Finch can do for your organization, contact our Sales team.

At Finch, our mission is to make accessing employment data simple. In 2020, we released Finch Connect, an easy way for employers to connect their HRIS and payroll system to other apps. 

Over the past few months, we’ve been revamping our connection experience with a focus on increasing visibility for our customers and driving higher conversion rates among employers.

Today, we’re excited to announce this all-new connection experience, which includes secure sessions, authentication progress tracking, smart re-authentication, and a more intuitive connection management experience for all.

Secure sessions and authentication tracking

We're excited to introduce Finch Connect sessions, a powerful new feature designed to increase security and visibility in the authentication process. 

What’s new: You can now generate a unique and unchangeable Finch Connect URL for each employer, making the connection process more secure and allowing you to track authentication progress in the Dashboard.

Here’s how it works: Employers are invited to authenticate via a secure URL created just for them. Because these URLs are defined on the backend, they cannot be manipulated. Any Finch user within your organization can generate these secure links through our Dashboard.

Once the employer clicks the link and begins their session in Finch Connect, you’re able to track their progress through each of the four stages in the Dashboard.

Use the Authentication Progress tab for an overview of the employers’ progress. If there are any errors, Finch will provide more information so you can quickly resolve them. 

For a detailed timeline of events related to each session, you can navigate to the Session History tab.

Clear, actionable connection management

We’ve made changes to the Dashboard that make it easy to keep track of all of your connections across employers and their statuses.

What’s new: You can now easily view all your live, staged, and disconnected connections at a glance in the Dashboard under the Connections page.

Here’s how it works: Each connection will be labeled as Staged, Live, or Disconnected.

• Staged: The session is active, but a connection has not yet been established.
• Live: The employer has completed the Finch Connect workflow. If there are any errors or if re-auth is needed, it will be flagged under Connection Status in this view.  

• Disconnected: The connection is no longer live and the session is not active.

By clicking into any connection, you can also find more details about status, job history, access tokens, and more. You can learn more about Connection Status in this post.

You can now also download all your connections as a CSV file for deeper analysis or to share with other members of your team who don’t have Dashboard access.

‍

Smart re-authentication for employers

Over 40,000 employers have successfully shared access to their HRIS or payroll data through Finch. And while the need for re-authentication isn’t frequent, it is sometimes necessary to keep a connection active. 

We’re excited to introduce a simplified flow for these users that reduces the number of steps required to re-authenticate.

What’s new: There are now fewer steps required of employers who need to re-authenticate their connection.

Here’s how it works: When a connection requires re-authentication, it will be flagged in our API and Dashboard. Any Finch user can then generate a new link for the employer to re-authenticate. Rather than starting from the beginning of the Finch Connect process, the employer will be sent directly to the sign-in page for their provider, skipping any prior steps they’d already completed. All they need to do is sign in with their credentials, API key, or other authentication method to re-establish their connection. 

Just like the initial connection experience, you can monitor the stages of re-authentication in the Dashboard.

How to get started

We know how important changes like these are to your operations. As a unified integrations platform, it’s our job to take on the heavy lifting of offering the best connection experience for your customers so that you can focus on building the apps and services that empower employers and individuals.

These changes are now fully available through the Finch platform.  If you’re already a Finch customer, you will need to adopt connection and session IDs into your workflow to enable these new features. Instructions to adopt these fields are available in our Help Center. If you have any questions, reach out to us at developers@tryfinch.com.

Getting access to the employment data locked inside HRIS and payroll systems can be a huge challenge for apps across HR, benefits and fintech. For decades, the industry standard has been to use secure file transfer protocol (SFTP) integrations or manual file uploads to share data between systems. While API integrations —the gold standard for data access—have grown in popularity over the past few years, many organizations don’t have the technical resources to build or maintain these integrations themselves. 

At Finch, we recognize this challenge. That's why we’re excited to introduce our newest beta feature: Finch Flatfile. Flatfile helps organizations with limited technical resources leverage our infrastructure to retrieve data from HRIS and payroll systems – without engineering resources. Flatfile customers can retrieve standardized data from 30+ HRIS and payroll systems, without subjecting employers to a drawn-out SFTP onboarding process or manual administration work.

Get started with Finch Flatfile today -->

What is Finch Flatfile?

Flatfile enables you to get up and running with Finch faster to unlock streamlined employer onboarding, data standardization, and secure file delivery. Flatfile users don’t need to build an API integration to Finch, making the feature accessible to all companies, regardless of their development resources.

Flatfile users can simply log in to the Finch Dashboard to provide a destination for SFTP-based file transfers, generate Finch Connect links, and monitor the status of connections. Employers still connect their system through Finch Connect, and all data is standardized across providers. 

In short, Flatfile lets you enjoy all the benefits of Finch’s Unified Employment API without the heavy lift of building to our API.

How does Finch Flatfile work?

Finch uses its existing integrations with leading HRIS and payroll providers to pull data directly from their systems. This data is then standardized through the Finch API and delivered by file to any single SFTP server you provide. 

Here’s how it works:

1. Share a link: Simply log in to the Finch Dashboard to generate a Finch Connect link. You can then share this link with any employer to enable them to connect their HRIS or payroll system.
2. Connect Providers: Employers can then go through the Finch Connect process to authenticate as usual. Finch walks them through any nuances between providers.
3. Receive Files: Each pay run, you’ll receive a file that is standardized across every provider. The file is delivered by SFTP, and contains all the information you could get through our API.

For more details, check out our step-by-step guide on working with Finch Flatfile.

How is Flatfile different from a traditional SFTP integration?

While Flatfile uses SFTP, there are a few key differences when compared to a 1:1 SFTP integration with an HRIS or payroll provider. 

In a typical SFTP setup, the provider (HRIS/payroll) would work with an individual client (employer) and third-party application (your app) in order to configure a custom file to transfer routinely. Each provider has different setup requirements, implementation timelines, and costs associated with this process. Generally, each employer must go through the implementation individually, making it difficult to scale.

With Finch Flatfile, you can avoid the months-long SFTP setup process and get up and running in minutes. You begin receiving files over SFTP once an employer has permissioned your app to access their system.

Benefits of Finch Flatfile

Flatfile users enjoy a range of benefits over traditional SFTP integrations and manual file uploads.

• More integrations: By eliminating the Operational burden of managing multiple SFTP processes, we make it easier for you to support more of the integrations your customers need. Flatfile is currently compatible with 30+ providers.
• Easy authentication and onboarding: Traditional SFTP integrations involve a lengthy implementation process with a lot of back-and-forth between your support team, the provider, and your client. With Flatfile, employers simply go through Finch Connect to authenticate. No data mapping, implementation fees, or testing required. 
• Data standardization: Unlike a direct SFTP integration with a provider, Finch offers a single, standard file format for every HRIS and payroll system that matches our unified API. This simplifies any manual work for your Operations team, and eliminates the need to manage unique data schemas and naming conventions. 
• Secure file delivery: If you already use SFTP for integrations, there’s no need to set up something new. Simply provide your credentials to Finch, and we’ll upload fresh files upon first connection and after each pay run.

Get started with Finch Flatfile today

Once enabled, Finch customers can start using Flatfile in minutes. Learn more about our supported providers by contacting our Sales team. 

We’re excited to announce several upgrades to Finch’s connection health monitoring tools. These improvements offer deeper insights into each employer’s connection status at a glance so you can ensure each integration is running smoothly.

What are connections?

Connections are a critical concept at Finch. Simply put, a connection is created when a single user (in this case, the employer) links their HRIS or payroll system through Finch Connect. The connection is 1:1:1, meaning a single employer and a single provider are linked through one authentication token. (Note: This concept becomes slightly more complicated if the employer has multiple Employer Identification Numbers (EINs), but this definition applies in most situations.)

Once a connection is established, data can flow between the employer’s system of record and your application through Finch’s API. 

Connection health monitoring: what’s new?

Keeping the connections between the employer’s HRIS/payroll system and your application healthy is essential to maintaining data flow between the platforms. That’s why Finch’s dashboard includes connection monitoring tools. 

The latest improvements to connection health monitoring include:

• A new, more detailed Connection Status field
• Granular filters to help you triage issues and identify stale connections
• A new way to monitor setup status for assisted integrations

Detailed Connection Status field

Previously, unhealthy connections were only identified in the dashboard as “Needs Attention.” Developers had to click into each individual connection’s page to see more detail. 

Now, the main dashboard page will display more granular detail about the status of each connection, making it easier to see, at a glance, what is impeding data flow. 

The new statuses are:

• Reauthentication needed: The employer needs to reauthenticate Finch as a user to enable data access.
• No account set up: The employer has not created an administrator account for Finch.
• Insufficient permissions: The employer has authenticated Finch as a user, but has not permissioned Finch to access the necessary data. 
• Multiple errors: This will appear if two or more of the above statuses apply. 

Filters for triaging issues and identifying stale connections

Two new filters have been applied to the main dashboard page, allowing you to filter connections by status and by last sync time.

With the new granularity of the connection status field, you can filter connections by the action item required—reauthentication, no account set up, insufficient permissions, or multiple errors. 

We’ve also added a new column to the dashboard called Last Synced; previously, this information was only available on the connection detail page. The addition of this column means you can now sort by this detail as well—set your timeframe (in hours, days, weeks, or months) and the filter will display all connections that last synced within or outside of that timeframe.

Assisted integration setup status

Finch supports both automated and assisted integrations. Assisted integrations are supported for our Scale plan customers through a feature called Finch Assist. These integrations require an employer to add Finch as a third-party administrator in their HRIS or payroll system.

Because the workflow for connecting employers to an assisted integration is slightly different than with automated connections, we’ve added a timeline on the connection detail page that allows you to see when each step of the process was completed and which are still pending. 

The milestones on the assisted setup timeline are:

• Token Created: The employer has completed the Finch Connect flow and a token has been sent to you, the application.
• Account Invitation Accepted: Finch has accepted an invitation from the employer to access the payroll system and has begun to set up the account.
• Permission Verified: Finch has verified that the employer has granted proper access to the system. At this point, the connection can now be configured.

This additional information makes it easier for developers, product managers, and operations teams to understand the status of assisted connections, and help walk through employers through any troubleshooting steps if needed.

Get started with Finch

Offer your customers integrations to hundreds of HRIS and payroll systems all through a single integration with Finch’s Unified Employment API. To learn more about the systems we support, visit our Integrations page or explore our developer docs.

According to our June 2023 survey of 1,000+ HR professionals, 97% of employers agree that employment systems like HR and payroll should integrate with other tools in their tech stack. But building and maintaining these integrations can be a big challenge for PMs and developers. 

That’s where Finch comes in. 

On February 6th, Finch teamed up with HR platform Deel to demonstrate how easy it is to connect to employers’ HR or payroll systems through our API and sandbox. With these tools, any PM or developer can connect to live HR and payroll systems, generate mock data, and simulate real-world testing scenarios — for free.

We covered the following topics:

• The challenges with integrating with HR and payroll providers today
• Types of HR and payroll integrations
• How lack of integration impacts employers (your customers)
• How Finch works
• The Provider Sandbox (connect to demo accounts)
• The Finch Sandbox (generate mock data on-demand)

‍

Below, we provide highlights from the webinar. You can also watch the complete recording by filling out the form below.

‍

The challenge: your customers are spread across countless HRIS and payroll systems

HR and payroll systems are every business’s source of truth for their employees. It’s where you can reliably find if individuals are actively employed, where they work and live, how much and how often they’re paid, what benefits they’re enrolled in, and more.

But there are literally thousands of HR and payroll systems on the market that your customers may be using — more than 5,700 in the US alone. 

While all of this variety is great for employer choice, it can make integrating with those providers a big challenge. With so many integrations to build, it can be hard to know where to start.

Why are HR and payroll integrations so complicated?

Beyond the sheer number of providers you’ll want to integrate with, the variation between providers poses another set of challenges. Every provider expects PMs and developers to integrate in a unique way (if they’re willing to support integration at all). 

Typically, PMs and Developers find they have 3 options:

1. Build integrations from scratch using each provider’s public API
2. Help your customers set up a secure, automated file-sharing process between their HR or payroll provider and your app
3. Ask employers to simply upload or enter the data manually. This isn’t really an integration, but will still require engineering resources to manage.

For more information on how these integration methods stack up, you can also check out our SFTP vs API whitepaper.

Finch is a unified API for hundreds of HR and payroll systems

With Finch, you only need to build and maintain one API integration to unlock connectivity with 200+ HR and payroll providers. And with one shared data model, you don’t need to worry about nuances between providers. No matter what HR or payroll system your customers use, all data is returned in a standardized format. 

But instead of taking out word for it, we encourage PMs and developers to try it themselves. That’s where our sandboxes come in. 

Finch has two testing environments — the Provider Sandbox and the Finch Sandbox.

Finch Testing Environment #1 – The Provider Sandbox

Our Provider Sandbox allows you to connect to demo instances of live HR or payroll providers. You can utilize them as you would a real production connection.

Watch the demo to learn step-by-step how to:

1. Set up your demo or trial account
2. Set up a connection through Finch
3. Experiment freely by making changes in the system of record and seeing how it’s returned

Finch Testing Environment #2 – The Finch Sandbox

The Finch Sandbox allows you to create mock connections for any provider that Finch supports, giving you greater configurability and control over testing scenarios. 

Perhaps the most valuable part of the Finch Sandbox is that the mock data generated reflects what can actually be returned by each provider—a valuable insight when determining if an integration is going to be able to adequately support your use case.

While Finch generates the data, the user can configure these connections any way they want using our sandbox API. Using the API rather than relying on a provider’s dashboard makes it easier to set up bulk or repetitive testing scenarios. For example, you could quickly generate multiple pay statements with specific earnings and deductions amounts, and replicate that scenario across multiple connections.

In the Finch Sandbox demo, we explain how you can:

1. See what data can be returned from providers you care about
2. Manipulate specific data fields or the state of connections
3. Simulate edge cases for last-mile testing scenarios

Try before you build with two powerful testing environments

To recap, there are 3 key benefits to using our developer sandboxes. 

1. You can set up live, external connections for free. 

There’s nothing that can beat getting to jump in and try out your use case with real providers. The provider sandbox can really help you identify the opportunities and boundaries around what you can build with Finch.

2. See exactly what data can be returned, and what features can be supported for each individual provider. 

This is important since different providers may support different fields and functionality.

3. Use the Sandboxes to demo Finch Connect to your own customers.

While this wasn’t included in the demo, our customers love that they can use our sandbox to demo Finch to their own customers. For example, you could incorporate the connection flow and return mock data from our sandbox in your own live product demo. This helps employers see just how easy it is to set up their connection through Finch.

If these benefits sound interesting to you, reach out to our team for more information, or sign up for free to try Finch yourself.

Software sandboxes offer a controlled environment where developers can play, explore, and learn about a product without real-world consequences. While Finch has always had a sandbox for our API, we’re excited to share a brand new sandbox experience that will help developers test our integrations with specific HR and payroll providers. We call it the Provider Sandbox.

What is the Provider Sandbox?

The Provider Sandbox is the easiest way to test our integrations with HR and payroll providers. It provides a realistic environment where developers can initiate an external connection with live providers like Gusto and Deel — and receive data from demo and trial accounts.

The beauty of the Provider Sandbox is the ability to test live, external connections with specific providers. It’s as realistic as you can get outside of a live customer scenario. That means you can test everything our API offers – like request forwarding and data syncs – just as you would a production account.

The Value of Dummy Data from Providers

Each HR and payroll provider is unique. They offer different features, specialize in different industries and customer sizes, and even if the data they store is similar – the way that they manage the data is different. Without actually connecting to providers’ systems during the testing phase, it’s difficult to know what data you’ll actually have access to. And that makes it tricky to test your unique use case. 

With the Provider Sandbox, you can test for specific field support and understand specific nuances of a provider - for example how contractors are handled in the system. Most importantly, you’ll be able to update your demo company within the provider’s dashboard, resync with Finch, and see those changes reflected in the Finch API response. This is the simplest way to realize the power of Finch without having to worry about using a live customer – or worse, your own payroll account – to test.

How to Connect To Your First Demo or Trial Account

In order to use the Provider Sandbox, you’ll need to first set up a demo or trial account with a supported provider. Then, you can modify the data in your account, sync with Finch, and understand how those changes are reflected in the Finch API. Getting comfortable with this back and forth can help you feel more confident that this provider can support your use case.

Currently, the Provider Sandbox supports Gusto, Deel, and Square demo accounts and BambooHR, Bob, Humaans, Personio, Sage, Square, and Zenefits trial accounts. 

In the demo below, you can see the process of setting up a demo account and testing your first connection with Gusto. 

Experiment with Finch’s API and Dashboard

Connecting to an external provider is only the first step. With the Provider Sandbox, you can use this connection to test many of Finch’s API and Dashboard features.

For example, say you’re building a financial forecasting product, and require weekly working hours from Personio. While this isn’t supported in our standardized data model, it is possible to access it with Finch Request Forwarding. Simply use our /Forward API to request data from Personio in their native API data model. Once the raw data is returned, you can understand exactly how this data can be utilized in your production application. To see how this works, watch our Request Forwarding demo.

This is just one example of how you might use the Finch API to experiment with provider data. Please note that Request Forwarding is only available for active customers on our scale plan.

Conclusion

Together, we hope both our Provider Sandbox and Finch Sandbox can help developers test exciting new applications of Finch without having to worry about the sensitivity of live customer data and PII. 

Our Provider Sandbox is free for developers. If you’re already a Finch customer, get started by visiting your Sandbox Application in the Finch Dashboard. If not, sign up for free.

Most people aren’t aware of the huge inefficiencies that plague the benefits and retirement industries. But if you have ever enrolled in a 401k, HSA, FSA or other fringe benefit there is likely a chain of manual processes that have made that benefit available to you.

At Finch, we’re helping retirement and benefits platforms improve not only the administrative experience for HR professionals, but also unlock new products and services that are personalized, easy-to-use, and scalable.

So how are we doing it?

Finch was built to connect the employment ecosystem. In 2020 we launched seamless read access to HR and payroll systems so applications could consume employer and employee details in a standardized format. Then, last year, we launched Deductions (previously Benefits) to help applications write deductions and contributions changes back to their customers’ payroll systems automatically.

This two-way integration is critical to employee benefits platforms, which need to fit seamlessly into their customers’ existing HR tech stacks. Finch is the only unified API offering it today.

“Frankly, there were no other solutions that could support our vision and facilitate writing payroll deductions automatically," says Erika Davison-Aviles, Deductions customer and Co-Founder of TempoPay, "Finch had the technology and functionality that best met our product needs.”

“Frankly, there were no other solutions that could support our vision and facilitate writing payroll deductions automatically. Finch had the technology and functionality that best met our product needs.”

The Need for Automated Deductions Management

Benefits platforms want to be able to offer seamless experiences for the employers (sponsors) they serve. But, it’s not uncommon for the sponsor onboarding process to require a lot of manual work and coordination across operations, customer success, and technical teams. There is also a significant administrative burden for their core user, the HR admin.

Benefits platforms face monumental administrative burdens

Most payroll providers don’t offer deductions management through their API, this means one-off file transfer processes need to be created for each supported provider. This means a months-long process of discovery, setup, data mapping, and operational change management. It means setting up unique SFTP servers for each provider and paying for implementation or hosting. And it means any subsequent change to the data collected means revisiting the process again. On top of ongoing testing and quality checks. 

This administrative overhead not only impacts what these platforms can build and offer, it also has significant downstream effects on the sponsors and employees they intend to serve. It's a big challenge for companies hoping to differentiate with a great user experience.

As Davison-Aviles explains, “SFTP and flat file uploads were out of the question. Manual file uploads are not only time-consuming, they’re wrought with errors. They simply didn’t align with our vision.”

“SFTP and flat file uploads were out of the question. Manual file uploads are not only time-consuming, they’re wrought with errors. They simply didn’t align with our vision.”

Operational overhead limits viable benefits options for sponsors

In our recent survey of over 1,000 HR professionals, HR teams spent 3-5 hours per payroll cycle to ensure employees had the correct deductions and contributions applied. That may work with a large HR team, but often isn’t feasible for small businesses. As early Finch Deductions customer Chris Ellis, Co-Founder and CEO of Thatch says, “Small businesses want to offer great benefits, but don’t have the bandwidth to deal with complexity.”  

Additionally, employers update their payroll systems as they grow, but the lack of integration and standardization across the ecosystem makes it impossible (or unreasonable) to take their benefits with them. 

According to Fidelity Investments’ 2023 Small Business Retirement Index, 22% of small business owners said they don’t have time to offer retirement options to their employees, (only 34% currently offer retirement savings plans). But, with new legislation enacted in Secure Act 2.0 and the rise of state-mandated retirement plans like CalSavers, employers may need to find a way. There is an opportunity for benefits platforms to use technology to help these businesses control costs while remaining compliant.

What’s Next for Finch Deductions?

In the past year, we’ve made huge strides in delivering automated deductions management for some of the largest payroll systems on the market. We’ve enabled platforms like Thatch to reliably manage employee deductions and contributions across payroll providers through a standardized experience. And we’ve made it flexible enough to enable brand-new use cases, such as TempoPay’s individualized health benefits that allow employees to control their payments every month.

But there’s still more to do. In the next few months, we’ll more than double our coverage of popular payroll systems to help our customers serve more employers, leverage automation to tackle new industry requirements, and deliver new, innovative benefits that help individuals achieve their mental, physical, and financial goals. 

As we scale, our focus is on expanding coverage of payroll systems that we offer in completely automated ways, while simultaneously raising the bar for reliability. Our goal is to build comprehensive tooling to help benefits providers reduce operational overhead and focus on providing first-class services to employers and employees. And we will continue to build deep industry partnerships across different parts of the employment stack.

Employment and benefits industries are at the cusp of monumental change, and payroll integration will be crucial. In the words of Chris from Thatch, “Payroll integration shouldn’t be your core competency. Like Stripe for payments and Plaid for bank accounts, Finch is the best solution in its category. It would take you longer and cost you more to reinvent the wheel."

“Payroll integration shouldn’t be your core competency. Like Stripe for payments and Plaid for bank accounts, Finch is the best solution in its category. It would take you longer and cost you more to reinvent the wheel."

To learn more about how benefits platforms are using Finch, check out our new customer stories from Thatch and TempoPay. Or get started with Finch today for free.

‍

Subscribe to our Newsletter

Want to stay in the loop on all the exciting new product updates from Finch? Sign up for our monthly newsletter below. You can unsubscribe at any time.

‍

‍

Building with Finch just got easier. 

Today, Finch announces the release of a set of new backend SDKs that will help developers support integrations faster than ever. We expect this new functionality to help our customers focus more on their application logic and less on boilerplate code.

What’s a Software Development Kit?

A software development kit (SDK) is a set of platform-specific building tools for developers. SDKs put everything you might need to develop and run software in one place. They can also contain helpful resources like documentation, APIs, and frameworks that enable faster application development. 

While the actual contents of each software development kit will vary, most will include:

Libraries and Frameworks: These are collections of pre-written code that developers can leverage to perform common tasks without having to build from scratch. Libraries simplify the development process by providing reusable, modular components.

Documentation: Comprehensive guides and references that detail the functionalities, classes, methods, and best practices for using the SDK. Good documentation is crucial for developers to understand and effectively utilize the tools provided.

Sample Code: Examples of how to use the SDK's features. Sample code can serve as a starting point for developers, helping them get up to speed quickly and see practical implementations of the SDK's capabilities.

All of these resources help developers control costs, shorten development cycles, and ultimately ship great products faster. 

Backend SDKs for Authentication and Data Retrieval

Finch’s SDKs give developers the building blocks and tools needed to build robust, scalable, and efficient applications. Our SDKs are designed to streamline the development process, reducing the time and effort required to integrate with Finch — and by extension, hundreds of payroll and HRIS systems.

With this newest set of SDKs, developers can expect a comprehensive set of built-in functions and methods that allow them to interact with Finch's APIs directly in their language of choice. These backend SDKs include authentication and data retrieval operations, making it easier for developers to perform common tasks.

Let’s walk through an example using our Python SDK: After an employer authorizes through Finch Connect, developers can use the get_access_token function to exchange the authorization code for an access token. Once they have this access token, they can call any of the retrieval functions to retrieve data for that company. 

For example, client.hris.company.retrieve() will retrieve data from the /employer/company endpoint of the Finch API.

Developers can use this pattern to pull the same data models available in our API. This includes all data available via the company, directory, employment, individual, payment, pay statement, and benefits endpoints.

Get started with Finch SDKs

Looking to get started? Check out our SDK repositories, which provide extensive documentation and sample code. Start with selecting your preferred coding language:

• Python
• Java
• Javascript

Curious what other SDKs Finch supports? Check out our frontend SDKs, which can help you embed Finch Connect in your application.

We're excited to see what you build with Finch. Visit our docs for more information on installation and usage. If you have any questions or need help getting started, reach out to developers@tryfinch.com.

Monitor Data Syncs Job History in the Finch Dashboard

Just a few weeks ago, we announced a new set of Jobs Management endpoints, which make it easy for developers to programmatically view the status of data sync jobs for any employer connection. Now, we’re excited to share a new user interface (UI) in the dashboard that empowers any user to do the same. We call it the Data Syncs UI.

The Data Syncs UI enables any Finch user to view the status of scheduled and requested data syncs through a user-friendly dashboard. This gives developers, support teams, and product managers alike an accessible source of truth for the status of data syncs across all connected customers.

Real-time visibility for your entire team

The Data Syncs UI is designed to make it easy for anyone in your organization, regardless of their technical expertise, to view and manage data sync job activity.

For example, product managers can now monitor the health of connections across their applications without the need for engineering support. The intuitive interface gives them visibility into every active and past connection, so they can proactively address syncing issues and provide timely information to customers (or our support team) as needed.

Meanwhile, the Data Syncs UI empowers support representatives to quickly assess the status of customers’ connections and efficiently field questions and requests. This helps them provide a best-in-class experience for your customers.

Get started with the Data Syncs UI

To access the Data Syncs UI, simply log in to your Finch dashboard and click on any of your individual customers under the 'Employers' tab to see a full list of syncs and their status. If you aren’t already using Finch today, but want to learn how employment data can help power your next product innovation, sign up for a free account, or talk to a member of our team today.

‍

Today, we’re excited to announce two major upgrades to Connect: authentication fallback and improved configurability. These enhancements give you more flexibility and control over how employers authenticate through Connect.

Increasing Connect conversion with auth fallback

Fallback is an alternative path to authenticate when your customers are having difficulty connecting with the primary authentication method. This enables employers to connect through Finch without the need to contact support.

How it works

If an employer attempts to authenticate through Connect and cannot complete the primary authentication method, Connect will display instructions for the employer to connect manually as a fallback option. Once Finch sets up the account, the data for this connection will flow through the Finch API as usual. Check out our docs for a complete list of providers and more implementation details.

Improved configurability of Connect

Finch may display various authentication methods to employers depending on different providers. Several common examples of authentication include credential auth, OAuth, and API keys. Each authentication method has its pros and cons, some of which include friction to connect, cost to employers, and data refresh frequency.

The new and improved authorization configurability allows you to decide what configurations to enable in Connect across providers, including:

• Which methods to show as the primary method in Connect
• Which methods to disable in Connect
• Which providers to hide in Connect

To learn more, read the configuration docs for more details.

Getting started

Both Connect updates are immediately available. Please reach out to Sales or your Account Manager to enable authentication fallback and config. If you don’t have API keys yet, you can sign up for a free account today!

We are thrilled to announce the launch of our new Data Refresh endpoint, allowing you to request new data whenever you need it.

The Finch API syncs data with providers on a set cadence. This enables Finch to provide developers a reliable, low-latency API. But, we know sometimes you need to refresh your data sooner than Finch's retrieval schedule.

Kick off a new sync any time with Data Refresh

Data Refresh is a new endpoint which lets you enqueue a new job on demand without waiting for the next scheduled sync.

We are excited about enabling use cases where near-real-time data is critical. For example:

• A health insurance provider that needs to check for qualifying life events on employee payroll data to ensure accurate coverage
• A retirement company that needs to knows when its customers run payroll, and check for new pay runs in a time-sensitive use-case (e.g. confirming deductions)
• A compensation application services a customer undergoing a tender offer and needs to see updated employee directory information in short order
• A financial planning application services a customer making changes to their payroll system while doing financial modeling, and wants to see the changes in near-real-time.

How it works

First, you’ll need a way to trigger a refresh in your application. This is typically triggered by a refresh button built into the product or through some backend workflow. Then you can use this workflow to send a request to our POST /jobs/automated endpoint and we’ll kick off a new job to fetch any new updates. While the job is running, you can use our GET /jobs/automated endpoint to check on the status of the job. After the data is updated, you can call each individual data endpoint to retrieve the latest data. Check out our docs to learn more.

Improved Data Syncs management for better visibility

But that’s not all—we’ve also released new Jobs Management endpoints to give you more visibility and control into jobs run by Finch. With these endpoints, you’ll also be able to view the status of a data sync job, as well as timestamps related to key lifecycle events by sending a request to GET /jobs/automated. Use this endpoint to understand and communicate with your customers the last updated time, status of the current sync, and more.

Getting Started

The /jobs endpoint is available to everyone today. Anyone with API keys, please reach out to Sales or your Account Manager to enable the feature in production. If you don’t have API keys, sign up for a free account!

Today, we are excited to announce the launch of Benefits, a product that enables developers, benefits administrators, and employment providers to enable holistic benefits management—including benefits creation, employee enrollment, and deduction and contribution updates—across employment providers via a single API.

At Finch, we are on a mission to power the future of employment, and a huge piece of employment involves benefits. As the employee benefits landscape becomes increasingly digital and competitive, existing benefits providers need to be able to scale rapidly. In addition, benefits expectations have changed drastically over the past 18 months. From small businesses to large enterprises, there is more demand than ever from employees for quality benefits, and new solutions are popping up to fill those needs. We're excited for this new product to provide seamless control over benefits data so you can deliver these much-needed services to employers.

The current situation— multiple systems, complicated processes

Today, benefit providers sell to employers across a whole range of different employment systems, from Gusto™ to Zenefits to Insperity® and more. These benefits providers not only need the ability to retrieve employee records when a new member joins, but also process deductions and benefits enrollment to move money from payroll compliantly. The requirement to process deductions and enrollment is further complicated given money movement and employment regulations.

Existing solutions are error-prone and time-intensive

Today, there are generally three options for benefits providers—

• SFTP—Most of the health insurance, health benefits, and retirement sector currently upload files to be consumed via SFTP. This is the standard in the industry but it is not real-time and is prone to errors.
• Partnerships—Partnering directly with payroll providers can require several months of partnerships and business development effort on top of technical integration work.
• Product Operations— Building out an in-house product operations team to pull reports and manually make changes to the system.

Many times, this benefits infrastructure is cobbled together with millions of dollars in development cost and is extremely difficult to maintain. Benefits changes the game. We have rebuilt this infrastructure from the ground up using modern API connectivity. Gone are the days of depending on painful CSV uploads, antiquated SFTP transfers, or error-prone internal product operations teams. With Benefits, Finch's platform can support the growth and expansion of our partners for today's increasingly digital and fragmented employment landscape.

Easy to set up, robust functionality

Benefits is comprised of a few simple endpoints under /employer/benefits/ to set up company benefits as well as enroll individuals—

/employer/benefits

• Supports 17 benefit types (401(k), 403(b), HSA, FSA, and more)
• Provides detailed benefits information including frequency, company contributions, and employee deductions
• New company benefits can also be created via the API
• Robust feature set covering catch-up limits for retirement benefits, flexible annual maximums for HSAs, and other benefits-specific configurations

/employer/benefits/{benefit_id}/individuals

• Provide individual enrollment information including individual deductions, contribution limits, and other configuration information relevant to the specific benefit
• Individuals can be enrolled in and unenrolled from company benefits via the API

You can enable the benefits product for supported providers today by simply configuring your application to request permission for the new benefits scope on Finch Connect.

Trusted data integrity and security

As with all of our products, Finch takes data integrity and security very seriously, and our Benefits product is no different. None of this sensitive data is stored by Finch, but rather it is passed through from the application to the underlying provider. Since we are a pass-through layer, we build on top of all of the existing fail-safes for communicating issues and tracking deductions and contribution limits, just as the underlying payroll systems do.

Already improving acquisition and retention

Benefits is already being used by customers from sectors including HSA, FSA, 401(k), payroll-backed lending, and more. Hear directly from some of our customers—

Operational efficiency and employer coverage was a bottleneck to our sales efforts. Finch Benefits allowed us to drive real-time management around deductions and enrollment and therefore increase our customer acquisition and retention. Our sales and operations teams are extremely happy!

CPO of a large enterprise powering a new workplace savings program

Finch has allowed us to streamline our required integrations with our client's payroll administrators, freeing our clients and Lane Health from having to expend time and resources to perform these payroll system integrations and file exchanges.  By providing Lane Health with access to 95 payroll systems, we can deliver a superior client experience very effectively and efficiently.  Finch has and will continue to be a valued partner for enabling our growth and achieving our business goals.

Crystal Peel, VP of Client Solutions @ Lane Health

The Finch team have been valuable partners to us as we navigate the various complex aspects of 401(k) administration and compliance, and how payroll and contribution data factor into that equation. We couldn't be more pleased with our partnership with Finch so far and are equally excited for the future as Finch continues to evolve their service platform to include more valuable features and benefits.

Justin Young, Senior Manager of Product Development @ Slavic401k

We would like to extend a big thank you to all of our early users who provided invaluable feedback during the build!

Getting started with Benefits

If you’re an existing Finch customer, you can enable the Benefits product today by reaching out to your account manager to get started. Developers new to Finch can reach out to developers@tryfinch.com.

Stay tuned as we continue to update the endpoint with additional benefits categories. We look forward to supporting you in what you build next to create innovations for employers and employees.

Introducing searchable API logs for an enhanced developer experience

At Finch, we know that your success depends on the information and tools you have at your disposal. As part of our commitment to supporting that success, we’re thrilled to bring searchable API requests to the Finch dashboard.

How it works

The log is a record of every API request made by your application. Some requests may be batched with associated status codes for every individual ID or payment ID, and we expand these into their own log. We record requests with singular responses as their own.

You’ll find the event log in your Finch dashboard under the Activity tab. From there, you can search by company ID, company name, request ID, individual ID, payment ID, or Finch endpoint (e.g., directory, company, payment) and filter by payroll provider, status, and time.

Developer agency is our why

In the future, the piping we’ve built will make many more features possible — like a metrics or issues center — that offer even more reliable data capture and deeper search mechanisms.

Our goal is to empower the developers building on top of Finch. With visibility into your API usage, you’ll be equipped to troubleshoot errors, keep your team apprised of their status, properly communicate issues to your external users, and provide better service.

To start building with Finch, enter your email address on our homepage here to get API keys today.

‍

We built Finch to unlock access to employment data and are committed to creating a best-in-class developer experience. Today, we’re excited to announce the launch of our self-serve sign-up, which makes it easy for innovative developers to get API keys and start evaluating the benefits of employment data for their product.

Connect to employment systems in minutes

For many developers looking to leverage employment data, it takes months to gain access and build integrations one by one. Even when those integrations are built, the process can still involve flat files, complex authentication, and mismatched data scopes. Finch condenses that entire process into a few days by unifying all employment systems through a single API with normalized data and permissions. In the end, your customers can sync their employment system with your product in minutes (though we’ve seen it happen in as little as 30 seconds).

Sign up to access our docs, sandbox, and dashboard

Now, instead of having to go through our sales team to access our API keys, we’ve overhauled our onboarding process, so you can start building in minutes. Getting up and running is easy and only takes three steps:

1. Head over to the Get API Keys button on our homepage.
2. Enter your contact and account creation information.
3. Generate sandbox credentials.

In only a few minutes, you’ll have everything you need to start testing with Finch’s sandbox.

Once you’ve created an account, you’ll get access to our sandbox, which includes multiple test instances representing varying employer sizes, a dashboard with connections monitoring and audit logs, and documentation that sets you up for success.

Launching into production

Once you’re done testing out the platform and are ready to go to production with live customers, reach out to our team. We’ll make sure you have production keys and check all the boxes related to production readiness and compliance so that you can offer the best data-syncing experience to your customers.

Gain access to Finch today and supercharge your application experience with employment data.

If we had to describe last month in one word, it would be expansive, with several integration launches, extended field support, and an alternative integration auth method. Check out what’s new!

New automated API integrations added to coverage

Humaans

Humaans is a modern HR system focused on modularity and compatibility with other HR platforms. While support for Humaans is part of our larger strategy to grow our coverage in European markets, Humaans has also begun to expand globally, unlocking myriad new employers internationally.

SageHR

SageHR has grown to support businesses of up to 125 employees in 1,200 cities worldwide. As the company enters the next stage of its evolution, adding new modules and features specifically designed to scale, we’re even more excited to support integrations with SageHR accounts.

Sapling

A relatively young player in the HR space, Sapling was founded in 2016 and expanded market share quickly, eventually being acquired by Kallidus in 2020. With offices in the U.S. and Canada, Sapling services hundreds of employers around the world, and is a welcome addition to our coverage network.

Support for new inclusive field — preferredName

Another significant development in our ever-deepening field support, preferredName is a crucial field for many players on the Finch platform.

Rather than relying on legal names only, using an employee’s configured preferred name allows applications to make employees feel more comfortable and, in sensitive circumstances, can have a significant impact on belonging and trust. Preferred name is now available via the individual endpoint for all of Finch’s automated API integrations!

Expanded Paychex Flex deduction types

Finch has expanded support for deduction types in our pay-statement endpoint for Paychex Flex. Many new deduction types are available, including 401k, Roth 401k, 401k Loan, FSA Dependent Care, Section 125 Medical, and more.

This is of notable importance for retirement and benefits applications, which rely on this information to validate that deductions have been run, as well as tax credit companies, who use deduction information to determine tax credit eligibility.

Alternative auth option with Zenefits API token

Finch is constantly making improvements to our existing integrations, and Zenefits is one of Finch’s most-used and longest-standing examples. Zenefits recently introduced their own API, which allows Zenefits customers to create an API token in their dashboard for development use. This provides a faster and more secure way to access Zenefits data.

Employers can now enter their API information directly via Finch Connect. To do this, they simply select Zenefits as their provider, and select the “Using SSO? Enter an API Token Instead” button at the bottom of the login page. This will direct them to enter their API information.

That's all for this monthly update! Stay on the lookout for our next monthly product update. If you want to get your hands on the latest and greatest Finch features sign up for free access here.

Reduced latency with data syncs

Finch now syncs data with providers on a 24 hour cadence, and Finch API requests now return data from the most recent sync. This will result in major improvements to response latency, as well as a more smooth and consistent experience using Finch — any provider-specific issues related to their own infrastructure will be smoothed over by our most recent sync data. In the future, we’ll be adding even more rich functionality to our data syncs, including faster refresh times and the ability to force a data sync on-demand.

Embed Finch Connect with the new Javascript SDK

In addition to our ReactJS SDK, Finch now offers a vanilla Javascript SDK for embedding Finch Connect into your application. Simply load the SDK via a script tag and add some simple initialization code to your application to embed connect.

Developers are no longer limited by choosing React to embed Connect with our supported SDKs. Any web app running Javascript can now take advantage of this superior developer experience.

More granular deduction types for 3 more providers

From calculating tax credits to identifying when deductions have been applied, many customer use cases rely on being able to consistently discern benefit deduction types in employee pay statements. We have now added support for Section 125 Medical deduction typing in Paychex Flex, ADP Workforce Now, and Rippling. You can see these s125_medical types showing in the form employee_deductions[].type field on Finch’s /pay-statements endpoint. More providers to follow soon!

That's all for this monthly update! Stay on the lookout for our next monthly product update. If you want to get your hands on the latest and greatest Finch features sign up for free access here.

As developers ourselves, we know that while APIs are a great first step to increasing business efficiency, when it comes to implementation, SDKs create a superior experience.

We recognized this early on at Finch, which is why we focused on developing our React SDK for Finch Connect. This SDK offers an easier alternative for embedding Connect into applications versus using the Finch API directly. However, it also constrained developers to using React if they wanted to embed our product.

For this reason, we’ve gone back to the basics and developed a vanilla Javascript SDK for Finch Connect. This framework-agnostic SDK offers more flexibility when embedding Finch Connect into your frontend applications. Any web app running Javascript can now take advantage of the improved developer experience that SDKs offer.

Using the SDK

To embed Connect via our JS SDK, simply load the SDK via a script tag and add some simple initialization code to your application:

<script src="https://prod-cdn.tryfinch.com/v1/connect.js"></script>

The returned FinchConnect object exposes open, close, and destroy lifecycle methods, which you can utilize to seamlessly get Connect up and running in your application.

Read our docs to learn more about our JS SDK and view the open source repository here!

This month's updates include further expansion of coverage with two additional API integrations, greater availability of a key field for insurance providers, and a new way to connect with TriNet customers. Check out what’s new!

Broader North American coverage with two new integrations

Wave

Wave offers payroll as part of an all-in-one suite of financial products that serve over 2 million SMBs across the US and Canada. Acquired by H&R Block in 2019, the company offers a set of free services including invoicing, accounting, and banking, and adds additional paid services such as payroll, payments, and bookkeeping. We're excited to support Wave and allow developers to connect with hundreds of thousands of their payroll clients.

Quickbooks Canada

While we have compatibility with Quickbooks Payroll in the US we've now added support for Quickbooks Payroll as part of our broader international expansion efforts. Now developers can connect directly all 1.4 million Quickbooks Payroll customers across North America.

Expanded support for worker's compensation fields

We continue to roll out new fields for essential use cases and have made the worker's comp class_code field available in both Quickbooks and Paylocity alongside Gusto, ADP RUN, and others.

This field within the employment endpoint exposes the specific 3-4 digit code that identifies the types of work an employee performs so that insurance companies can estimate risk and calculate accurate premiums for employers.

While many of them will follow the National Council on Compensation Insurance (NCCI) code system, 14 states operate with independent class code systems. Cross-referencing the work location state for each employee with the class_code field is important to properly interpret this datapoint for your insurance product.

Alternative auth option with Trinet API token

With over 23,000 employers supported in the US, TriNet is one of our longest-standing and most popular integrations, and we’ve given it a fresh new update! Our TriNet integration now supports the option to connect via TriNet’s API directly. This new integration option is both a smoother and more secure experience, providing significant latency and reliability improvements to the connection.

How to Connect

Employers who select TriNet as their provider will see a new authentication page displayed by default in Finch Connect. Once they follow the process outlined by TriNet, employers will receive a set of API keys from TriNet, which can then be securely shared via Finch Connect.

That's all for this monthly update! Stay on the lookout for our next monthly product update. If you want to get your hands on the latest and greatest Finch features sign up for free access here.

This month’s updates include the beta launch of our new ATS API, an updated authorization workflow for our latest HRIS partner, and additional data field coverage for some of our most popular supported systems.

Announcing our first ATS integration

In response to growing customer demand, we’ve officially launched the Finch applicant tracking system (ATS) API, and our first ATS integration, Lever, is live!

Because applicant tracking systems house crucial insights into an organization’s recruiting pipeline, seamless ATS data connectivity is essential to B2B applications that service the candidate lifecycle. To unlock a range of high-value use cases in product categories like candidate sourcing, compensation management, and DEI, our ATS API supports four data models: candidate, applications, jobs, and offers.

Reach out to get early access!

BambooHR OpenID Connect

As part of our strategic partnership with BambooHR, Finch customers can now leverage BambooHR’s OpenID Connect to establish data connections with the fast-growing HRIS.

OpenID Connect is a reliable authorization method that acts as a simple identity layer on top of the OAuth 2.0 protocol. By working through BambooHR’s OpenID Connect flow, we’re making it even more seamless and intuitive for your users to permission a data sync between your application and BambooHR.

Expanded field support

Deduction Types

Building on the headway we made in August, Finch now proudly supports Section 125 medical, dental, and vision deduction typing for ADP Run, PrismHR, and UKG Pro. This level of granularity fuels innovative customer use cases related to deduction management, tax credit calculations, and more. You can find them displayed in the employee_deductions[].type field on our /pay-statements endpoint.

Employer Benefits Contributions

For Trinet and Zenefits, you can now view employers’ benefit contributions—like 401(k) matches—in the pay-statements field, which provides essential visibility for retirement benefits providers.

Gender

The gender field is now supported in Rippling, ensuring that developers building products that analyze pay disparities and DEI issues have crucial data access for a significant segment of their customer base.

Class Code

In continued support of workers’ compensation insurance use cases, the class_code field  is now available through the employment endpoint in Trinet—adding to the list of systems we previously rolled out support for in September.

This field identifies the type of work an employee performs, enabling insurance companies to more accurately assess risk and calculate premiums for employers. Please note that 14 states operate with a class code system independent of the National Council on Compensation Insurance (NCCI) standard. Cross-referencing each employee’s work location with the class_code field is important to properly interpret this datapoint for insurance products.

That's all for October! Stay on the lookout for our next monthly product update. If you want to get your hands on the latest and greatest Finch features sign up for free access here.

This month’s updates include a partnership with exciting implications, an alternative auth protocol, and a host of new supported data points.

HiBob partnership and upgraded integration

In November, we were thrilled to announce our deeper partnership with HiBob. With that partnership, our HiBob integration has gotten a facelift.

Now, employers who want to connect their HiBob account to a third-party can authenticate directly through Finch Connect to generate a long-lasting API token that queries the HiBob API without the user exiting our front-end modal. Alternatively, employers using SSO will be able to walk through a quick set of instructions that lets them directly generate the API token from within the HiBob dashboard. This will then be shared with Finch, completing the authentication process.

Authenticating via Paylocity API

The more than 33,000 U.S. employers who use Paylocity to run their payroll and HR functions are the new beneficiaries of an exciting product feature: alternative auth via API token.

In other words, employers looking to link their Paylocity account to another application will have the option to do so directly with API credentials, for an ultra secure and reliable connection.

The new option is presented to employers who select Paylocity as their provider in our front-end modal as an alternative to the default Finch Connect flow. Once they follow the process outlined by Paylocity, employers will receive a set of API keys which can then be securely shared via Finch Connect.

Expanded field support

• Employees’ legal names are not always how they refer to themselves, and, in some cases, can even be in conflict with their identity. New support for preferred_name in our Paychex API integration allows applications using Finch to distinguish the two.
• In other news, our Justworks integration now covers gender, an essential datapoint for workplace equity and compensation strategy use cases, to name a few.
• Added support for department and employment.location for our assisted Paytime integration.

That's a wrap for November! If you haven’t already, be sure to sign up for free access to put our latest features to work for you.

This month’s updates include support for custom fields, which unlocks a multitude of use cases, and ethnicity, which employers can use to track progress on initiatives such as DEIB.

Custom fields unlocks edge cases

Custom fields has consistently been one of our most requested features with a multitude of use cases, ranging from capturing employee t-shirt sizes, to recording eligibility for fringe benefits, to storing data such as variable compensation targets. ​​Finch defines custom fields as fields created by employers which do not yet exist in the system, and we’re happy to announce that custom field support is now available for the following systems with expanded availability across more platforms later next year:

• ADP Workforce Now
• Gusto
• Justworks
• Paylocity (support for both credential & API auth)
• Quickbooks
• Zenefits (support for both credential & API auth)
  

While the range of data in these fields can vary, we already see multiple use cases leveraging common fields to drive a better employer experience.

• Compensation management platforms gather variable compensation and OTE to build more comprehensive compensation benchmarks for roles that are commission based.
• Learning management systems use education and certification data to recommend various training modules that better fit the skill levels of each individual employee.
• Benefits administrators review benefits selection data to better understand utilization across an organization.
• Expense managers track travel and expense (T&E) allowances and build approval flows when spend exceeds those amounts with minimal manual input.
• Performance management systems match project data with goals and internal objectives to identify key stakeholders across the team.
  

Read the developer docs to learn more about the custom fields addition to the “employment” endpoint.

Ethnicity data provides insight into organizational diversity

Ethnicity is a valuable datapoint that organizations aim to track to provide leadership and HR teams insights into workplace metrics such as diversity, hiring (recruitment, applications, interviews, and job offers), compensation, performance, and employee engagement. And now, it is also a field that is supported by Finch in the following HRIS systems:

• ADP Workforce Now
• BambooHR
• Justworks
• Paylocity
• Paychex
• Trinet
  

Similar to custom fields, developers use ethnicity data to deliver deeper insights into an organization. Here are a few use cases that benefit from the additional granularity Finch provides:

• Compensation management platforms layer on ethnicity data to equity of compensation across an organization and identify potential biases.
• DEIB solutions track ethnicity across the entire organization, departments, and individual teams to hold hiring managers accountable to targets.
• Performance management systems monitor ethnicity and compare it against career development to gain insight into equitable career growth paths and potential biases within teams.
  

Learn more about the ethnicity addition to the “individual” endpoint.

That's a wrap for December! If you haven’t already, be sure to sign up for free access to put our latest features to work for you.