Make

Connect RoxyAPI to Make in under three minutes and automate astrology, tarot, numerology, I-Ching, dream, crystal, angel number, and biorhythm workflows on a visual canvas. One API key, 10 domains, 130+ endpoints, called from Make's HTTP module without writing a single line of code. If you can drag a module on a canvas you can build a daily horoscope email blast, a Life Path lookup on form submit, or a Vedic kundli generator that delivers a branded PDF report. This page walks you through every click.

Make (formerly Integromat) is a visual workflow automation platform with a proper free tier, a generous module library, and a dedicated HTTP app for talking to any REST API. It is the most popular paid alternative to Zapier in the AI workflow space, and it has a lighter learning curve than n8n if you have never touched a backend in your life.

Quick path: HTTP "Make a request" module with a manual header

This is the path that actually works on the first try. Skip the API Key Auth keychain for now (we cover it later) and get a working call in five minutes flat.

Step 1: add the HTTP "Make a request" module

1. Open your Make scenario (cloud only — Make does not self-host)
2. Click the + on the canvas to add a module
3. In the module picker, search for HTTP
4. Pick the HTTP app (the verified one with the globe icon)
5. Choose the Make a request action

An empty HTTP request module opens.

Step 2: set the URL and method

1. URL: paste any RoxyAPI endpoint, for example for a daily horoscope:

   https://roxyapi.com/api/v2/astrology/horoscope/aries/daily

2. Method: pick GET or POST. RoxyAPI uses GET for read endpoints (horoscopes, dream lookups, hexagram readings) and POST for endpoints that take a birth time or rich payload (natal chart, synastry, Vedic kundli, KP significators)

Step 3: add your API key as a header

1. Scroll to the Headers section
2. Click Add item
3. Set Name to X-API-Key (hyphens required, case does not matter, but spelling does)
4. Set Value to your RoxyAPI key from your account page

Step 4: enable Parse response

1. Scroll to the Parse response field
2. Set it to Yes

This tells Make to parse the JSON response automatically. Without it, the output of the module is a raw string and you cannot map individual fields in downstream modules. Always set this to Yes for RoxyAPI calls.

Step 5: run the module

1. Right-click the module on the canvas
2. Choose Run this module only
3. Make fires a single request and shows the response in the bundle inspector

A healthy RoxyAPI response looks like this:

{
  "sign": "Aries",
  "date": "2026-04-13",
  "overview": "Today, your natural leadership shines through...",
  "love": "Venus in your 5th house favours playful encounters...",
  "career": "Mars supports decisive action on a stalled project...",
  "luckyNumber": 7,
  "luckyColor": "Red",
  "moonSign": "Libra",
  "energyRating": 8
}

You can now connect this module to a Schedule trigger, a Webhook, a Form, or any of Make's 1,500+ integrated apps. Every field above is mappable from the bundle picker in downstream modules.

Power path: "Make an API Key Auth request" with a keychain

Use this path when you want your API key stored in Make's encrypted keychain instead of pasted into a module field. The trade-off: setup is slightly fiddlier, but the key never appears in scenario exports or shared screenshots.

Step 1: pick the right module

1. Add the HTTP app to your scenario
2. Choose the Make an API Key Auth request action (not "Make a request")

Step 2: create a keychain credential

1. In the Credentials field at the top of the module, click Add
2. Give the keychain a clear name like RoxyAPI key
3. Key: paste your RoxyAPI key from your account page
4. API Key parameter name: enter X-API-Key exactly
5. API Key placement: choose In the header (not query parameter)
6. Click Save

Step 3: configure the request

1. Set URL to the RoxyAPI endpoint
2. Set Method
3. Add a body if needed (see the JSON section below)
4. Set Parse response to Yes
5. Run the module

Make injects the X-API-Key header from the keychain on every call. The key never appears in the module UI or in exported scenarios, only the keychain reference.

Send a JSON body for POST endpoints

Endpoints like /astrology/natal-chart, /astrology/synastry, /vedic-astrology/birth-chart, and /numerology/life-path take a JSON payload. Here is how to send one.

1. Set Method to POST
2. Set Body type to application/JSON
3. In the Request content field, paste your JSON, mapping values from upstream modules where needed:

{
  "datetime": "{{1.birth_datetime}}",
  "latitude": {{1.birth_lat}},
  "longitude": {{1.birth_lng}},
  "timezone": "{{1.timezone}}"
}

The {{1.fieldName}} syntax references field fieldName from module 1 (the upstream trigger). In practice you click into the field, the mapping panel opens, and you drag fields from the bundle picker — Make builds the expression for you.

Map data from upstream modules

Make's visual mapping panel is its killer feature. After running any module once, every field in its output bundle becomes mappable in downstream modules.

Common upstream patterns for RoxyAPI

• Schedule. Runs your scenario on a cron. Perfect for "daily horoscope email at 8 AM".
• Webhooks > Custom webhook. Exposes a URL you can POST to from any form, no-code app, or external system. The request body becomes mappable fields in downstream modules.
• Form connectors (Tally, Typeform, Google Forms, Jotform). Make has integrations for every popular form builder. Pick whichever you already use; the form submission payload feeds straight into the HTTP body. (There is no native Make form module — the third-party "MakeForms" app on apps.make.com is unrelated to Make.com itself.)
• Email > Watch emails. Triggers on incoming Gmail or IMAP messages. Use it to build a "reply to my email with a tarot reading" bot.
• Telegram, Discord, Slack triggers. Build a chatbot that calls RoxyAPI and posts results.

Reference RoxyAPI response fields downstream

After running the HTTP module once with Parse response: Yes, every field in the JSON response (overview, luckyNumber, moonSign, energyRating, etc.) becomes mappable in any module after it. Click into a downstream field, drag the field from the HTTP module's output bundle, and Make wires it up.

For example, to email the daily overview:

1. Add a Gmail > Send an email module after the HTTP module
2. In the Subject field, type Your daily horoscope and drag in {{2.sign}} from the HTTP module output
3. In the Content field, drag in {{2.overview}} followed by {{2.love}} and {{2.career}}
4. Run the scenario

Fallback: API key as a query parameter

If a module flow somehow blocks you from setting custom headers, RoxyAPI also accepts the key as a query parameter:

https://roxyapi.com/api/v2/astrology/horoscope/aries/daily?api_key=YOUR_KEY

Test your API key outside Make first

Before you wire anything into a scenario, confirm your key works on its own. Open a terminal and run:

curl "https://roxyapi.com/api/v2/astrology/horoscope/aries/daily" \
  -H "X-API-Key: YOUR_KEY"

If that prints JSON, the key is good and any error inside Make is a module config issue, not a RoxyAPI issue. If it returns 401, the key is wrong or your subscription is inactive. Check at your account page.

Troubleshooting

401 api_key_required

{
  "error": "API key is required. Provide via X-API-Key header or api_key query param",
  "code": "api_key_required"
}

Make did not attach the header. Open the module and check:

1. The Headers section has an item with Name spelled exactly X-API-Key (hyphens required)
2. Value has your full key with no leading or trailing spaces, no quotes
3. If you are using the keychain module, the placement is set to In the header, not In the query

401 invalid_api_key

The header reached the server but the value is wrong. Re-paste the key from your account and remove any whitespace.

429 rate_limited

You hit your plan quota. Every RoxyAPI response carries X-RateLimit-Remaining and X-RateLimit-Reset headers. Add a Sleep module before high-frequency loops, batch your scenario with a longer cron interval, or upgrade on the pricing page.

404 not_found with a suggestion field

{
  "error": "Not found",
  "code": "not_found",
  "suggestion": "Did you mean POST /astrology/natal-chart?",
  "docs": "https://roxyapi.com/products/astrology-api"
}

The path is wrong. RoxyAPI returns the closest valid route in the suggestion field. Copy that path into the URL field and retry.

405 method_not_allowed

You used the wrong HTTP verb. The response allow array lists valid methods. Change the Method dropdown and retry.

Cannot map response fields in downstream modules

You forgot to set Parse response to Yes on the HTTP module. Without parsing, the response is a raw string and the bundle picker shows nothing. Set it to Yes and re-run the module once so Make rebuilds the output schema.

"Missing Authentication header" with the API Key Auth keychain

Known Make quirk. Switch to the plain Make a request module and add X-API-Key as a manual header. Both paths reach the same endpoint with the same key.

Extend your integration

You have one endpoint working in Make. Adding the next 130 is the same pattern: drop another HTTP "Make a request" module, change the URL, change the body, the header config is reusable. Three places to find the next endpoint to wire up:

• Interactive API reference — Scalar-powered live docs for every endpoint across all 10 domains. Try a call in the browser with the pre-filled test key, see the exact request and response shape, then paste the URL into a new HTTP module.
• Domain guides — short walkthroughs of which endpoints to call in what order for a given product:
  • Western Astrology guide — natal charts, horoscopes, synastry, transits
  • Vedic Astrology guide — kundli, Gun Milan, Vimshottari Dasha, panchang, KP
  • Tarot guide — daily card, three-card, Celtic Cross, custom spreads
  • Numerology guide — Life Path, Expression, Soul Urge, personal year
• Reuse the keychain. If you set up the Make an API Key Auth request keychain, every new module you add uses the same stored credential. One keychain, every endpoint unlocked.

The pattern is the same every time: horoscope today, compatibility tomorrow, kundli next week. One header, every endpoint unlocked.

What to build first

• Daily horoscope to Gmail. Schedule (8 AM daily) → HTTP GET /astrology/horoscope/aries/daily → Gmail Send. Loop with an Iterator over all 12 signs to send personalised horoscopes to a mailing list.
• Tarot card of the day to Slack. Schedule → HTTP POST /tarot/daily → Slack Post Message. Your team starts the day with a tarot card.
• Webhook-powered Life Path calculator. Webhook → HTTP POST /numerology/life-path → Webhook response. Point a no-code form at the webhook URL and you have a live numerology API with zero backend code.
• Vedic kundli to Google Docs PDF. Tally or Typeform trigger → HTTP POST /vedic-astrology/birth-chart → Google Docs Create document → Convert to PDF → Email to user. Full kundli with nakshatra, Vimshottari Dasha, and panchang as a branded PDF report.
• Dream journal with auto-interpretation. Email trigger (user emails their dream) → Text Parser (extract dream description) → HTTP GET /dreams/symbols → Reply via email with matching symbols.
• Weekly horoscope newsletter. Schedule (Monday 9 AM) → Iterator (12 signs) → HTTP GET /astrology/horoscope/{sign}/weekly → Aggregator → Mailchimp Send Campaign. One scenario, one campaign, every subscriber served.
• Telegram tarot bot. Telegram Bot → User asks a question → HTTP POST /tarot/spreads/three-card → Format reply with cards → Send to Telegram chat.

FAQ

How do I connect Make to RoxyAPI?

Add the HTTP "Make a request" module, set the URL to a RoxyAPI endpoint, set the method, add a header with Name X-API-Key and Value your RoxyAPI key, and turn on Parse response. That is the entire setup. For multi-module scenarios, the keychain-based Make an API Key Auth request module is more secure but historically more confusing to set up.

Is Make the same as Integromat?

Yes. Integromat rebranded to Make in 2022. Old documentation and YouTube videos that say "Integromat HTTP module" describe the same product, with the same HTTP app and the same module names.

Does Make work with self-hosted instances of RoxyAPI?

Make is cloud-only and does not self-host. It calls https://roxyapi.com over the public internet, which is exactly what every other Make integration does. There is no firewall or networking config required on your side.

Can I use Make with the AI Agent / OpenAI / Claude modules?

Yes. Make has dedicated modules for OpenAI, Anthropic Claude, Google Gemini, and others. A common pattern is: HTTP module fetches structured data from RoxyAPI (a natal chart, a numerology calculation, a tarot spread), then a Claude or GPT module rewrites it in your brand voice, then the result goes to Gmail, Slack, Webflow, or any output channel. Make does not (yet) have a native MCP client, so use the HTTP module for the RoxyAPI calls.

What is the difference between "Make a request" and "Make an API Key Auth request"?

Both modules call HTTP endpoints. Make a request is the universal HTTP module — you set headers, body, and method directly in the module. Make an API Key Auth request stores the key in an encrypted keychain so it does not appear in module config or scenario exports. The trade-off is that the keychain has historically been confusing for users to set up correctly. Start with the plain module; switch later if you need the keychain.

How do I cache RoxyAPI responses to save quota?

Make does not have built-in HTTP response caching. For daily content (horoscopes, daily tarot cards), use a Data Store (Make's built-in key-value storage) to save the response with a date key, and check there first before calling RoxyAPI. The pattern: Schedule → Data Store search → router branch (cache hit vs miss) → HTTP fetch on miss → Data Store add. One daily fetch per sign, served from cache for the rest of the day.

How accurate are the astrology calculations under a Make scenario?

Every position comes from Roxy Ephemeris, verified against NASA JPL Horizons. See the methodology page for accuracy details. Same engine for every endpoint, regardless of which integration calls it.

Will my API key end up in exported scenario JSON?

If you use the plain Make a request module, yes — the key value is in the module config and exports with the scenario. If you use the Make an API Key Auth request module with a keychain, only the keychain reference is exported, not the key value. For scenarios you plan to share publicly or hand off to a client, use the keychain path.

Where do I get a RoxyAPI key?

Visit the pricing page for paid plans, or try the interactive API reference with a pre-filled test key first. Plans start at 5,000 requests per month.

Is there a ready-made Make template for RoxyAPI?

Not yet. If you build a public Make template for astrology, tarot, or numerology on RoxyAPI and want it featured on our starters page, reply to your onboarding email with the template URL. The first community Make template gets a free month on us.