How to Build Custom Connectors in Hours: Connect AI Guide

According to Zylo’s 2025 benchmark report, which tracked more than $40 billion in SaaS spend, the average company runs 275 SaaS applications and adds seven more every month.

That average count doesn’t even include the tools your engineers build internally, which creates a compounding problem. A specific connector is needed to move data from each of them to your warehouse.

But as each of these SaaS tools ships periodic updates, API endpoints change their behavior, and internal tools evolve in what they process and how they send it, these connectors need to be built once and maintained.

And doing that is costly. It’s estimated that data engineers spend over 44% of their time building and maintaining connectors and pipelines.

The only other option is to wait weeks or months for your data platform to build the connector you need, and then spend your team’s bandwidth again maintaining it.

Not anymore. This blog discusses how you can build custom connectors in hours, without writing a single line of code or deploying infrastructure to maintain them.

What is a custom connector?

A custom connector is a bridge that moves data between a data source that your ELT platform doesn’t support out of the box and a destination such as your data warehouse. Its job is to ensure that each field maps to the right column in your warehouse, and keep the mapping current as the source schema changes.

When do you need a custom connector?

When a source has no connector, its data still has to reach the warehouse somehow.

However, every ELT platform comes with a finite catalog of connectors that support a finite number of sources. And that catalog rarely matches the full list of sources your business loads data from, brewing a need for a custom connector to do the job. And as your business grows and adopts new tools, it needs more of them.

Here are four major scenarios where a custom connector becomes necessary:

• New SaaS products: Your teams pick up new tools to solve new problems, and some of those tools start generating data your business depends on almost immediately. But ELT platforms like Fivetran only build connectors for tools with proven demand among their customer base, often leaving newer tools out of their catalogs.
• Vertical systems: Vertical systems handle end-to-end workflows for businesses in niche industries, such as healthcare, aviation, or logistics, thereby limiting their target audience for APIs. Thus, the data models vary from account to account, leaving little incentive for ELT platforms to build native connectors for them.
• Internal APIs: No external vendor can pre-build a connector for a private schema, a bespoke auth gateway, or an internal release cycle.
• Tier-gated APIs: Sometimes a native connector exists, but the subscription tier of that product does not expose the required endpoints or scope until the plan is upgraded. In those cases, data teams need to work around with custom connectors.

What are the ways to build a custom connector?

There are three primary ways to get a connector for a source that your ELT platform doesn’t support. But the way that’d fit you depends on the trade-off you’re willing to make between turnaround time, the team’s bandwidth, and maintenance responsibilities.  

Keep those in mind as you read through each option, because the right choice depends on which of them your team can least afford to give up.

So let’s see the three ways to build a connector:

Wait for Your Data Platform to Build It

The least-cost path is to simply ask your ELT platform to build a custom connector for the source and add it to their catalog. But that’s also why it’s uncertain. All you can do is raise a request, and it’s up to the platform whether to build the connector.

Usually, an ELT platform would only build a custom connector for you if there’s enough demand for the connector for that particular source from their other customers and prospects, too.

From then on, the vendor should maintain. But in some cases, your team might need to take the maintenance responsibility for one-off cases.

Build It In-House with Your Engineering Team

The second way to build a custom connector is to do so internally with your engineering team. 

But because you’d build it, you’d require it to maintain it as well. That’s a tough job. A production connector usually requires authentication, pagination, deduplication, and monitoring capabilities. This adds up to a lot of maintenance work. 

At a median US data engineer compensation of around $157,000 a year, even a single week of work costs about $3,000 before overhead.

Use a Connector SDK

A connector SDK is a toolkit for building connectors. While your engineers write custom code specific to the source, an SDK provides ready-to-use scaffolding.

Thus, this approach is faster than building everything from scratch and suits the teams that need proprietary logic, access to a private network, or code they can review line by line.

However, your team is still required to do the source-specific work. And the maintenance responsibility lies within your teams, too.

Other than that, SDKs come at a cost. For example, Fivetran bills SDK connectors by monthly active rows (MAR), which can quickly increase your costs

Which options should you pick?

The option best for you would reveal itself once you weigh the overall costs, time, and resources needed for each route.

Conventional options consume too much time and resources

Connect AI builds the connector from your API docs in hours, and Hevo maintains it after launch.

See how Connect AI works

Here’s a head-to-head comparison between the three approaches:

Option	Time to first data	Code	Hosting	Logic maintenance
Wait for the platform	Potentially weeks or months	None	Vendor	Vendor, if accepted and released
In-house service	Team-dependent	High	Customer	Customer
Fivetran Connector SDK	Faster than building runtime infrastructure	Python	Fivetran	Customer owns source logic; Fivetran owns runtime services
Airbyte Builder/CDK	Minutes for simple declarative APIs; longer for edge cases	UI/YAML or Python	Airbyte Cloud or the customer	Customer reviews and updates the custom definition
Meltano Singer SDK	Accelerated scaffolding	Python	Customer-selected	Customer/maintainer
dlt REST source	Fast for common REST patterns	Python/config	Customer-selected	Customer, unless buying additional managed services
Connect AI, as briefed	About two hours for supported REST APIs	No customer code	Hevo	Hevo after validation and publication

What Are the Challenges of Building Custom Connectors?

A connector has one job: to move every record from the source into your warehouse on every run. To do that, it has to log in to the source, pull data in batches, keep up with however the source’s API works today, and confirm that what landed matches what left. Because the source controls most of those conditions, things can go wrong at three points: how the source grants access and shares data, how often its vendor updates the API, and how quietly the connector can fail once it’s running.

Handling Authentication and Pagination

Since data is always behind an access control, connectors need an authentication mechanism to prove they have the right access to read and move data. To do that, some sources may accept a static API key, while others may rely on OAuth.

Pagination is how the connector pulls large datasets in chunks: most APIs return a few hundred records per request and indicate the next batch with an offset, a page number, or a cursor.

However, they can run into deadlocks and loops. For example, while using single-use refresh tokens, if two jobs try to refresh at once, both tokens get invalidated. Similarly, offset pagination can skip or duplicate records when new rows arrive mid-sync, and a buggy next link can cause a connector to enter an endless loop.

Keeping Up with API Changes

The hardest part of API changes is that you don’t control when they happen. Each vendor sets its own release calendar, publishes deprecation notices in its own changelog, and enforces its own cutoff. And when you’re pulling data from multiple sources at once, just tracking that becomes a job in itself.

And most importantly, when vendors decide to cut off endpoints, you’re left with no option but to build your own workarounds for it. For example, Salesforce retired API versions 21.0 through 30.0 in 2025, and requests to those endpoints now return an error instead of data.

Some changes are quieter and worse. A renamed or retyped field can leave the sync running without errors while the data it loads is already wrong.

Monitoring and Maintaining the Connector

Once you’re done building the connector, you need to catch it every time it malfunctions and bring it back up as soon as possible.

And that’s the difficult part. A connector can report success even while it skips pages, drops a new field, or returns zero records from a stream that should have data.

Catching those failures means building checks for row counts, freshness, schema changes, null rates, and cursor movement, then deciding who responds when one fires.

What is Hevo’s Connect AI connector builder agent?

Building a custom connector from scratch is painstaking. You need to consume and understand copious API documentation, work out authentication methods, understand which endpoints return what, and how they page through results.

In Postman’s 2024 State of the API report, 44 percent of developers said they had dug through source code just to understand an API, and 43 percent relied on colleagues to explain one. ​

But the job isn’t over even then: your engineers write the connector, test it, and maintain it throughout the connector’s lifecycle.

Connect AI: the connector builder agent takes that whole job off your team. You give it a public link to the documentation, and it reads the API, writes the connector, and tests it against your own account before it goes live, with no code for you to write.

1) It reads your API documentation

Give Connect AI: connector builder agent a public documentation URL, an OpenAPI specification, or a Postman collection, and it automatically works out the rest. It identifies which objects you can sync through which endpoint, and how the API handles pagination and authentication.

Once it’s done, it gives you a list for your review and automatically translates each object into a table in your data warehouse.

2) It Tests the Connector Against Your Live Account

Documentation shows how an API should behave, and Connect AI: connector builder agent makes real API calls to test if the runtime behavior matches the expectations.

It checks that it can authenticate, reach each object, and extract data from it. If an issue arises, it flags it and highlights the reason.

3) Hevo Maintains It After Launch

Once you publish the connector, it becomes a Hevo source like any native one. Hevo runs, monitors, and maintains it, and anyone on your team can select it to build a pipeline. The connector stops being a project your engineers own and becomes part of the platform.

Got an API doc link? Connect AI will handle the rest.

Connect AI: connector builder agent at your docs, test against your live account, and publish a Hevo-managed connector in hours.

Request Early Access

What Do You Need Before Building a Managed Connector with Connect AI?

Like any process of building a connector from scratch, building one automatically also requires a few base ingredients. Here’s everything you’ll need to start building custom connectors with Connect AI: connector builder agent:

1. A REST API: Your source needs to expose a REST-based API, since that’s what Connect AI: connector builder agent reads and builds against.
2. API documentation: Have it ready as a public URL that opens without a login, an OpenAPI specification in JSON or YAML, or an exported Postman collection. You can provide all three if you have them.
3. Source credentials: Keep the base URL and the credentials your API uses, such as an API key, a bearer token, a username and password, or a query parameter, so that the connector can be tested against your account.
4. A supported destination: Your pipeline needs to load into your preferred destination. Usually, it’s destinations like Snowflake, Snowflake Iceberg, Google BigQuery, Databricks, or Amazon Redshift.
5. Early Access: Connect AI: connector builder agent is in Early Access, so ask your Hevo account executive or the Support team to enable it for your account.

How Do You Build a Custom Connector with Connect AI?

To show how the process works end-to-end, let’s build a connector for Brevo, the email and marketing automation platform.

From Brevo’s docs, we know that Brevo’s API uses API key authentication, publishes its reference documentation openly, and exposes objects that most marketing data teams want in their warehouse, such as contacts, lists, and email campaigns.

So building on that, here are the steps to build a custom connector with Connect AI:

1) Start the build

In Hevo, go to Pipelines, click + Create Pipeline, and on the Select Source Type page, click Build Connector in the Connect AI banner. A short dialog lists what you’ll need for the build. Once you’ve confirmed you have it, click Get Started.

2) Give It Brevo’s API Documentation

Once you’re on the page where you define your source, simply enter Brevo as the source name. Once done, provide either the URL to the documentation of Brevo’s public API or upload the documentation yourself.

Alternatively, you can also upload Brevo’s OpenAPI specification or Postman collection.

3) Click submit

As soon as you submit the documentation, the Connect AI connector builder agent will start analyzing it, which typically takes around 10 to 20 minutes for small documentation and up to 60 minutes for larger APIs.

4) Add Your Brevo Credentials and Validate

Once you’re on the page setting up the connection, enter Brevo’s base URL and select API key as your preferred authentication method. Once done, simply paste the API key generated from Brevo account settings and click Save and Test Connection.

5) Fix Gaps Before Publishing

Once the validation is complete, the page will show you the list of objects that were fully verified or partially done. It’ll also show you the reason behind it.

If it’s a credentials issue, click Update Credentials and enter a key with the right permissions. If it’s an account issue, fix it in Brevo and click Retry Validation. When you’re satisfied, click Publish Connector. Verified and partially verified objects go live, and unverified ones are left out.

What Happens After Your Custom Connector Goes Live?

Once published, your connector works like any native Hevo source. Hevo runs, monitors, and maintains it, so your engineers no longer treat it as a side project. Simultaneously, it also becomes available to everyone on your team, and anyone can select it to build a pipeline.

What Are the Benefits of Using Connect AI for Custom Connectors?

One of the most anticipated outcomes of the Connect AI connector builder agent is that it can get an unsupported source sending data into your warehouse within hours.

And it does that while keeping your team out of the code, the infrastructure, and the maintenance that usually come with a custom connector.

Here’s what that looks like in practice:

• No code to write or infrastructure to manage: The agent writes the connector, and Hevo runs it, so your engineers don’t build, host, or deploy anything.
• Connectors ready in about 2 hours, not weeks: Analysis and validation each typically take 15 to 60 minutes, compared with the weeks a vendor request or an in-house build can take.
• Tested against your own account before launch: Connect AI: connector builder agent runs every object against your live account before publishing, so you know it works with your data and permissions, beyond what the docs promise.
• You choose which objects to sync: You review every object the agent finds and keep only the ones you need, so your warehouse doesn’t fill up with tables nobody queries.
• Fully managed by Hevo after launch: Once published, the connector is monitored and maintained like any native Hevo source, with no repairs left for your team.

Try Connect AI

Connect AI: The connector builder agent builds, tests, and hands off the connector in about two hours. Hevo maintains it from there.

Try Connect AI

How Is Connect AI Different from Connector SDKs?

While both methods help you build your custom connector faster than other approaches, Connect AI is faster and more convenient. It uses AI to analyze API docs, build the API, and test it. It’s a completely no-code solution.

On the other hand, SDKs only offer pre-built scaffolding around it. With an SDK, your engineers write the source-specific logic, the API calls, authentication, and pagination, so every fix after launch is theirs too.

Then there’s maintenance. Once built with the SDK, it’s your engineers who maintain the connector with every API update. But with Connect AI: Connector builder agent, Hevo maintains it for you like any other native connector.

Let’s look at what that means in practice:

Parameter	Waiting for your ELT platform	Build in-house	Connector SDK	Connect AI: connector builder agent
Time to first data	Weeks to months, if the request is accepted	Depends on API complexity and engineering bandwidth	Faster than in-house, but it still depends on your engineers	Typically hours
Code required	None	All of it, including auth, pagination, state, and retries	Source-specific logic, written by your team	None
Hosting	Vendor	Your team	Vendor or your team, depending on the SDK	Hevo
Maintenance after launch	Vendor	Your team	Your team owns the source logic	Hevo

Missing a connector?

Build it with Connect AI: a connector builder agent in no time.

Try Connect AI now

In short

Connect AI: connector builder agent turns a REST API’s documentation into a working, tested connector in hours, with no code for your team to write. Once it’s live, Hevo runs and maintains it like any native source, so your engineers get the data without inheriting the upkeep.

Connect AI: the connector-builder agent is now available in Early Access. Contact your Hevo account executive or the Support team to enable it for your account.

FAQ