Resources · Make integration

NPM Registry Make integrationAutomate NPM Registry with Make.

Checking a package version by hand gets old fast. The NPM Registry Make integration gives you 3 modules: search the registry, read a package record, or call any endpoint. This page covers connecting the app and building a first scenario.

Try the NPM Registry integration on MakeSee the 3 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the NPM Registry Make integration actually do?

It wires the npm registry into Make, the tool where you build a scenario: a chain of modules, each module being one brick that does one job, running without you. Three modules cover the ground here. You can look up packages by name, pull the full record of one of them, or hit the registry API directly when the rest falls short. Nothing to install, nothing to host.

Keep a dependency list honest. A scheduled scenario calls Get package metadata on the packages that matter and drops what comes back wherever your team already looks. What you read is the registry talking, not a value someone copied into a sheet and forgot.

Shortlist a library without losing the afternoon. Search the registry takes the text you type and returns the packages that fit, one bundle per hit. A bundle is one item travelling from a module to the next. Zero, one, or several: the scenario carries on with whatever the registry found.

Reach what the other two never expose. Make an API Call sends the request you write to the registry API on the same connection, the link between your account and Make that every module reuses, so a need outside the listed modules does not stall the scenario.

Two limits, stated plainly. Make's page for this app is short, because too little public material exists about it to build a full guide, so the reference is what the editor shows you inside the module rather than a web page. And there is no trigger at all, nothing in the registry wakes Make up, you decide when the scenario runs. The same registry lives on the other tool too, through the NPM Registry n8n integration and the n8n vs Make comparison if you are still choosing. What each Make plan allows is laid out in Make pricing.

Connect

How do you connect your NPM Registry account to Make?

  1. 01

    Drop in an NPM Registry module

    Create a scenario, click the +, search NPM Registry in the app list and pick one of its three modules. The module panel shows a Create a connection button, and that button opens the connection: your account linked to Make once, reused after that.

  2. 02

    Authorize Make

    Name the connection if you expect to juggle several, then follow what the window asks. Either you authorize Make from the app's own page, or you paste the key the app hands you. The documentation does not say which of the two applies here, so read the window instead of guessing.

  3. 03

    Save it once

    Click Save. The connection sits in your Make account and every NPM Registry module across every scenario draws on it, so you will not start over each time you add one.

First scenario

Your first scenario: from a search to a package record

GoalOn the schedule you set, Make looks up a package in NPM Registry and reads its full record, with nobody opening a terminal.

  1. 01

    Create the scenario

    From the Scenarios page, create a new one. A circle with a + sits in the middle of the canvas, and that is where the first module goes.

  2. 02

    Add Search the registry

    Type NPM Registry in the app picker, choose Search the registry, then click Create a connection to link your account. In the panel that opens, write the text you want the registry to match.

  3. 03

    Chain Get package metadata

    Click the + on the right of the first module and add Get package metadata. Map the value the search returned into its field, so the second module reads what the first one found.

  4. 04

    Test with Run once

    Click Run once. The scenario fires a single time and each module shows the bundles it received, which means you see real data before anything is scheduled.

  5. 05

    Schedule it and switch it on

    Open Scheduling on the first module. A fresh scenario runs every 15 minutes by default, so set the rhythm your case needs, then flip the scenario switch to on.

Modules

The 3 NPM Registry modules, one by one

NPM Registry gives you 3 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

NPM Registry1

Get package metadata

Action

In Make“This module responds with the package metadata document, sometimes informally called a "packument" or "doc.json".”

Asks the registry for everything it holds on one named package and returns the whole document as a single bundle, what the npm world nicknames a packument, or doc.json.

When to use it
the moment a scenario needs the live state of a library your product leans on, rather than a copy saved somewhere.
Watch out
it answers for the one package you name and no other, so run a search first when the exact spelling escapes you.
NPM Registry2

Make an API Call

Action

In Make“Performs an arbitrary API call.”

Sends a request you write yourself to the registry API and pours the answer back into the scenario. It is the module that covers the ground the other two leave alone, on the connection you already made.

When to use it
a case that falls outside Get package metadata and Search the registry, and that you would rather not handle away from Make.
Watch out
nothing here comes prefilled, so you need to know which request to send before you open the module.
NPM Registry3

Search the registry

Search

In Make“Search the NPM registry for packages matching the given text”

Takes a piece of text and brings back the packages that line up with it, one bundle per hit. Zero, one, or several: the scenario moves on with what the registry found and nothing more.

When to use it
when two libraries do the same job and you want to weigh them without leaving the editor.
Watch out
a search can hand over several bundles at once, and each one makes the next module run again, so decide what happens to them before you schedule anything.
Need help

Need help automating NPM Registry with Make?

A person reads every message.

FAQ

What people ask next

01Is the NPM Registry Make integration free?
Yes, from the Free plan. NPM Registry is a standard app, and standard apps come with every Make plan; only apps marked as enterprise need the Enterprise plan. What the Free plan caps is the running, not the app: 2 active scenarios, 15 minutes minimum between two scheduled runs, 5 minutes of execution, files up to 5 MB and 512 MB of transfer. Paid plans bring the interval down to 1 minute, lift the cap on active scenarios and stretch execution to 40 minutes. Usage is counted in operations: each time a module processes one bundle, that counts as one operation, and it is what your plan meters.
02What do you need to connect NPM Registry to Make?
A Make account, and that is where the honest answer stops. The documentation for this app lists no prerequisites, since Make admits it lacks public material to detail them. What is left is the standard path: add a module, click Create a connection, name it if you plan to run several, authorize Make on the app side or paste the key it gives you, then save. The window that opens tells you which of the two routes applies. Once the connection exists, every NPM Registry module reuses it.
03Does the trigger fire in real time?
No, because there is no trigger here at all. NPM Registry brings 3 modules to Make, 2 actions and 1 search, and none of them watches the registry for you. Nothing in npm wakes Make up. You start it yourself: either you put Make's clock on the first module, which on a fresh scenario runs every 15 minutes by default, or you launch the scenario from a Make webhook, an address something outside calls to set it running, or from another app's trigger. The NPM Registry modules take over once it is going.
04What if a module is missing or a limit gets in the way?
Make an API Call is the answer. It sends the request you write to the registry API on the same connection, so whatever the other two modules never expose stays within reach of the scenario. The other limit worth knowing is the documentation itself: Make flags its guide for this app as incomplete, for lack of public material, which means the fields you see in the editor are the reference and not a page. When even that falls short, a second app inside the same scenario usually closes the gap.
05Make or n8n for NPM Registry?
It depends on what your team already runs. Make puts a drawn scenario in front of you: you place the 3 modules, click Run once, watch the bundles move, and the tool teaches you the logic while you build. n8n sits closer to code and you can host it yourself, which matters when the automation is one piece of a system developers own. The registry exists on both sides, so the call is about your team and your hosting, not about what npm can hand you.
Hack'celeration Lab

Get our weekly automation tips.

No spam. Unsubscribe anytime.

Same platform

Other docs you might need on this stack.

Browse all integrations