How to Use the Make.com TypeScript SDK and Handle App Updates

The make.com TypeScript SDK and app update process help developers build, maintain, and evolve custom apps in a predictable and safe way. This guide explains how to work with the SDK, migrate from v1 to v2, and manage updates so your scenarios continue running smoothly.

What the Make.com TypeScript SDK Does

The TypeScript SDK for make.com is a developer toolkit that simplifies how you define modules, connections, and triggers in your custom apps. Instead of manually wiring everything, you use typed helpers that enforce structure and reduce runtime errors.

The SDK supports:

• Typed definitions for modules and connections
• Clear separation between app versions
• Safer upgrades thanks to explicit versioning
• Better development experience for large integrations

By using the SDK correctly, you gain more control over how your app behaves when make.com updates or when you publish new versions of your app.

Core Concepts in the Make.com SDK

Before you start building, understand the key ideas that shape how the SDK works in make.com.

Versioned apps in make.com

Every app has versions, typically v1 and v2. The SDK is aligned with this concept so that:

• v1 apps remain stable for existing scenarios
• v2 apps can introduce breaking changes
• Users decide when to upgrade inside their scenarios

This versioning is essential to preventing unexpected behavior when a make.com integration evolves.

Modules and connections

The TypeScript SDK structures your app into modules and connections. In make.com:

• Modules handle actions, searches, and triggers.
• Connections define how authentication and API access work.

The SDK provides typed utilities to describe parameters, outputs, and authentication flows so that your app configuration remains consistent between versions.

How to Start Using the Make.com TypeScript SDK

To work efficiently with the SDK in make.com, follow a structured approach.

1. Set up your development environment

1. Initialize a Node.js project with TypeScript.
2. Install the official TypeScript SDK package as documented on the make.com help page.
3. Configure your tsconfig.json so that type checking covers your app source files.

This environment gives you type safety and better auto-completion while developing for make.com.

2. Define your app structure

Using the SDK, outline your app with a main definition file. Typically, you will:

• Create a central file that declares app metadata, modules, and connections.
• Split each module into its own file for maintainability.
• Re-use shared helpers for pagination, authentication, and error handling.

Consistent structure ensures easier upgrades when you move from v1 to v2 inside make.com.

3. Implement modules with TypeScript

With the structure in place, you can implement individual modules using the SDK:

1. Define input fields and their types.
2. Describe output schemas for better mapping in make.com scenarios.
3. Implement the logic that calls your external API or service.
4. Use TypeScript types for better compile-time guarantees.

Each module should be predictable and easy to test before you roll it out to users in make.com.

How App Updates Work in Make.com

Understanding how updates propagate is crucial. The make.com platform separates app updates from scenario behavior to protect automation workflows.

Update lifecycle in make.com

The typical lifecycle when you publish a new app version looks like this:

1. You develop changes in your app project using the TypeScript SDK.
2. You publish the new version to make.com.
3. The platform stores both the old and new versions.
4. Existing scenarios keep running on their current version until users explicitly upgrade them.

This separation avoids breaking running automations when you introduce new logic or parameters.

Backward compatibility considerations

When designing updates in make.com, be cautious about breaking changes. Consider:

• Keeping field names stable where possible.
• Providing defaults for new fields.
• Avoiding the removal of outputs that scenarios might rely on.
• Documenting any breaking changes clearly.

The TypeScript SDK helps by making your changes explicit in the type system, so you see what is added, removed, or renamed.

How to Migrate from v1 to v2 in Make.com

Migrating from v1 to v2 is a structured process that you should plan before touching any production scenario on make.com.

Step 1: Clone or branch your v1 app

Start by making a clean separation of your v1 codebase:

• Create a new branch or copy of the existing project.
• Mark the new branch as v2 in your repository.
• Update metadata to clearly label the version for make.com.

This protects your v1 app from accidental changes while you develop v2.

Step 2: Introduce your v2 changes

With the v2 branch ready, introduce planned changes using the SDK:

• Refactor modules that need new or altered parameters.
• Update connection definitions if authentication models changed.
• Deprecate old modules in favor of cleaner v2 implementations.

Use TypeScript types to make sure each change is intentional and visible in your app definition for make.com.

Step 3: Test your v2 app

Before publishing the new version, thoroughly test it:

1. Run unit tests on key modules.
2. Create test scenarios in make.com using the v2 app.
3. Verify that error messages and outputs are clear and stable.

Testing ensures that when users upgrade scenarios, they do not run into surprises.

Step 4: Publish and guide users to upgrade

After testing, publish the v2 app to make.com:

• Announce the availability of v2 to users or your internal teams.
• Explain which scenarios should upgrade and why.
• Provide migration notes describing changes to modules and fields.

Since scenarios remain on their existing versions until they are manually upgraded, users are in control of when the transition happens.

Best Practices for Make.com App Maintenance

Long‑term success with the TypeScript SDK in make.com depends on a solid maintenance strategy.

Use semantic versioning principles

Even though apps are usually labeled with v1, v2, and so on, follow semantic versioning ideas internally:

• Treat breaking changes as major versions.
• Group minor improvements into well‑documented releases.
• Keep a changelog synchronized with the make.com app versions.

Document modules and changes clearly

Good documentation helps others understand your app behavior in make.com:

• Describe what each module does and when to use it.
• Explain important inputs, outputs, and edge cases.
• Record any deprecations or planned removals.

Clear docs reduce support requests and make migrations smoother.

Monitor scenarios after updates

After publishing new versions to make.com:

• Monitor error logs from scenarios that use your app.
• Track support tickets or user feedback.
• Quickly patch and republish if you detect systemic problems.

Combining monitoring with the TypeScript SDK gives you early warning when a change has unintended effects.

Where to Learn More About Make.com Development

To deepen your skills with the TypeScript SDK and app updates in make.com, use these resources:

• Official documentation on the TypeScript SDK and app updates.
• Implementation and optimization guides from automation specialists such as Consultevo.

By following the practices above and using the SDK as designed, you can build robust, upgradeable integrations on make.com that stay reliable as your product and requirements evolve.

Need Help With Make.com?

If you want expert help building, automating, or scaling your Make scenarios, work with ConsultEvo — certified workflow and automation specialists.

Get Help