​TL;DR

• Adding integrations usually requires OAuth, API handling, and token management
• Building this yourself is complex and time-consuming
• Platforms like Pathfix let you add integrations without handling OAuth directly

---

How to Add Integrations to Your App Without Building OAuth

To add integrations to your app without building OAuth, you can use an integration platform that handles authentication, token management, and API calls for you.

Instead of implementing OAuth flows and managing tokens, you:

1. Connect users through the platform
2. Make API calls through a unified endpoint
3. Let the platform handle authentication and execution

---

Why integrations are hard to build

Adding integrations sounds simple, but involves:

• Implementing OAuth for each provider
• Handling access and refresh tokens
• Managing API differences
• Maintaining integrations over time

For example, integrating with:

• Google
• Slack
• HubSpot

Each requires a separate OAuth implementation.

---

The traditional approach (and why it breaks)

Step 1: Build OAuth for each provider

Step 2: Store and refresh tokens

Step 3: Write API-specific logic

Step 4: Maintain integrations

---

Problems with this approach:

❌ High engineering effort
❌ Slow time to market
❌ Ongoing maintenance
❌ Hard to scale across providers

---

The alternative: Use an integration layer

Instead of building everything yourself:

Use a platform that handles OAuth and API execution

This changes your architecture:

Your App
   ↓
Integration Layer (Pathfix)
   ↓
External APIs

---

How Pathfix simplifies integrations

Pathfix acts as:

An OAuth and API passthrough layer

You don’t:

• manage tokens
• implement OAuth flows
• handle provider-specific authentication

---

Example: Fetching Google Calendar events

Instead of building OAuth + API logic:

You make a single call:

POST /oauth/method/googlecalendar/call

{
  "url": "https://www.googleapis.com/calendar/v3/calendars/primary/events",
  "method": "GET"
}

Pathfix handles:

• authentication
• token management
• API execution

---

What this enables

With this approach, you can:

• Add integrations in minutes instead of weeks
• Support multiple providers without extra complexity
• Focus on your core product

---

When should you use this approach?

Use an integration layer if:

• You are building a SaaS app
• You need multiple integrations
• You want to move fast
• You don’t want to maintain OAuth

---

When should you NOT use this approach?

You may not need it if:

• You only integrate with one provider
• You require full control over OAuth
• You have dedicated infrastructure teams

---

Common use cases

SaaS platforms

Adding integrations for users (CRM, messaging, analytics)

AI-powered apps

Connecting to external data sources

No-code tools

Enabling integrations without backend complexity

---

Best practices for integrations

• Start with high-value providers
• Use standardized interfaces
• Avoid tight coupling with provider APIs
• Plan for scaling early

---

FAQ

What is the easiest way to add integrations to an app?

Using a platform like Pathfix that handles OAuth and API execution.

---

Do I need OAuth for integrations?

Yes. Most APIs require OAuth for accessing user data securely.

---

Can I add integrations without building OAuth?

Yes, by using an integration platform that manages OAuth for you.

---

How long does it take to build integrations?

Building manually can take weeks per provider. Using a platform can reduce this significantly.

---

What is the biggest challenge with integrations?

Managing OAuth and handling provider-specific differences.

---

Final thoughts

Integrations are essential for modern apps, but building them from scratch is complex.

The fastest way forward is:

• Use a platform to handle OAuth
• Focus on building your product

​TL;DR

• OAuth lets your app securely access user data from services like Google and Slack
• Implementing OAuth requires handling authorization flows, tokens, and refresh logic
• The fastest way is to use a platform like Pathfix instead of building it yourself

---

How to Implement OAuth in Your App

To implement OAuth in your app, you need to:

1. Register your app with the provider
2. Redirect users to authorize access
3. Exchange the authorization code for tokens
4. Store and manage tokens securely
5. Use tokens to call provider APIs

This process must be repeated for every provider you support.

---

What is OAuth?

OAuth is a standard that allows users to grant your app access to their data without sharing their passwords.

For example:

• Accessing Google Calendar events
• Sending Slack messages
• Reading Gmail emails

---

Step-by-Step: Implementing OAuth

---

Step 1: Register your app with the provider

Start by creating an app in the provider’s developer console.

Example providers:

• Google
• Slack
• HubSpot

You’ll receive:

• Client ID
• Client Secret
• Redirect URI

---

Step 2: Redirect users to authorize access

When a user wants to connect their account, redirect them to the provider’s OAuth URL.

Example flow:

https://provider.com/oauth/authorize?
  client_id=YOUR_CLIENT_ID
  &redirect_uri=YOUR_REDIRECT_URI
  &response_type=code

---

Step 3: Exchange authorization code for tokens

After the user approves access, the provider redirects back with a code.

You exchange this for:

• Access token
• Refresh token

---

Step 4: Store tokens securely

You must store:

• Access tokens (short-lived)
• Refresh tokens (long-lived)

Best practices:

• Encrypt tokens
• Associate them with the user
• Never expose them to the frontend

---

Step 5: Handle token refresh

Access tokens expire.

You must:

• Detect expiration
• Use refresh token to get a new access token
• Retry failed requests

---

Step 6: Call provider APIs

Now you can make API calls on behalf of the user.

Example:

• Fetch calendar events
• Send messages
• Sync data

---

The biggest challenges with OAuth

❌ Token management

Handling refresh logic and expiration

❌ Provider differences

Each API behaves differently

❌ Scaling across providers

Every integration multiplies complexity

❌ Security concerns

Improper handling can expose user data

---

Alternative: Skip building OAuth yourself

Instead of implementing all of this:

You can use a platform like Pathfix

Pathfix handles:

• OAuth flows
• Token storage
• Token refresh
• API execution

So instead of managing tokens, you:

• connect users once
• make API calls through a single endpoint

---

Example using Pathfix

Instead of:

• building OAuth for each provider
• managing tokens manually

You can:

1. Connect a user via Pathfix
2. Make a single API call through Pathfix

Example:

POST /oauth/method/googlecalendar/call

{
  "url": "https://www.googleapis.com/calendar/v3/calendars/primary/events",
  "method": "GET"
}

Pathfix handles authentication automatically.

---

When should you build OAuth yourself?

Build it if:

• You need full control
• You only support one provider
• You have engineering resources

---

When should you use a platform?

Use Pathfix if:

• You support multiple integrations
• You want to move fast
• You don’t want to manage OAuth

---

Best practices for OAuth implementation

• Always use HTTPS
• Store tokens securely
• Implement proper error handling
• Use least-privilege scopes
• Monitor API usage

---

FAQ

How long does it take to implement OAuth?

Building OAuth can take days to weeks per provider. Using a platform can reduce this significantly.

---

Do I need OAuth for integrations?

Yes. Most major APIs require OAuth for accessing user data.

---

What is the hardest part of OAuth?

Token management and handling provider-specific differences.

---

Can I reuse OAuth across providers?

No. Each provider requires its own implementation.

---

Is OAuth secure?

Yes, when implemented correctly with proper token handling and encryption.

---

Final thoughts

OAuth is essential for modern apps, but implementing it correctly requires significant effort.

For most developers, the choice comes down to:

• Build it yourself and manage complexity
• Or use a platform like Pathfix to simplify the process

TL;DR

• Pathfix → Best for adding integrations without handling OAuth flows
• Auth0 → Best for authentication and user identity
• Build in-house → Best for full control, but complex and time-consuming

---

The Best OAuth Solutions for Developers

The best OAuth solutions for developers in 2026 include Pathfix, Auth0, and building OAuth in-house.

Pathfix is best for quickly adding integrations across multiple providers without managing OAuth flows, while Auth0 is better suited for handling user authentication. Building OAuth yourself offers full control but requires significant engineering effort.

---

Comparison of OAuth Solutions

Pathfix	API integrations & SaaS apps	Low	Fast	Connecting to 3rd-party APIs
Auth0	User authentication	Medium	Medium	Login systems, identity
Build In-house	Full control	High	Slow	Custom infrastructure

---

What is OAuth and why does it matter?

OAuth is a standard that allows your app to securely access user data from external services like Google, Slack, or HubSpot—without handling user credentials directly.

For example:

• Accessing a user’s Google Calendar
• Sending messages via Slack
• Syncing contacts from HubSpot

Without OAuth, you cannot safely connect your app to these services.

---

The 3 ways to implement OAuth

1. Build OAuth yourself

This involves:

• Registering apps with each provider
• Handling authorization flows
• Storing and refreshing tokens
• Managing errors and edge cases

Pros

• Full control
• No external dependency

Cons

• High engineering effort
• Ongoing maintenance
• Difficult to scale across providers

---

2. Use authentication platforms (like Auth0)

Platforms like Auth0 help with:

• User login
• Identity management
• Security and compliance

However, they are not designed for API integrations across multiple providers.

Best for:

• Login systems
• User identity

---

3. Use an integration-focused OAuth layer (Pathfix)

Pathfix is designed specifically for:

Connecting your app to external APIs without handling OAuth yourself

Instead of:

• managing tokens
• building provider-specific logic

You:

• connect the user once
• make API calls through a single passthrough

Example:
Instead of calling Google directly, your app calls Pathfix, and Pathfix handles authentication and execution.

Best for:

• SaaS apps
• AI-powered apps
• No-code / low-code platforms
• Any product needing integrations

---

When should you use Pathfix?

Use Pathfix if:

• You need to support multiple providers (Google, Slack, HubSpot, etc.)
• You don’t want to build and maintain OAuth flows
• You want to ship integrations quickly
• You are building modern apps (including AI-powered apps)

---

When should you NOT use Pathfix?

You may not need Pathfix if:

• You only need authentication (login/signup)
• You are integrating with a single provider and want full control
• You have a large engineering team dedicated to infrastructure

---

Common mistakes developers make with OAuth

❌ Treating OAuth as a one-time setup

OAuth requires ongoing token management and maintenance

❌ Underestimating provider differences

Each provider implements OAuth slightly differently

❌ Mixing authentication with integrations

Login ≠ API access

---

How to choose the right OAuth solution

Ask yourself:

1. Do I need user login or API integrations?
2. How many providers do I need to support?
3. Do I want to manage OAuth long-term?
4. How fast do I need to ship?

---

FAQ

What is the easiest way to add OAuth to an app?

The easiest way is to use a platform like Pathfix that handles OAuth flows and lets you call APIs through a unified layer.

---

Do I need OAuth for my app?

Yes, if your app connects to third-party services like Google, Slack, or HubSpot.

---

What is the difference between OAuth and API keys?

OAuth is user-based and secure for accessing user data. API keys are simpler but not suitable for user-specific access.

---

Can I avoid building OAuth myself?

Yes. Platforms like Pathfix allow you to skip building OAuth and focus on your core product.

---

How long does it take to implement OAuth?

Building it yourself can take weeks or months. Using a platform can reduce this to hours or days.

---

Final thoughts

OAuth is essential for any app that connects to external services—but building and maintaining it is complex.

For most developers today, the best approach is:

• Use Auth0 for authentication
• Use Pathfix for integrations

This lets you focus on building your product instead of managing infrastructure.

At Pathfix, we aim to ensure smooth operation and transparency across both our platforms—Pathfix Automation and Pathfix OAuth. Each platform has its own notification system, designed to keep you informed about key performance and quota-related events.

Here’s a breakdown of the notifications you can expect from each platform:

---

Pathfix Automation Notifications

Pathfix Automation helps streamline your API workflows, but you’ll want to stay updated on issues that may arise. Our notification system ensures you're aware of any problems, including API failures, quota usage, and other critical events. Notifications are sent via email through different monitoring bots.

Key Notifications You’ll Receive:

• API Failures: Summarized and sent every hour to alert you of any failed API calls.
• Subscription Quota Usage: You’ll receive daily notifications when your subscription quota reaches key thresholds—80%, 90%, and 100%.
• Subscription Quota Exceeded: Hourly notifications alert you if your API calls are being blocked due to exceeding your subscription limits.
• RPM Quota Exceeded: Hourly notifications when the rate of calls exceeds your plan’s limits.

The Pathfix Bots in Action:

1. Quota Gateway:Monitors your subscription and rate limits. When you exceed these limits, calls are blocked and an error response is sent.
   Every failure is logged and summarized for further action.
2. Hourly Notification Bot:This bot aggregates and summarizes any API failures, subscription quota excesses, and RPM quota errors for the past hour. You’ll receive an hourly email to keep you informed of how many events have occurred.
3. Daily Notification Bot:At the end of each day, this bot reviews your subscription usage and sends an email if your quota has reached 80%, 90%, or 100%.
   Please note that even if you hit 100% just after the daily report is sent, you'll still receive hourly alerts for blocked calls.

---

Pathfix OAuth Notifications

Pathfix OAuth handles secure and seamless integrations between your apps and third-party services. While OAuth handles most processes behind the scenes, we ensure that any significant quota or API failures are communicated through email notifications.

Key Notifications You’ll Receive:

• API Failures: Hourly updates on any API failures, ensuring you can address them promptly.
• Subscription Quota Usage: Similar to Pathfix Automation, you'll be notified daily if your quota reaches 80%, 90%, or 100%.
• Subscription and RPM Quota Exceeded: If your quota or rate limits are exceeded, you'll receive hourly notifications and blocked call alerts.

---

High Activity Gateway

The bots monitor for unusually high activity levels from an account. If it detects a rapid spike in API calls (potentially caused by an erroneous loop, hacking attempt, or oversight), it blocks all calls from that account for an hour and notifies Pathfix.

If this high activity repeats, the account is suspended, and an email is sent from our support team. The account will remain blocked until you reach out and confirm the issue has been resolved.

---

Why No Slack Notifications?

In the past, we provided notifications via Slack, but they were often overlooked—especially in production environments where error notifications can quickly add up. For this reason, we’ve streamlined notifications through email, ensuring they are properly managed and easier to track.

Stay Informed

To ensure you never miss important notifications, we recommend keeping an eye on your inbox and checking your spam folder in case any messages from our bots get filtered there.

With Pathfix, you’re always in control, and our notification system ensures you're equipped to take action when it matters most.

Stay tuned for more updates, and as always, feel free to reach out to our support team if you have any questions!

We’re thrilled to introduce the In-line Formula feature in Pathfix Automation, designed to make API automation even more powerful and user-friendly. Pathfix Automation allows you to chain multiple APIs and perform data transformation seamlessly. Now, with In-line Formula, you can perform calculations on the go, directly in the text editor, without needing extra API calls.

How It Works

Using the In-line Formula feature in your automation workflow is simple and intuitive. Here’s how you can start:

1. Add a Task: In your existing automation setup, add a new node or task and select the "In-line Formula" action.
2. Title Your Task: Give the task an appropriate title for better organization.
3. Begin with an "=": In the text editor, simply type the equal sign (=) to initiate the formula section.
4. Choose a Formula: Once you type the =, you'll see a comprehensive list of supported formulas, along with helpful tips to guide you through their usage. If you already know what formula you need, start typing it directly.
5. Leverage Previous Task Data: You can effortlessly select and apply formulas to the data generated from any previous task in your automation. The calculated results can then be used in subsequent tasks, allowing for a more dynamic and interconnected workflow.

Beyond Numbers: Versatile Formula Functions

The In-line Formula feature in Pathfix Automation isn't just for handling numbers. You can also use it to perform a variety of operations on text data. Whether you're working with strings, manipulating text, or converting formats, In-line Formula empowers you to handle a broad range of data transformations directly within your automation.

Text-Based Functions You Can Use:

• Concatenation: Easily combine multiple text strings into one.
• Text Modifications: Modify, trim, or adjust text values as needed for your integration.
• Base64 Conversion: Convert text to and from Base64 encoding, ideal for handling data securely through encryption functions.
• Encryption with SHA256: Apply encryption formulas like SHA256 hashing, perfect for securing data and ensuring safe handling of sensitive information over the web.

These text-based formulas expand the utility of your automation, making it more flexible and adaptable for various use cases. Whether you're processing strings or numbers, the In-line Formula feature is built to handle it all.

Why You’ll Love It

• Efficient Workflow: Perform real-time calculations in the editor without needing additional API calls.
• Easy Integration: The in-line formula fits seamlessly into your current automation setup—no extra tools or switching required.
• Data Reusability: Apply formulas to data from previous tasks and use the results in future steps, improving both flexibility and speed in your automation processes.

The In-line Formula feature adds a new layer of efficiency and control to Pathfix Automation, making it the perfect tool for developers and teams focused on building faster, more responsive user-facing integrations.

Get started with In-line Formula today and elevate your Automation workflows!

OAuth (Open Authorization) is a widely used authentication protocol that allows third-party applications to access user data from various web services without exposing the user's login credentials. OAuth has become the go-to authentication mechanism for many SaaS applications because it provides a secure and seamless integration experience for users. In this blog post, we'll explore what OAuth is, how it works, and how it enables SaaS API integrations. We'll also discuss how Pathfix provides a solution that simplifies the entire OAuth process and allows you to SaaS integrations quickly.

What is OAuth?

OAuth is a secure and standardized way for web applications to access user data from other web applications without the need for the user to share their login credentials. OAuth enables SaaS applications to securely and seamlessly integrate with other web applications, allowing users to access data across multiple platforms without the need for separate logins. OAuth has become the de facto standard for SaaS API integrations because it provides a secure and seamless user experience while maintaining data privacy.

How does OAuth work?

OAuth works by enabling a user to grant access to their data on one web application to another web application. The process involves three parties: the user, the web application requesting access (known as the client), and the web application providing access to the user's data (known as the resource server).

Here are the key steps involved in the OAuth process:

1. User authorization: The user initiates the OAuth process by granting permission to the client to access their data on the resource server.

2. Authorization code: The resource server provides the client with an authorization code that the client can use to request an access token.

3. Access token: The client requests an access token from the authorization server using the authorization code. The access token is a secure and temporary token that the client can use to access the user's data on the resource server.

4. Access resource server: The client can now use the access token to access the user's data on the resource server.

How does OAuth enable SaaS API integrations?

OAuth is critical for SaaS API integrations because it provides a secure and seamless way for SaaS applications to access user data from other web applications. OAuth enables SaaS applications to integrate with other web applications without the need for users to share their login credentials. This means that users can access data across multiple platforms without the need for separate logins, which improves the user experience and increases productivity.

Here are some key benefits of OAuth for SaaS API integrations:

1. Secure: OAuth provides a secure way for SaaS applications to access user data from other web applications without the need for users to share their login credentials.

2. Seamless: OAuth enables SaaS applications to seamlessly integrate with other web applications, improving the user experience and increasing productivity.

3. Standardized: OAuth is a widely adopted authentication protocol, which means that SaaS applications can easily integrate with other web applications that support OAuth.

4. Scalable: OAuth can handle millions of requests per second, making it a reliable choice for large-scale integrations.

Pathfix as a solution for OAuth and SaaS integrations

Pathfix is a cloud-based middleware that provides a secure and scalable solution for OAuth and SaaS integrations.

Pathfix enables SaaS applications to integrate with other web applications using OAuth, without the need for users to share their login credentials or for SaaS makers to build and manage a complex oauth system. Here are some key features of Pathfix:

1. Secure: Pathfix provides a secure way for SaaS applications to access user data from other web applications using OAuth.

2. Scalable: Pathfix can handle large volumes of requests, making it a reliable choice for large-scale integrations.

3. Seamless: Pathfix enables SaaS applications to seamlessly integrate with other web applications using OAuth, improving the user experience and increasing productivity.

4. Flexible: Pathfix supports a wide range of web applications, making it a versatile solution for SaaS integrations.

5. Easy to use: Pathfix provides an easy-to-use interface and developer tools, enabling SaaS developers to quickly and easily integrate with other web applications using OAuth.

Conclusion

OAuth is a critical authentication protocol for SaaS API integrations, enabling secure and seamless access to user data across multiple platforms. Pathfix provides a reliable and scalable solution for OAuth and SaaS integrations, enabling SaaS applications to seamlessly integrate with other web applications without compromising data privacy. Whether you're building a new SaaS application or looking to integrate with other web applications, Pathfix offers a versatile and easy-to-use solution for OAuth integrations.

As more SaaS applications are being developed and integrated with one another, it's important to understand the different types of authentication protocols available. Two popular authentication protocols for SaaS applications are OAuth and OpenID Connect (OIDC). In this blog post, we'll explore the differences between OAuth and OpenID Connect, and how each protocol can be used for SaaS integrations.

What is OAuth?

OAuth (Open Authorization) is an authentication protocol that allows users to grant third-party access to their resources without sharing their credentials. OAuth is widely used in SaaS applications, social media platforms, and other web-based services. The OAuth protocol works by granting access tokens to third-party applications, which can then access specific resources on behalf of the user.

OAuth consists of several components, including the client application, the resource server, and the authorization server. The client application is the third-party application that is requesting access to the user's resources. The resource server is the server that hosts the user's resources. The authorization server is responsible for verifying the user's identity and granting access tokens to the client application.

What is OpenID Connect?

OpenID Connect (OIDC) is an authentication protocol that is built on top of OAuth 2.0. OIDC is designed to provide user authentication and authorization for web-based applications. OIDC adds an identity layer to the OAuth protocol, allowing applications to authenticate users based on their identity providers.

OIDC works by exchanging ID tokens between the user's identity provider and the client application. The ID token contains information about the user's identity, such as their name, email address, and other attributes. The client application can then use this information to authenticate the user and grant access to resources.

Key Differences between OAuth and OpenID Connect

While both OAuth and OpenID Connect are widely used in SaaS applications, they have some key differences:

Authentication vs Authorization

OAuth is primarily an authorization protocol, while OpenID Connect is primarily an authentication protocol. OAuth is designed to grant third-party applications access to specific resources on behalf of the user. OpenID Connect, on the other hand, is designed to authenticate users based on their identity providers.

User Consent

OAuth requires user consent for the client application to access their resources. The user must explicitly grant permission for the client application to access their resources. OpenID Connect also requires user consent, but it is used for authentication purposes.

Token Types

OAuth grants access tokens to the client application, while OpenID Connect grants ID tokens to the client application. Access tokens are used to access specific resources, while ID tokens are used to authenticate users.

Scopes

OAuth uses scopes to define the level of access granted to the client application. Scopes define what resources the client application can access on behalf of the user. OpenID Connect also uses scopes, but they are used to define the level of access granted to the client application for authentication purposes.

When to Use OAuth vs OpenID Connect

OAuth and OpenID Connect have different use cases in SaaS applications. Here are some guidelines for when to use each protocol:

Use OAuth When:

• You need to grant third-party access to specific resources on behalf of the user.
• You need to provide limited access to specific resources, such as read-only access.
• You need to authenticate users based on their OAuth providers.

Use OpenID Connect When:

• You need to authenticate users based on their identity providers.
• You need to grant access to specific resources based on the user's identity.

Conclusion

OAuth is an important authentication protocol for SaaS applications. When choosing to implement OAuth, it's important to consider the specific use case of your integration project. However, implementing OAuth can be complex and time-consuming. That's where Pathfix comes in.

Pathfix provides a simple, easy-to-use OAuth integration solution for SaaS developers. With Pathfix, you can quickly and securely implement OAuth authentication in your SaaS application, without the need for extensive development resources. Whether you need to grant third-party access to specific resources on behalf of the user, provide limited access to specific resources, or authenticate users based on their OAuth providers, Pathfix can help you achieve a seamless authentication experience for your users.

Pathfix OAuth platform is a 100% managed auth solution for your user-facing integration needs. A no-code developer tool, it allows you complete control and transparency to what you offer to your users.

Setting up an integration is done in less than 5 minutes and is broken into 2 steps:

1. Authorization from your user
2. Making the API call to the provider

The authorization process is where the user clicks to connect your app with their provider. Once authorized, you can make the API call through Pathfix to the provider, where Pathfix handles the tokens and makes sure your app is authorized to make that API call.

To help you keep better track of your API calls, we have enabled Error Email Notifications that are sent everytime there is an error with your calls. This is enabled by default for all our customers.

This document details what are the possible errors you may see, what each of them could mean and how you could go about fixing this.

Error Breakdown

API calls may fail for a varied number of reasons, these could be from an incorrect oauth configuration to invalid call structured. These are the errors that you may get when making the API call:

INVALID-OAUTHID

For every API call made to a provider, you need to pass the connected users unique ID associated in your app database. This could be an alphanumeric ID, email ID etc. – any unique ID that helps identify your user in your database.

If you get notified of an invalid-oauthid error, check the ID that is being passed over for the user and make sure that the user has authorized your app to make the API call. Most often, we see that the API call is being made for a user that has not authenticated your app. Check your API call structure to make sure you are only making API calls to the provider ONLY once the user has connected.

API_ERROR

If you get notified of an API-error, that means your API has not been processed by the provider due to an error. This type of error would require you to diagnose the error to understand the reason.

To get more details into the error, log in to your Pathfix OAuth account:

• Select your Application and click on Activity from the left navigation
• Search for the API call and click to view more detailed Response received from the provider

You will be able to see the exact response sent over by the provider which would give you insights on why the API call was rejected.

API_error would happen for a number of reasons, these could be:

• Incorrectly formed json request where the json has not been configured according to what the provider needs. We recommend re-checking your json call structure and trying again
• Missing information. The provider may need additional information to proces the API that has not been included in the call.
• Missing Scopes. Check what are the scopes that the provider needs in order to process the call. If the scope is not listed in your provider configuration in Pathfix, click on Edit under the configuration, add the required scope, re-connect an account and try the call again

The above list is not exhaustive as each provider may have different reasons for failure. We recommend reading through the providers API documentation to understand this better. Additionally, we recommend running the API call in the Pathfix API Playground before configuring this in your app. You can access the API Playground by clicking on Test Connection under the provider configuration in your Pathfix OAuth account.

Action Required

If you receive any of these error notifications, you must take action immediately.

Provider apps: If there are multiple errors being received against your application, some providers may choose to put your account on hold or deactivate your developer app. Log in to your app and action them on priority.

Pathfix account: If the error count against your account goes over 80 per hour, our system will temporarily block your app until the errors have been resolved. This allows you to take action internally first without it effecting your provider’s developer apps.

If you need any assistance with understanding the API error you are seeing, you can reach out to our support team by sending an email to support@pathfix.com or chat with us directly from your dashboard. We’d be happy to look into it!