November 2025 Summaries
77 posts from Nango
Filter
Month:
Year:
Post Summaries
Back to Blog
In the competitive landscape of SaaS product integrations, there are two main solutions: Embedded iPaaS, which requires building each integration individually using low-code platforms like Zapier, and unified APIs, which offer pre-built integrations accessible through a single API. While embedded iPaaS platforms are known for their cumbersome workflows and limited pre-built steps, unified APIs streamline the process by enabling integration once for multiple use cases. However, traditional unified APIs can be restrictive, with limited API coverage, customization options, and visibility into integrations. Nango emerges as a comprehensive integrations platform that combines the best of both worlds by providing a large catalogue of pre-built use cases and allowing easy customization and extension of integrations. With its open-source nature, Nango supports a wide array of APIs and offers full visibility and advanced tooling for developers, making it a future-proof and developer-friendly solution.
Nov 25, 2025
866 words in the original blog post.
Native product integrations are essential for B2B SaaS companies, with platforms like Prismatic offering solutions to streamline this process. However, alternatives such as Nango, Merge.dev, and Tray Embedded present different approaches. Nango is an open-source platform favored for its extensive catalog of integrations, developer-friendly features, and robust support, catering to firms prioritizing developer experience over low-code configurability. Merge.dev provides a unified API model that simplifies integration but at the cost of customization, appealing to those seeking quick setups. Tray Embedded focuses on low-code/no-code solutions, offering a customizable workflow for enterprise clients. Despite these options, some companies still prefer building integrations in-house for full control, though this requires significant time and resources. Each choice depends on the specific needs of a company, whether it prioritizes speed, flexibility, or developer ease.
Nov 25, 2025
1,817 words in the original blog post.
AI agents are revolutionizing automation by transforming business operations, but their success heavily depends on robust authentication infrastructure to interact with real-world APIs. AI agent authentication involves users granting secure access to their data in external software systems, typically managed through OAuth flows, API keys, or other methods. Effective platforms for AI agent authentication should offer a comprehensive catalog of pre-built APIs, white-label capabilities, easy extensibility, user guides, and avoid vendor lock-in. Among the top platforms, Nango stands out with extensive API coverage and open-source flexibility, Arcade specializes in AI agent tool calling but has limited API support, and Auth0 provides secure token storage and integration with popular AI frameworks but is currently in public beta with limited API coverage. Choosing the right authentication platform is crucial for scaling products, maintaining security, and building desired integrations, with each platform offering unique strengths tailored to different needs.
Nov 25, 2025
896 words in the original blog post.
In the evolving B2B SaaS landscape, native product integrations are essential for rapid delivery and minimized engineering effort, with various alternatives to Codat being explored for 2024. Nango emerges as a prominent open-source platform, offering a broad catalog of pre-built integrations, a developer-first experience, and self-hosting options, making it appealing to over 400 B2B SaaS companies. Tray Embedded, an add-on for Tray.io, provides a low-code/no-code interface for custom integration flows, though it may not be ideal for engineering teams seeking extensive API support. Apideck offers pre-built unified APIs and a marketplace product, focusing on quick deployment but limited customization. Some companies still opt to build integrations in-house for greater control, despite the significant time and maintenance required. These in-house solutions allow for full flexibility and future-proofing but pose challenges such as high maintenance demands and scalability concerns. Each alternative presents unique benefits and drawbacks, guiding organizations in selecting the most suitable integration approach based on their specific needs and priorities.
Nov 25, 2025
1,708 words in the original blog post.
OAuth 2.0 addresses security concerns by using short-lived access tokens that require periodic refreshing with refresh tokens, but this introduces challenges such as concurrency issues in handling token refreshes. When multiple processes attempt to refresh tokens simultaneously, it can lead to race conditions, resulting in expired or invalidated tokens, causing API failures and requiring users to re-authenticate. Different APIs handle token refreshes in varied ways, affecting the concurrency problem's manifestation. Detecting these issues involves recognizing symptoms like temporary API failures, refresh token revocation errors, and inconsistent token expiration behavior, which often occur under high load. Implementing locking mechanisms, such as in-memory locks for single-instance applications or distributed locks with Redis for multi-instance setups, can help manage these concurrency challenges. Optimizations like token caching and retry logic on 401 errors can further enhance performance. To prevent issues like refresh token expiration and to handle refresh failures appropriately, robust error handling and user re-authentication flows are essential. Tools like Nango can automate and simplify OAuth token management across multiple APIs, minimizing the complexities involved in building and maintaining integrations.
Nov 25, 2025
1,829 words in the original blog post.
In late August 2022, co-founders faced a pivotal realization that their product lacked market validation, despite investing weeks into its development. This experience highlighted the challenge of pre-product validation, leading them to pivot their focus towards refining their positioning by emphasizing effective messaging and differentiation. By examining successful strategies from peers and competitors, they attempted to adapt the API aggregator model for a niche market, yet initial market feedback remained lukewarm. Despite frustrations, the founders leveraged their deep market insights to identify a gap in integration solutions, resulting in the creation of Nango Sync, which resonated strongly with the target audience and quickly gained traction. Their journey underscored the importance of persistence, iterative learning, and maintaining focus on solving the core problem, ultimately achieving a product-market fit that brought significant engagement and satisfaction.
Nov 25, 2025
1,294 words in the original blog post.
Merge offers a unified API platform designed to streamline integrations across various categories such as HRIS, accounting, CRM, and ticketing, promising faster deployment with less engineering effort. However, its pricing model is largely opaque and can become costly, particularly for companies where integrations are a core product feature. Merge requires annual contracts with capacity-based pricing, which could lead to overcommitment and unnecessary expenses, and many essential features are restricted to its Enterprise plan. In contrast, Nango provides a transparent and flexible pricing model with monthly contracts, usage-based fees, and no hidden costs, allowing companies to scale their integrations more economically and adaptively.
Nov 25, 2025
1,230 words in the original blog post.
The team at Nango has developed numerous API integrations using AI agents like Cursor and Claude Code, gaining insights into effective AI collaboration for integration development. AI excels in discovering and assembling API endpoints, generating boilerplate code, and performing straightforward data mapping, particularly with well-documented platforms. However, it struggles with less popular APIs, making subtle implementation errors, and handling complex authentication and infrastructure. Successful human-AI collaboration involves breaking down tasks, effective prompt engineering, iterative development, and using specialized tools and platforms like Nango for complex integration scenarios. By understanding AI's strengths and limitations and maintaining human oversight, teams can accelerate integration development while ensuring reliability and quality.
Nov 25, 2025
1,362 words in the original blog post.
Embedded iPaaS systems are designed to simplify the integration of products with external APIs by offering low-code/no-code solutions, but they often fall short in practice, primarily requiring engineers for effective implementation. These systems face limitations such as insufficient API coverage and a suboptimal developer experience. The text explores three alternatives to embedded iPaaS: building integrations in-house, using closed unified APIs, and employing open unified APIs. Building in-house offers complete control and customization but demands significant engineering resources and maintenance. Closed unified APIs simplify integration across multiple APIs but lack flexibility and customization. Open unified APIs, like Nango, combine the benefits of unified access with the ability to customize and extend integrations, though some understanding of external APIs is still necessary. The document suggests these alternatives offer more control, customization, and potentially reduced maintenance compared to embedded iPaaS, depending on the specific needs and resources of a company.
Nov 25, 2025
1,520 words in the original blog post.
Unified APIs offer a streamlined approach for integrating multiple external APIs through a single interface, which simplifies development and accelerates the integration process for AI agents or SaaS products. These platforms create universal data models for entities like "Employees" and "Companies," allowing for either shallow integrations or custom unified APIs to meet specific product needs. While pre-built unified APIs, such as those offered by Merge, Apideck, or Unified.to, are suitable for basic and broad integrations, they often lack the deep customization required for core product integrations. In contrast, platforms like Nango provide a customizable and code-driven approach, supporting over 500 APIs across various categories, which offers greater control and observability for complex use cases. However, building on platforms like Nango requires more upfront development and a steeper learning curve. The choice between pre-built and custom unified APIs should depend on the specific needs, capabilities, and goals of the development team, balancing the need for rapid deployment with the level of customization and functionality required.
Nov 25, 2025
1,615 words in the original blog post.
Integrating with external APIs requires a complex authentication process that can be deceptively deep, as experienced by a team that spent three years implementing authentication for over 400 APIs. OAuth, often mistaken for a protocol, presents challenges due to non-standard extensions and customizations by different APIs, which complicates debugging and implementation. API keys, while seemingly straightforward, pose usability issues for non-technical users and require extensive documentation, validation, and support. Custom authentication flows, like those from GitHub and Shopify, further complicate integration with their unique requirements and structures. Additionally, managing token refreshes, revoked credentials, and required parameters adds layers of complexity, necessitating careful handling of scopes, permissions, and security measures. Despite the availability of numerous libraries, most focus on user login and do not address the intricacies of accessing data across various APIs, leading the team to develop and open-source their own solution to address these needs comprehensively.
Nov 25, 2025
1,410 words in the original blog post.
Encountering the OAuth error "invalid_grant" is a common issue for those working with Salesforce APIs, often due to stale, revoked, or over-quota refresh tokens. This error, which can have various root causes such as expired tokens, incorrect client credentials, unsupported grant types, or changes in user status, requires users to re-authenticate to resolve. The potential reasons for token revocation include reaching the access token limit per user, immediate expiration policies, user or admin revocation of app access, or user password resets. To mitigate these issues, developers can follow best practices such as setting appropriate OAuth refresh token policies, scheduling regular token refreshes, discarding stale tokens, and monitoring for invalid_grant spikes. The introduction of refresh-token rotation in Salesforce's Spring 2024 release necessitates storing new refresh tokens as the old ones get revoked. Tools like Nango can automate the Salesforce OAuth token lifecycle, offering seamless access token refreshing, support for rotated refresh tokens, and real-time webhooks for token revocation alerts.
Nov 25, 2025
1,008 words in the original blog post.
Nango's journey in building developer infrastructure for product integrations highlights the importance of crafting powerful yet flexible abstractions, which are crucial for creating intuitive and effective tools that meet diverse user needs. Despite initial high-level solutions, Nango learned that offering lower-level control to clients was more successful for integrations, as it allowed for tailored solutions that fit seamlessly with existing product features. This realization came after extensive hands-on experience and iterations, which underscored the value of deep expertise and the need for iterative development to achieve product-market fit. The company's path was non-linear, involving multiple major iterations, each contributing to a deeper understanding of integration complexities and customer needs. Nango emphasizes that getting abstractions right from the start outweighs the conventional wisdom of rapid deployment, as it reduces rework and support overhead while providing a solid foundation for future developments. This experience is shared in hopes of aiding other teams in the developer infrastructure space, while also inviting potential contributors as they continue to grow their team.
Nov 25, 2025
930 words in the original blog post.
Embedded integration platforms, also known as embedded iPaaS, are crucial for building native integrations within AI or SaaS products by connecting them with external APIs that customers use. These platforms offer the infrastructure and tools needed for various integration forms, such as data syncs, AI tool calls, and webhook processing. While unified API platforms provide basic, broad integrations, embedded platforms excel in offering deep, custom integrations essential for a product's value. Key features to consider include API authentication, continuous data syncs, extensibility, and observability. Leading platforms like Nango, Prismatic, Albato, and Workato each have unique strengths and limitations. Nango, for example, offers extensive API support and developer control, whereas Prismatic and Albato focus on low-code solutions but have scalability and customization constraints. Workato provides a robust library of pre-built actions but is limited to simpler workflow patterns. Choosing the right platform involves balancing development speed with functionality, especially as the product evolves, and considering specific needs like AI integrations.
Nov 25, 2025
1,777 words in the original blog post.
API unification addresses the complexity of integrating multiple third-party APIs by providing a standardized interface, allowing integration logic to be written once for all providers. Integration platforms as a service (iPaaS) facilitate this process by offering the necessary infrastructure and tools. The text reviews top iPaaS options, each with distinct features and limitations. Nango, an open-source platform, offers full flexibility and control, allowing teams to create custom unified APIs. Merge provides pre-built unified APIs for quick deployment but lacks customization. Workato specializes in workflow automation with a visual builder but doesn't support unified APIs. Prismatic offers both low-code and code-first integration options but also lacks unified API support. Choosing an iPaaS depends on specific needs, team capabilities, and the goal of balancing development speed and functionality. The guide emphasizes that while unified APIs are beneficial for secondary integrations, direct integrations may be preferable for critical functionalities requiring deep, API-specific capabilities.
Nov 25, 2025
1,452 words in the original blog post.
Building a unified API for product integrations can enhance development speed and minimize maintenance challenges, but it requires careful consideration and implementation of best practices. Unified APIs are most effective when supporting similar core functionalities across multiple APIs with comparable data models, and it is recommended to start with a focused scope and expand gradually. Using an internal data model for the unified API ensures consistency and reduces complexity, while concept mapping remains a critical challenge. Not all integrations should be unified; for widely used systems, API-specific integrations may be more beneficial. Planning for extensibility, such as handling nullable properties and schema evolution, is crucial, along with maintaining a centralized unification logic. A robust technical foundation, including observability, data validation, and handling common challenges like rate limits and token refreshes, is essential for long-term success. While unified APIs can streamline development and maintenance, they are not a one-size-fits-all solution for integration challenges.
Nov 25, 2025
1,315 words in the original blog post.
Nango's team has extensively utilized AI agents like Cursor and Claude Code to develop API integrations, gaining insights into their effective use and limitations. AI excels in endpoint discovery and boilerplate code generation, especially with well-documented APIs such as Salesforce, HubSpot, or Stripe, by efficiently identifying endpoints and creating foundational code structures. However, AI struggles with poorly documented APIs, subtle implementation errors, and complex authentication scenarios, necessitating human oversight and intervention. Effective human-AI collaboration involves breaking down complex tasks, using precise prompt engineering, and adopting an iterative development process, with tools like Nango's dryrun command facilitating testing and validation. The guide emphasizes leveraging AI for endpoint discovery and code generation while relying on human expertise for infrastructure and authentication complexities, advocating for a balanced approach to integration development.
Nov 25, 2025
1,362 words in the original blog post.
Unified APIs offer a streamlined approach to integrating multiple third-party APIs by providing a single, consistent interface, thus simplifying the codebase and reducing maintenance burdens. While pre-built unified APIs are quick to implement, they often lack the flexibility required by specific use cases, prompting many B2B SaaS companies to develop custom unified APIs tailored to their needs. The primary benefits of unified APIs include simplified integration logic, centralized mapping, consistent error handling, and faster support for new APIs. However, they also pose challenges such as accommodating only the lowest common denominator of features across APIs, managing complex mapping logic, and handling discrepancies in data models. The decision to use unified APIs should consider the importance of the integration and whether specialized API functionality is required. Custom unified APIs are often preferred for their flexibility and adaptability, despite the increased development effort. Building a unified API requires careful planning, starting with defining interactions, data models, and implementing robust infrastructure. Leveraging tools like AI-powered development aids and integration platforms can accelerate development and enhance reliability, but it is crucial to design with long-term extensibility and maintainability in mind.
Nov 25, 2025
2,081 words in the original blog post.
OpenTelemetry Observability for Nango has been introduced to enhance real-time monitoring and debugging of integrations with external systems, where observability is crucial due to the lack of control over these systems. Nango now offers extensive real-time logging covering 18 log types, powered by ElasticSearch to ensure speed and scalability, along with real-time metrics available directly in the user interface. Future improvements include full-text search and additional insights such as authorization tracking. The OpenTelemetry export feature allows teams to export integration events as traces for deeper performance insights. These enhancements enable users to break down metrics by customer or integration, debug API calls with detailed logs, and track data quality issues, and are accessible on both Nango Cloud and Nango Enterprise Self-Hosted platforms.
Nov 25, 2025
313 words in the original blog post.
Embedded integration platforms, also known as embedded iPaaS, are essential tools for AI and SaaS products, enabling them to create native integrations with the diverse software ecosystems used by their customers. These platforms offer robust infrastructure and tools to connect products with external APIs, facilitating forms of integration such as data syncs, AI tool interactions, and webhook processing. Unlike unified API platforms, which provide general functionality across similar APIs, embedded integration platforms cater to developing deep, custom integrations that are integral to a product's value. Key factors in selecting a platform include API authentication, continuous data syncs, extensibility, observability, and LLM tool calling support. Some of the leading platforms in this space include Nango, Prismatic, Albato, and Workato, each offering distinct features and limitations. Nango stands out with its open-source model and developer-centric approach, supporting extensive API integration and robust observability. Prismatic offers both code and low-code interfaces, while Albato caters to less complex workflows but lacks customization. Workato focuses on pre-built actions and visual automation but is limited in supporting advanced integration patterns. Choosing the right platform involves balancing development speed with functionality and considering extensibility and control, especially as the product evolves and grows.
Nov 25, 2025
1,777 words in the original blog post.
Native product integrations are increasingly crucial in the B2B SaaS sector, prompting many companies to explore options like Tray Embedded and its alternatives to expedite delivery while minimizing engineering workload. Nango stands out as a popular open-source platform, offering an extensive catalog of pre-built integrations, a developer-first approach with end-to-end type safety, and flexible pricing that accommodates various integration needs. Merge.dev provides a unified API model that simplifies access to multiple APIs by abstracting them into a single interface, though it limits customization. Apideck offers entirely pre-built unified APIs for quick deployment but lacks flexibility, focusing on white-label solutions. Some organizations choose to build integrations in-house, granting complete control and adaptability but requiring significant time investment and maintenance. Nango is presented as a superior choice for those prioritizing a comprehensive, customizable integration platform with a strong developer experience, especially where security and compliance are essential.
Nov 25, 2025
1,826 words in the original blog post.
OAuth 2.0 addresses security with short-lived access tokens but introduces challenges in managing token refreshes, notably concurrency issues. These issues occur when multiple processes simultaneously attempt to refresh tokens, leading to potential race conditions and API failures. To mitigate these problems, implementing locking mechanisms is crucial to ensure that no API requests use a token during its refresh and that only one refresh process runs per token. Solutions include using in-memory locks for single-instance applications and distributed locking with Redis for multi-instance environments. Additionally, caching tokens and retrying requests on 401 errors can optimize performance. Proper handling of token expiration and refresh failures, as well as considering third-party services like Nango for OAuth management, are recommended to maintain robust and reliable integrations.
Nov 25, 2025
1,829 words in the original blog post.
Nango, an open-source developer tool, transitioned from using Temporal to a custom-built queuing and scheduling system on Postgres to handle interactions with third-party APIs due to the challenges of running untrusted user code and enterprise adoption barriers. The team evaluated several alternatives, considering scalability, minimal dependencies, and flexibility, ultimately opting to create their own system using Postgres due to its simple yet effective locking and concurrency capabilities. This decision allowed them to remove a complex external dependency and gain more control over their infrastructure, while managing millions of tasks efficiently without downtime during the migration process. The implementation involved creating a tasks table in Postgres, using built-in locking mechanisms to handle task scheduling, and overcoming performance bottlenecks by linking tasks in a series. The migration strategy involved running the new system in parallel with the old one, using feature flags to switch accounts gradually, and ensuring seamless performance, which proved successful and introduced minimal overhead. Nango now utilizes Postgres for multiple workloads, including relational databases, object storage, and task orchestration, highlighting its versatility and reliability.
Nov 25, 2025
1,562 words in the original blog post.
Merge.dev offers a unified API platform that facilitates integration development across various categories like HRIS, ATS, and CRM, but it has limitations such as restricted API coverage, a limiting unified data model, and lack of control over integrations. These drawbacks can make it unsuitable for integrations that are core to product features, leading to potential scalability issues and prohibitive pricing. Alternatives to Merge.dev include Nango, which offers more customization and control for developers through open-source infrastructure and supports over 500 APIs; Apideck, which provides a wide range of category coverage with usage-based pricing and an integrations marketplace; Unified.to, which covers niche categories with similar limitations to Merge but offers a built-in MCP server; and Codat, which specializes in accounting and banking integrations tailored for fintech companies. Each alternative presents unique strengths and use cases, allowing businesses to choose a platform that best fits their specific integration needs and priorities.
Nov 25, 2025
1,876 words in the original blog post.
Integrating with the Salesforce API is often perceived as difficult, costly, and time-consuming, but different approaches can alleviate some of these challenges. The text explores four methods for building a Salesforce integration: in-house development, using embedded integration platforms as a service (iPaaS), leveraging unified APIs, and utilizing open-source product integration platforms. Each option has its pros and cons, such as the flexibility and control of building in-house versus the speed and simplicity of using pre-built solutions. The document details how Nango, an open-source integration platform, was used to create a Salesforce integration within three hours by utilizing pre-built templates and infrastructure, demonstrating a balance between rapid deployment and customization. This approach allowed for efficient syncing of Salesforce contacts and accounts with a SaaS product, emphasizing the potential of open-source platforms to combine speed and flexibility in API integrations.
Nov 25, 2025
1,680 words in the original blog post.
Salesforce's token endpoint deviates from standard OAuth conventions by not including the "expires_at" parameter, which indicates when an access token expires. To determine the expiration date, users must make an additional API request to a token introspection endpoint, which provides details such as the token's expiration time in a Unix timestamp format. The lack of expiration information complicates the process of refreshing access tokens, which should ideally be refreshed well before they expire to avoid potential API request failures. To address these challenges, Nango, an open-source API authorization solution, offers pre-built implementations for Salesforce OAuth and automates processes like access token refreshes and secure token storage, easing the integration burden for developers.
Nov 25, 2025
447 words in the original blog post.
In the evolving landscape of workflow automation in 2025, companies are increasingly adopting a layered and modular approach to streamline operations and improve efficiency. The primary methods include buying specialized SaaS tools for reliability and structured tasks, building in-house solutions for maximum control and customization, utilizing integrations platforms like Zapier for simple, event-driven automations, and deploying AI agents for flexible, context-rich workflows. Embedded integrations also play a role by allowing seamless communication between SaaS tools. Each of these approaches offers distinct advantages and trade-offs, with SaaS providing speed and reliability, in-house builds offering flexibility, integrations platforms ensuring accessibility, and agents adding adaptability. As organizations continue to navigate these options, they are not necessarily replacing SaaS but rather augmenting it with additional layers of automation, creating a more cohesive and efficient operational environment.
Nov 25, 2025
1,229 words in the original blog post.
GitHub offers two primary methods for building integrations: GitHub Apps and GitHub OAuth apps, each with distinct features and use cases. GitHub Apps are recommended for most integrations due to their modern design, security, flexibility, and ability to act independently or on behalf of users, making them ideal for organization-level integrations that require fine-grained permissions and persistent access. They are particularly suited for automations like bots and business-critical integrations. In contrast, GitHub OAuth apps are better suited for individual user-centric tools, providing broad access and simpler installation due to their inheritance of the user's permissions and standard OAuth flow. However, they are limited by user dependency and fixed rate limits. When deciding between the two, the choice largely depends on the target audience, required functionality, and complexity of implementation, with GitHub Apps being favored for most modern applications, especially those involving teams or organizations.
Nov 25, 2025
1,546 words in the original blog post.
Encountering the "invalid_grant: Token has been expired or revoked" error is a common issue when working with Google OAuth refresh tokens, and this article provides guidance on detecting and resolving it. The error, which renders the refresh token unusable, can occur due to various reasons including the app being in "Testing" mode, user revocation of access, inactivity for six months, password changes, exceeding client token limits, or admin-enforced policies. To address the issue, it's crucial to check the publishing status of the app and, if needed, switch from "Testing" to "Production," which may involve a security review. If the problem persists, users should be prompted to re-authenticate to obtain a new refresh token. To prevent such issues, developers are advised to regularly refresh tokens, discard stale access tokens, store new tokens, and monitor for spikes in "invalid_grant" errors. Solutions like Nango offer automated token refreshing and management to simplify handling OAuth token lifecycles.
Nov 25, 2025
695 words in the original blog post.
Integrating products with external APIs requires navigating a complex authentication landscape, as the experience of implementing authentication for over 400 APIs shows. The challenges stem from various factors, such as the sprawling OAuth standard with its non-standard extensions and quirks, the user-unfriendly nature of API keys, and the rise of custom authentication flows by platforms like GitHub and Stripe. Each API's unique requirements and behaviors, including token refresh mechanisms and additional parameters, add layers of complexity. Authentication often involves handling revoked credentials, managing permissions and scopes, and ensuring robust security measures. Many existing OAuth libraries focus primarily on user login rather than API access, prompting the development of a custom open-source solution to address these gaps. This intricate authentication process highlights the need for detailed documentation, user-friendly interfaces, and centralized logic to manage API requests, ultimately aiming to streamline integration and enhance user experience.
Nov 25, 2025
1,410 words in the original blog post.
Nango, a developer infrastructure company, emphasizes the importance of adhering to startup fundamentals despite the complexities of the sector, showing that staying scrappy and focusing on essentials can lead to success. Initially launching with minimal resources, Nango found that being lean not only necessitated focus but also enabled them to iterate quickly and adapt to user needs. Their hiring strategy evolved from generalists to highly experienced "platform engineers" with broad and deep expertise, ensuring innovation came directly from developers who are both creators and users of the product. This approach allowed them to build a durable and adaptable system with a small, selective team that could maintain high standards and support substantial growth, highlighting that even in infrastructure, a lean team can be a significant advantage.
Nov 25, 2025
1,136 words in the original blog post.
Salesforce's OAuth implementation deviates from standard conventions by not providing the `expires_at` parameter in its token endpoint response, which typically indicates when an access token will expire. Instead, users must make an additional API request to Salesforce's token introspection endpoint to obtain the expiration date, which is returned in the `exp` field as a Unix timestamp. This extra step is necessary for ensuring timely token refreshes, as failing to do so could result in failed API requests due to expired tokens. Implementing Salesforce OAuth efficiently can be complex and time-consuming, but solutions like Nango can simplify the process by offering pre-built implementations for Salesforce and other APIs, along with features such as automatic token refreshes, secure token storage, and detection of broken tokens.
Nov 25, 2025
447 words in the original blog post.
In the competitive SaaS industry, product integrations are crucial for enhancing user experience, but building them in-house often incurs hidden costs that can affect a company's resources and product development timeline. While initial in-house integration projects may seem promising, they quickly become complex due to the intricacies of external APIs, authentication challenges, and the need for scalable infrastructure. This complexity can lead to delayed time-to-market, reduced product velocity, and increased engineering resource drain. Additionally, maintaining these integrations requires ongoing support, robust observability tools, and effective customer issue management, which many companies underestimate. Rather than building in-house, leveraging platforms like Nango that offer pre-built integration templates and specialized tools can accelerate deployment and reduce maintenance burdens, allowing companies to focus on core product development and meet customer demands more efficiently.
Nov 25, 2025
1,726 words in the original blog post.
Building a unified API can streamline development and reduce maintenance for product integrations, but it's crucial to apply best practices for success. Unified APIs are most effective when multiple APIs within a category share core functionalities and similar data models. Starting with a focused scope and gradually expanding, using an internal data model, and maintaining a clean abstraction are vital steps. While not all integrations should be unified, popular systems may require dedicated API-specific integrations to leverage unique features. Ensuring a robust technical foundation with observability, data validation, and handling common challenges like rate limits and token refreshes is essential. Tools like Nango can aid in developing a unified API infrastructure by providing built-in support for authentication, data syncing, and webhook handling. Unified APIs are not a one-size-fits-all solution, but when implemented thoughtfully, they can significantly enhance development efficiency.
Nov 25, 2025
1,315 words in the original blog post.
Integrations are crucial for modern software ecosystems, and the decision to build them in-house or buy third-party solutions involves weighing factors such as scalability, reliability, speed, ownership, and costs. Building integrations internally provides complete control and tailored user experiences but requires significant resources and expertise, posing potential delays and maintenance challenges. In contrast, purchasing third-party solutions offers quicker time-to-market and infrastructure management, though it may lead to vendor lock-in and limited customization. The decision depends on an organization's team capacity, product goals, and integration importance, but a hybrid approach like Nango offers a promising alternative. Nango combines pre-built templates and customizable infrastructure, balancing speed, scalability, and control. This approach supports rapid deployment while allowing future-proofing and adaptability to evolving demands, making it a compelling option for those seeking the advantages of both building and buying integrations.
Nov 25, 2025
1,484 words in the original blog post.
AI agents are rapidly advancing and are expected to handle increasingly complex workflows, but many fail when interacting with real-world APIs due to intricate issues like authentication, schemas, rate limits, and edge cases. To overcome these challenges, AI agents require a robust integrations platform that acts as a translation layer between human-like intents and API-specific executions, handles authentication complexities, and provides observability for debugging. Such platforms ensure security and robustness by managing token lifecycles and scopes, offering logs and monitoring capabilities, and establishing constraints on API interactions. They also introduce clear "contracts" to define expected inputs and outputs, enhancing reliability and enabling agents to move beyond mere demonstrations to production-ready systems. While Model Context Protocols (MCPs) offer a standardized approach for agent-API interaction, they fall short without the underlying infrastructure to manage the complexities of real-world APIs, underscoring the necessity of a comprehensive integrations platform.
Nov 25, 2025
766 words in the original blog post.
Encountering the "BAD_REFRESH_TOKEN" error when integrating with HubSpot’s APIs using OAuth indicates a missing or invalid refresh token, which can arise from various reasons including user actions like revoking access or uninstalling an app, reaching access token limits, token expiration, scope changes, or mismatched client credentials. The error is final, meaning revoked tokens cannot be revived, and users must re-authenticate to obtain a new token. To minimize disruptions, it’s advised to refresh tokens regularly, discard stale tokens, monitor for error spikes, and handle app uninstallation and errors gracefully. Adopting engineering practices such as scheduled refreshes and using tools like Nango for automated token management can prevent issues and maintain smooth API operations.
Nov 25, 2025
700 words in the original blog post.
HubSpot's API is highly developer-friendly, offering extensive documentation and robust developer accounts, yet creating and maintaining a customer-facing HubSpot API integration presents challenges due to its quirks and nuances. This guide offers insights gained from experience in building complex HubSpot integrations, starting with setting up a free developer account to safely experiment with data, and creating an OAuth app following HubSpot's discontinuation of API key access. Authentication involves installing an OAuth app in a user's HubSpot CRM, with Nango providing a simplified OAuth client solution. Reading and writing data with the HubSpot API requires understanding its limitations, such as the need to manually request object properties and handle rate limits, with Nango offering tools to manage these complexities. A two-way data sync with HubSpot involves importing data into a separate database to overcome API rate limits and associating it with other data, while writing data back to HubSpot requires handling specific challenges like rate limits and custom configurations. The guide concludes by encouraging thorough testing, secure token storage, and considering listing integrations on the HubSpot Marketplace for increased visibility and trust, with Nango providing an alternative for those seeking simplified integration management.
Nov 25, 2025
2,433 words in the original blog post.
GitHub offers two primary methods for building integrations: GitHub Apps and GitHub OAuth Apps, each with distinct characteristics and use cases. GitHub Apps are the modern choice, ideal for organizations and business-critical integrations, providing security, flexibility, and persistent access even when users change. They support bot-like functionality and fine-grained permissions and are designed for scalability and better webhook support. Conversely, GitHub OAuth Apps, considered the "classic" method, are user-centric, granting broad access to personal user data and are suitable for personal productivity tools due to their simpler installation and permission inheritance. While OAuth is easier to implement, its dependence on individual users and lack of independent bot mode make it less suitable for organizational needs. The decision between these two integration paths depends heavily on the target audience and specific use cases, with GitHub Apps generally recommended for business applications and team-focused products, while OAuth remains useful for personal tools and straightforward integrations.
Nov 25, 2025
1,546 words in the original blog post.
Successfully roadmapping product integrations involves strategic planning and decision-making, emphasizing the importance of choosing the right integrations based on customer demand, business impact, feasibility, and strategic fit. Once priorities are set, defining the integration scope is crucial, distinguishing between deep integrations with core systems and shallow integrations for specific use cases. Effective timeline and resource planning, including accommodating API limitations and testing, ensures smooth integration delivery. Long-term maintenance requires designing flexible architectures, implementing robust monitoring systems, and preparing for scalability. The build vs. buy decision is critical, with Nango offering a hybrid solution that balances control and efficiency by handling authentication, rate limiting, and API syncing infrastructure. A strategic approach to integration roadmapping can deliver significant value to customers while enhancing team efficiency and turning integrations into a competitive advantage.
Nov 25, 2025
687 words in the original blog post.
OAuth redirects on localhost can be problematic due to many providers requiring HTTPS URLs, even when testing locally. This is because HTTP lacks the encryption needed to protect sensitive authorization codes during transmission, making HTTPS essential for security. However, since localhost requests never leave the local machine, HTTPS isn't technically necessary. To address these challenges, developers have several workarounds, such as using redirect services like RedirectMeTo, which reroute traffic to the specified local URL, or employing HTTPS tunnels like Ngrok that forward traffic from an external HTTPS URL to localhost. Alternatively, developers can enable HTTPS on their local machines by generating and installing SSL certificates. While these solutions effectively bypass OAuth redirect issues on localhost, outdated methods like self-signed certificates, URL shorteners, and altering host files are discouraged due to security concerns or lack of effectiveness. Additionally, open-source tools like Nango offer prebuilt OAuth flows and HTTPS-based redirects, simplifying the process for developers.
Nov 25, 2025
1,347 words in the original blog post.
Nango offers a comprehensive suite of tools and infrastructure to facilitate both real-time and near real-time data syncing without requiring users to build and maintain complex systems. Real-time syncing is achieved through webhooks, where external systems push updates directly to an app, but can also be paired with polling to address potential webhook unreliability. For situations where webhooks are not feasible, Nango provides fast polling, optimizing updates through 30-second intervals, incremental syncing, and sync partitioning to handle large datasets efficiently. This system ensures timely data reflection in applications, enhancing their responsiveness and reliability, with straightforward setup supported by detailed documentation.
Nov 25, 2025
284 words in the original blog post.
Nango is actively seeking backend engineers and offers a newsletter that provides practical tips, guides, and insights from building over 500 B2B SaaS integrations. The newsletter, appreciated by industry professionals like VPs of Engineering and CTOs, covers topics such as handling OAuth token refreshes without concurrency bugs, best practices for building API integrations with AI agents, and considerations on whether to build or buy product integrations. These articles, authored by experts like Robin Guldener and Bri Cho, aim to share lessons learned and enhance understanding of integration strategies in the tech industry.
Nov 25, 2025
253 words in the original blog post.
Paragon is an embedded integrations platform that helps build workflow automations for product integration with other systems, offering pre-built connectors and a low-code workflow builder. However, its pricing model is not publicly disclosed, requiring potential customers to contact sales for details on the Pro and Enterprise plans, which combine annual fees with unclear usage-based charges. The lack of a free tier and only a 14-day trial can make it difficult for early-stage companies to evaluate the platform's fit for their needs without significant financial commitment. Additionally, key features necessary for scaling, such as exporting observability data and role-based access control, are restricted to the Enterprise plan, increasing costs. In contrast, Nango provides a more transparent, usage-based pricing model with a free tier and no annual commitments, offering greater flexibility and cost predictability for teams of all sizes.
Nov 25, 2025
1,210 words in the original blog post.
Startups often face the dilemma of whether to offer services while developing their products, a challenge Nango encountered firsthand. Initially believing they understood integration complexities, they discovered the breadth of challenges in delivering scalable solutions. By offering services, Nango gained deep insights and credibility, transforming from outsiders into integral team members for their clients, which provided valuable feedback and expertise in integration landscapes. However, the service-driven approach led to operational inefficiencies, misaligned customer expectations, and a lack of product ownership. Eventually, Nango transitioned back to focusing on their product, leveraging the expertise gained from services to create a robust platform that allowed them to serve customers effectively with fewer resources. This journey highlighted the value of services as a learning tool and trust-building mechanism, but also emphasized the importance of knowing when to pivot back to a product-centric model for sustainable growth.
Nov 25, 2025
1,071 words in the original blog post.
Nango facilitates the development of AI applications by offering seamless access to over 400 APIs, enabling both data ingestion for Retrieval-Augmented Generation (RAG) and agentic API access. It provides continuous data polling and real-time ingestion through high-frequency syncing and webhooks, along with managed authentication and action introspection for AI agents. To ensure reliability and security, Nango includes features such as logs, metrics, alerts, automatic queuing, retries, and granular permission controls. The platform supports AI-driven applications for various companies and uses AI technologies to expand its integration catalog by parsing API documentation, automating integration testing, and assisting in custom integration building, ultimately aiming to expedite the API integration process for developers.
Nov 25, 2025
257 words in the original blog post.
Many startups grapple with whether to offer services while developing their product, a dilemma faced by Nango, which initially embraced this approach. The company discovered that developers needed infrastructure rather than prebuilt solutions, leading to a shift towards a more service-oriented model to overcome early product limitations. This strategy allowed them to gain trust and insight by working closely with customers on integration challenges, providing valuable feedback and deep understanding of diverse use cases. However, as services began to hinder scalability and create dependency issues, Nango transitioned back to focusing on its product, leveraging the insights gained to strengthen its platform. The transition allowed them to simplify operations, improve customer fit, and increase leverage by scaling software instead of human resources. Nango's experience underscores the importance of using services as a strategic learning tool, while recognizing the right moment to pivot back to a product-focused model to achieve sustainable growth.
Nov 25, 2025
1,071 words in the original blog post.
Nango, a developer infrastructure company, shares insights into its journey of building a team and scaling operations, emphasizing the importance of adhering to startup basics like staying scrappy and narrow in focus. Despite the complex nature of developer infrastructure, Nango succeeded by beginning with a small team and minimal resources, achieving traction through innovative approaches like using open-source repositories and manual setups during its initial launch. The company highlights the value of hiring highly skilled, T-shaped engineers with broad exposure and deep expertise, enabling them to innovate from the front lines and contribute significant improvements to the product. By focusing on product-led growth and maintaining a small, high-context team, Nango has managed to support hundreds of companies and achieve a seven-figure ARR without the need for a large team or extensive capital. This approach has allowed them to make thoughtful infrastructure decisions that enhance system durability and reduce the need for frequent rewrites, demonstrating that maintaining a lean team can be a strategic advantage even in the demanding field of developer infrastructure.
Nov 25, 2025
1,136 words in the original blog post.
Composio is a platform designed to streamline the integration of AI agents with a wide range of pre-built tools, focusing primarily on tool calls rather than broader functionalities like data syncs or webhooks. However, it is limited by its lack of customizability, visibility, and control, prompting users to seek alternatives. Nango emerges as a strong competitor by offering extensive integration capabilities, open-source tools, and real-time observability, making it ideal for teams seeking more control and scalability. Arcade offers a community-driven approach with a focus on custom MCP servers, while Workato provides enterprise-level features suitable for existing customers, particularly for internal use cases. The choice between these platforms largely depends on the specific needs for customization, observability, and scalability, with Nango being the most comprehensive option for teams requiring deep integrations.
Nov 25, 2025
1,393 words in the original blog post.
AI agent integration platforms are essential for connecting agents to external APIs with enhanced reliability, latency management, scalability, and observability. These platforms offer infrastructure and tools to manage authentication, execute tools, enforce permissions, and log activities, enabling agents to make deterministic tool calls with clear inputs and outputs. Key features to look for include broad API coverage, extensibility, low overhead, scalable runtime, robust authentication, and deep real-time observability. Notable platforms include Nango, which offers a code-first experience and supports over 500 APIs; Arcade, which focuses on the Model Context Protocol (MCP) for tool calling with advanced testing; and Workato, which provides an enterprise iPaaS with strong governance, auditing, and centralized management for internal tool use. Selecting the right platform depends on specific needs such as deep control, performance, visibility, and whether the focus is on product integrations or internal use cases.
Nov 25, 2025
1,166 words in the original blog post.
Pipedream Connect, an embedded product of the Pipedream automation platform, is initially appealing due to its vast catalog of integrations, but it faces challenges when used for AI agent integrations due to its design for human-in-the-loop interfaces rather than automation. These challenges include complex configuration requirements, non-standard schemas, limited development workflow support, lack of white-label authentication, and limited observability, making it less suitable for reliable production integrations. The text explores three alternatives to Pipedream Connect for AI integrations. Nango is highlighted for its scalable infrastructure, white-label authentication, extensive API support, and robust developer experience, making it ideal for teams needing deep integrations and control. Workato offers enterprise-grade solutions with a focus on internal use cases and extensive auditing tools, suitable for organizations already invested in its ecosystem. Arcade, built specifically for AI agent tool calling, provides advanced testing and permission management capabilities, making it a strong choice for teams requiring specialized AI agent integrations. The decision on which platform to choose depends on specific needs such as tool customization, observability, and scalability requirements.
Nov 25, 2025
1,524 words in the original blog post.
Choosing the right third-party integrations partner is crucial for companies looking to efficiently build and maintain product integrations without developing them in-house. Key considerations include ensuring the partner supports the necessary APIs and use cases for both current and future needs, offering robust developer tools for maintenance and debugging, and providing flexibility to customize and extend integrations as the product evolves. It is important to assess whether the platform operates as an open system or a closed "black box," as an open-source platform can prevent vendor lock-in and offer greater control and transparency. Additionally, enterprise-level support and the option for self-hosting are vital, especially for businesses dealing with sensitive data requiring strict compliance. The article highlights these factors to guide organizations in selecting an integrations partner that aligns with their unique needs and future-proofing their integration strategy.
Nov 25, 2025
1,398 words in the original blog post.
Integration efforts are frequently underestimated by teams, who often fall into the trap of believing in standardized or off-the-shelf solutions due to misleading market messaging. This misconception leads to misguided objectives, failed integrations, and wasted resources. The complexity of integrations arises from the unique nature of each product, such as ticketing systems, which require careful attention to details like field translations and workflow alignment. Checklist-driven approaches that prioritize speed and system integration over quality often result in unused, unreliable, and costly implementations. Effective integration should be treated as a core product development task, involving thorough discovery, design, testing, and ongoing maintenance, while focusing on systems critical to customers and ensuring user adoption. Understanding the true complexity and cost of integrations can help teams avoid common pitfalls and create more successful and reliable connections between systems.
Nov 25, 2025
565 words in the original blog post.
Embedded iPaaS platforms like Paragon initially promise a balance between control over integrations and abstracting API differences, with features such as pre-built authentication and low-code/no-code interfaces aimed at democratizing integration creation for non-engineers. However, these platforms often fall short, as engineers still need to manage the complexities of data models and API requests, while developers find the low-code interfaces less efficient than traditional coding environments. Paragon's limitations include a restricted coverage of API endpoints and a development experience that doesn't fully align with engineers' workflows. Alternatives such as Nango, Tray.io, Merge.dev, and Apideck offer various benefits and drawbacks. Nango supports extensive pre-built integrations and a developer-friendly experience, Tray.io focuses on bespoke integrations, Merge.dev provides unified APIs for common features, and Apideck offers a wide range of API categories but limited customization. Choosing the right integration platform is critical for accelerating product time to market and meeting customer needs, with Nango's community providing additional support for those exploring options.
Nov 25, 2025
1,644 words in the original blog post.
Pipedream Connect, an embedded product of the automation platform Pipedream, presents challenges for AI agent integrations due to its design for human-in-the-loop interfaces rather than AI applications. It requires complex configurations, uses non-standard schemas, has limited development workflow support, lacks white-label authentication, and offers limited observability. Alternatives such as Nango, Workato, and Arcade provide solutions that better cater to AI agent integration needs. Nango excels with its white-label authentication, scalability, and developer-friendly environment, while Workato offers enterprise-grade capabilities and is suitable for organizations already using its platform. Arcade, designed specifically for AI agent tool calls, provides advanced testing and permission management features. Choosing the right platform depends on specific needs like tool customization, observability, and scalability to ensure reliable AI agent infrastructure.
Nov 25, 2025
1,524 words in the original blog post.
In the rapidly evolving B2B SaaS landscape, successful product integrations are crucial for customer engagement and retention, as they enhance a product's strengths and directly contribute to growth. Building high-quality integrations involves designing them to fit seamlessly into customers' workflows, covering necessary APIs, and offering customization options to meet specific needs. Companies like Nango facilitate this process by providing tools and platforms that simplify the integration building and maintenance, offering pre-built templates and customization capabilities to address common challenges such as OAuth handling, rate limits, and API changes. Successful integrations not only require a thoughtful design approach but also a robust system for maintenance and reliability, ensuring they remain functional and valuable in production environments. By leveraging platforms like Nango, which handles many integration challenges out of the box, companies can create integrations that are both customer-centric and developer-friendly, ultimately leading to improved customer satisfaction and business growth.
Nov 25, 2025
1,693 words in the original blog post.
Integrating with multiple third-party APIs can be complex due to their unique characteristics, but API unification offers a solution by standardizing these APIs under a single interface. Integration platforms as a service (iPaaS) facilitate this process by providing the necessary infrastructure and tools. The article reviews various iPaaS options for API unification, including Nango, Merge, Workato, and Prismatic, each with distinct advantages and limitations. Nango is highlighted for its flexibility and open-source nature, supporting over 500 APIs and offering comprehensive infrastructure for custom unified APIs, although it requires significant upfront development. Merge provides pre-built unified APIs suitable for shallow integrations but lacks customization and control over production issues. Workato excels in internal workflow automation with a visual workflow builder but does not support unified APIs specifically. Prismatic offers a combined code-first and low-code experience but lacks unified API support and has limitations in scalability. The choice of iPaaS depends on specific team needs and goals, with the recommendation to use unified APIs for secondary integrations while considering direct integrations for critical functionalities.
Nov 25, 2025
1,452 words in the original blog post.
Encountering a "BAD_REFRESH_TOKEN" error when integrating with HubSpot's APIs using OAuth indicates a missing or invalid refresh token, requiring detection and resolution to maintain smooth functionality. This error can occur due to user actions such as uninstalling the app or manually revoking access, surpassing token limits, token expiration due to inactivity, scope changes, or mismatches in client credentials. Fixing the issue involves asking users to re-authenticate and ensuring correct client credentials are used, while preventing future occurrences can be achieved by regularly refreshing tokens, discarding stale ones, and monitoring for spikes in errors. Employing engineering practices such as setting webhooks for app uninstallation and implementing proper error handling can mitigate disruptions. Additionally, using tools like Nango can automate OAuth token management, allowing developers to focus on product features without worrying about token lifecycle complexities.
Nov 25, 2025
700 words in the original blog post.
Integrations can be a significant revenue driver when executed effectively, yet many product and engineering teams face challenges in delivering them quickly and at high quality. To address this, teams should implement a continuous discovery process to capture integration requests aligned with customer needs, prioritize them based on potential value, and integrate them into the product roadmap as a priority rather than as afterthoughts. Allocating specific capacity for integration work and setting business outcome-oriented goals can prevent them from being deprioritized. Engineering efficiency can be achieved by creating reusable components, standardizing interfaces, and leveraging AI for API integrations, which allows engineers to focus on the aspects that add the most customer value. Additionally, planning for maintenance by building robust infrastructure, implementing observability systems, and considering data schema migrations is essential to maintaining integration velocity. By strategically managing these areas, integrations can shift from being a bottleneck to a catalyst for product adoption and revenue growth.
Nov 25, 2025
513 words in the original blog post.
Encountering the "invalid_grant: Token has been expired or revoked" error is common when working with Google OAuth tokens, particularly when a backend attempts to exchange a refresh token for a new access token. This issue can arise due to various reasons, such as the application being in "Testing" mode, user revoking access, the token being unused for six months, password changes involving Gmail scopes, reaching the per-client token limit, or other undocumented security reasons. Once a refresh token is revoked, it cannot be revived, necessitating user re-authentication to obtain a new token. To mitigate such issues, developers should regularly refresh tokens, discard stale access tokens, and store any new tokens provided by Google. Monitoring for spikes in the "invalid_grant" error can help identify when user re-authentication is necessary. Tools like Nango can simplify managing OAuth tokens by automatically handling token refreshing and rotation, allowing developers to focus on product features while managing the token lifecycle efficiently.
Nov 25, 2025
695 words in the original blog post.
Unified APIs provide a convenient solution for early-stage B2B SaaS companies, allowing rapid integration with multiple third-party platforms with minimal engineering effort. However, as companies grow, they encounter limitations such as the inability to accommodate custom data schemas, lack of support for niche or emerging APIs, and challenges with enterprise compliance and control over integration experiences. These issues can lead to customer dissatisfaction and hinder growth. To overcome these constraints, companies are encouraged to consider more extensible integration platforms that offer full control, support for custom fields, complete API access, and compliance readiness. Such platforms enable scalability and flexibility in managing complex integrations, ensuring a more robust and adaptable infrastructure as the company expands.
Nov 25, 2025
1,026 words in the original blog post.
Composio provides developers with quick connections to various pre-built tools and external APIs for AI agents, but it has limitations such as lack of customization and limited observability, making it less suitable for scalable production deployments. Nango emerges as a strong alternative, offering more control, scalability, and real-time observability with open-source tools and support for advanced integration features like data syncs and webhooks, making it ideal for products that require deep integrations. Arcade takes a community-driven approach, allowing for custom MCP servers and niche tools, while Workato offers enterprise-grade capabilities, particularly beneficial for existing customers or those focused on internal use cases. Selecting the right platform depends on specific needs regarding customization, observability, and scalability, with each alternative providing unique strengths tailored to different requirements.
Nov 25, 2025
1,393 words in the original blog post.
Nango's Custom Integration Service aims to streamline the process of implementing business integrations by handling the complex aspects of integration development, allowing companies to ship integrations faster. Clients provide specifications, and Nango manages the integration process, including finding test accounts, unifying schemas, and maintaining integrations as APIs evolve. The service leverages Nango's expertise with various enterprise APIs and is available to customers on the Scale plan, who can request integrations via Slack for quick delivery. Looking ahead, Nango plans to incorporate AI to enhance integration speed and reliability, automate code generation, conduct AI-driven reviews, and improve issue detection, while also making these AI-driven tools available to customers who prefer to build integrations independently.
Nov 25, 2025
325 words in the original blog post.
Paragon is an embedded integrations platform offering workflow automation through pre-built connectors and a low-code builder, but its pricing model presents challenges due to lack of transparency and high entry costs, particularly for early-stage companies. The platform only offers Pro and Enterprise plans, both requiring contact with sales to determine pricing, which combines an annual fee with unclear usage-based charges, making cost prediction difficult. Concerns include high starting prices, additional costs for essential features available only in the Enterprise plan, and a short 14-day trial period that may not suffice for thorough evaluation. In contrast, Nango offers a transparent, usage-based pricing model with a free tier for development and testing, allowing for monthly commitments and volume discounts, thus reducing the financial risk and enabling comprehensive platform assessment before making a long-term commitment.
Nov 25, 2025
1,210 words in the original blog post.
OAuth, despite being a standard protocol with widespread availability of client libraries across programming languages, presents significant challenges due to its complex and varied real-world implementations. While OAuth 2.0 is the default, numerous APIs interpret the standard differently, leading to a plethora of unique implementations and nonstandard behaviors that complicate integration efforts. Developers often face issues like inconsistent parameter requirements, varied token request formats, and cumbersome approval processes, with many APIs implementing only parts of the OAuth standard they deem necessary. Additionally, security considerations and evolving best practices add layers of complexity, requiring developers to navigate potential race conditions, token expiration issues, and storage security. The text highlights Nango, an open-source service designed to simplify OAuth integrations with prebuilt flows and secure token management, as a potential solution to these challenges.
Nov 25, 2025
2,682 words in the original blog post.
Many product teams underestimate the complexity and cost of integrations due to assumptions that they can be standardized or quickly purchased, which results in misguided objectives and failed implementations. Market messaging often promotes the idea of "instant connectors," but these frequently lack functionality, scalability, and reliability, leading to poor customer adoption. The absence of dedicated integration specialists exacerbates the issue, as the responsibility often falls through the cracks. Integrations are inherently complex because they involve connecting unique systems, each with distinct features and workflows, and cannot be standardized. The checklist mentality drives teams to prioritize speed and cost over usability and reliability, resulting in underutilized integrations. Effective integrations require treating them as product development efforts, involving discovery, design, testing, user education, and continuous maintenance, recognizing their true complexity and cost. Teams should focus on integrations that enhance product value and customer satisfaction rather than quick technical solutions.
Nov 25, 2025
565 words in the original blog post.
Nango, a developer infrastructure company specializing in product integrations, has navigated a complex journey to enable integrations with over 500 APIs for numerous SaaS and AI companies. Their key learnings emphasize the importance of crafting robust abstractions, which are crucial for building effective infrastructure products and require a blend of deep domain expertise and artistic design. Their experience revealed that offering lower-level solutions, rather than high-level end-to-end solutions, often provides customers with better control and success in integrations. They also discovered that investing extra time in perfecting abstractions yields long-term benefits by reducing rework and support overhead. Additionally, their path to achieving product-market fit was nonlinear, involving multiple iterations and learnings about integration challenges across various B2B software products. Throughout this process, Nango gained valuable insights into the intricacies of building integrations, underscoring the significance of persistence and adaptability in their development strategy.
Nov 25, 2025
930 words in the original blog post.
AI agent integration platforms are crucial for connecting agents to external APIs reliably and efficiently, and choosing the right platform impacts factors like scalability, latency, and observability. These platforms manage authentication, tool execution, permissions, and logging, enabling agents to make deterministic tool calls without crafting raw API requests. Key features to consider include broad API coverage, type-safe interfaces, robust authentication, scalable infrastructure, and deep observability for error diagnosis. Among the notable platforms, Nango offers a code-first experience with over 500 supported APIs and is suitable for high-scale production environments. It provides a strong focus on observability and customization, making it ideal for products requiring more than simple tool calls. Arcade specializes in the Model Context Protocol (MCP), offering a dedicated tool execution engine and robust testing features, though it has a smaller catalog. Workato emphasizes governance and auditing, catering mainly to internal and enterprise contexts with a low-code approach. When selecting a platform, organizations should consider their specific needs for extensibility, observability, and scalability to ensure reliable and efficient AI agent integrations.
Nov 25, 2025
1,166 words in the original blog post.
Merge offers a unified API platform designed to simplify integrations across various categories, promising faster deployment with reduced engineering effort and an expanded integration catalog, primarily targeting Enterprise B2B SaaS customers. However, Merge's pricing model involves complexities and potential limitations, such as high fixed costs per linked account, annual contracts with capacity-based pricing, and key features restricted to Enterprise plans, which may not suit companies where integrations are a core product feature. The pricing structure is not publicly disclosed, requiring time-consuming sales calls to understand costs, and can result in overpaying for unutilized capacity due to inaccurate usage forecasts. In contrast, Nango provides a transparent, usage-based pricing model that allows for monthly contracts and low minimums, offering flexibility and cost-effectiveness, with a clear view of costs and features to help businesses scale their integrations without being locked into long-term commitments.
Nov 25, 2025
1,230 words in the original blog post.
Building integrations with multiple third-party APIs can become complex due to various authentication flows, data models, and rate limits, leading many B2B SaaS companies to adopt unified APIs for a streamlined approach. Unified APIs offer a single interface for interacting with different APIs, simplifying integration logic, reducing maintenance, and improving developer experience. While pre-built unified APIs can accelerate initial development, many companies eventually need to create custom unified APIs to cater to specific business needs and data models. The construction of unified APIs involves defining interactions with external APIs, establishing a consistent data model, and implementing robust error handling. Despite the advantages, there are challenges such as unification limitations and the need for ongoing maintenance of mapping logic. Custom unified APIs offer flexibility and control but require significant upfront development effort. Companies should consider their specific use cases, opting for unified APIs when supporting multiple APIs with similar functionalities, while direct integrations might be better for core systems requiring specific functionalities. The process involves starting with one API, expanding incrementally, and using the right tools and frameworks to ensure extensibility and maintainability.
Nov 25, 2025
2,081 words in the original blog post.
Embedded iPaaS platforms, designed to allow non-technical users to build integrations using prebuilt blocks, often fail to deliver on their promises due to several key limitations. The assumption that non-technical users can handle complex integrations is flawed, as real-world applications require deep understanding of data models and handling of edge cases like API inconsistencies and rate limits, which often necessitate developer intervention. Prebuilt connectors rarely align with specific product needs, limiting customization and often requiring developers to learn proprietary frameworks. Moreover, these platforms lack the necessary abstractions for developers, such as end-to-end type safety and support for continuous syncs, and tend to break under scale due to inefficiencies like repeated data serialization. As a result, many teams find themselves reverting to developer-centric tools like Nango, which offer greater control, flexibility, and scalability, allowing engineers to write integration logic in code while handling complex tasks like OAuth and webhooks out of the box, thereby providing a more reliable and scalable solution for building integrations.
Nov 25, 2025
506 words in the original blog post.
Unified APIs offer a streamlined solution for integrating multiple APIs by providing a single interface, thereby reducing the complexity and maintenance burden on engineering teams. This approach allows SaaS products to quickly build and deploy integrations with numerous APIs, increasing their appeal to customers who demand specific integrations. Selecting the right unified API is crucial as it should cover all necessary APIs and allow for customization to meet unique use cases. The unified API's ability to provide extensibility is vital to overcome the inherent limitations of a single interface for diverse APIs, enabling companies to adapt to evolving customer needs without having to build from scratch. There are different types of unified APIs, including niche, closed, and open, each offering varying levels of extensibility and coverage across API categories. Ultimately, the choice of a unified API impacts how effectively a company can meet customer demands and how efficiently they can maintain and scale their integration infrastructure.
Nov 25, 2025
1,762 words in the original blog post.
AI agents are increasingly central to automating business processes, but their effectiveness relies heavily on robust authentication systems to interact securely with various external software platforms. AI agent authentication allows users to grant agents secure access to their data across software like calendars and CRMs, typically involving OAuth flows, API keys, or other authentication methods. Key platforms for this purpose include Nango, Arcade, and Auth0 for AI Agents, each offering distinct features. Nango boasts extensive API coverage and open-source flexibility, Arcade provides AI agent tool calling with automatic permission checks, and Auth0 offers secure token storage and integration with AI frameworks, though it currently supports limited APIs. The choice of an authentication platform is crucial for scalability, security, and meeting customer integration needs, with each option catering to different requirements in terms of API support and extensibility.
Nov 25, 2025
896 words in the original blog post.
Building integrations with third-party APIs can be a complex and time-consuming process, transitioning from a simple proof of concept to a robust production-ready system. This process involves challenges such as implementing retry logic, error handling, managing rate limits, and ensuring scalability and fault tolerance. Fortunately, multiple solutions exist to streamline integration development, each with distinct advantages and limitations depending on factors like the level of interaction, integration depth, complexity of the external system, customer usage, data volume, and the number of systems involved. Options include building from scratch, using low-code/no-code integration builders, leveraging API aggregators, or adopting pre-built infrastructure. Each approach suits different scenarios, from bespoke integrations for enterprise customers to standardized API aggregations across similar systems, allowing engineering teams to choose based on their specific needs and resources.
Nov 25, 2025
1,245 words in the original blog post.
Building and maintaining integrations involves more than just making API calls; it presents significant infrastructure challenges that can impact scalability and user experience if not properly addressed. Key issues include the orchestration of tasks, resilience of long-running syncs, handling of high-frequency or real-time data syncing, and managing two-way or incremental syncing to ensure data integrity. Additionally, overcoming API rate limits, ensuring data quality across diverse and evolving schemas, and managing scalability with efficient resource and concurrency control are crucial. Observability is essential, requiring comprehensive monitoring of failures, performance, and rate limits, along with detailed network traffic logs to facilitate debugging and prevent costly outages. Addressing these challenges early on can mitigate potential scaling issues and engineering inefficiencies, ensuring robust and reliable integration solutions.
Nov 25, 2025
487 words in the original blog post.
Unified APIs offer a simplified integration solution for AI agents or SaaS products by providing a single interface to interact with multiple underlying APIs, thus streamlining the process of integrating with external systems. These platforms are particularly beneficial for shallow integrations across many APIs or for creating custom APIs tailored to specific product needs. The text analyzes several unified API platforms available in 2025, each with its strengths and weaknesses. Nango is highlighted for its custom unified API capabilities, allowing full control over data models and integration logic, suitable for complex use cases. Kombo, Merge, Apideck, and Unified.to are also discussed, each offering varying degrees of pre-built integrations and customization options, with specific focuses such as HRIS or e-commerce. The choice of platform depends on the specific integration requirements, the need for customization, and the level of control desired, with core product integrations often necessitating a more bespoke approach.
Nov 25, 2025
1,615 words in the original blog post.
Salesforce API users often encounter the "invalid_grant" OAuth error, particularly when dealing with expired or revoked access or refresh tokens. Common causes include exceeding the access token limit per user, specific OAuth policy settings like "Immediately expire refresh token," user password changes, or user deactivation. To resolve such errors, users need to re-authenticate, as all errors are permanent and can only be fixed by obtaining a new access and refresh token pair. Best practices to prevent these issues include configuring appropriate token policies, scheduling regular token refreshes, discarding stale access tokens, and monitoring for spikes in the "invalid_grant" errors. Tools like Nango can simplify managing the Salesforce OAuth token lifecycle by handling token refreshes, supporting rotated refresh tokens, and providing real-time webhooks for revoked tokens, allowing developers to focus on building product features without the headache of token management.
Nov 25, 2025
1,008 words in the original blog post.