Integrations

// Code by Zapier > Run JavaScript
// Input Data: domain = (map a field from your trigger), apiKey = sk_live_...
const res = await fetch(
  "https://api.gridlode.com/v1/domain/tech?domain=" + encodeURIComponent(inputData.domain),
  { headers: { Authorization: "Bearer " + inputData.apiKey } },
);
const body = await res.json();
if (body.status !== "success") throw new Error(body.error.code + ": " + body.error.message);

output = {
  technologies: body.data.technologies.map((t) => t.name).join(", "),
  total: body.data.total,
  credits_charged: body.credits.charged,
};

// Code node (Run Once for All Items), right after the Webhook node.
// Self-hosted n8n: allow the crypto module with NODE_FUNCTION_ALLOW_BUILTIN=crypto
const crypto = require('crypto');
const secret = 'whsec_...'; // the webhook_secret returned when you created the job

const raw = (await this.helpers.getBinaryDataBuffer(0, 'data')).toString('utf8');
const header = $input.first().json.headers['x-gridlode-signature'] || '';
const parts = Object.fromEntries(header.split(',').map((p) => p.split('=')));
const expected = crypto.createHmac('sha256', secret).update(parts.t + '.' + raw).digest('hex');
const valid = parts.v1 && parts.v1.length === expected.length &&
  crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(parts.v1)) &&
  Math.abs(Date.now() / 1000 - Number(parts.t)) < 300;
if (!valid) throw new Error('Invalid Gridlode signature');

return [{ json: JSON.parse(raw) }]; // { event: "task.completed", task: { id, status, ... } }

/**
 * Gridlode for Google Sheets: =GRIDLODE(engine, input, [path], [options])
 *
 * Setup: Extensions > Apps Script, paste this file and save. Then open Project Settings (gear icon) >
 * Script Properties > Add script property: GRIDLODE_API_KEY = sk_live_...
 * The key lives in the script's properties, never in a cell.
 */
var GRIDLODE_API = "https://api.gridlode.com";
var GRIDLODE_CACHE_SECONDS = 21600; // reuse answers for 6 hours so recalculation doesn't charge again

/**
 * Calls a Gridlode engine and returns a value from its result.
 *
 * @param {string} engine Engine slug, e.g. "domain.dns", "url.metadata" or "domain.tech".
 * @param {string} input The main input: a domain, URL, email address, phone number or query.
 * @param {string} path Optional field to return, e.g. "title" or "records.MX.value.exchange".
 * @param {string} options Optional extra parameters, e.g. "types=A,MX" or "max_age=0".
 * @return The value at path (lists joined with commas), or the whole result as JSON.
 * @customfunction
 */
function GRIDLODE(engine, input, path, options) {
  if (!engine || input === "" || input === null || input === undefined) return "";
  var cache = CacheService.getScriptCache();
  var cacheKey = gridlodeHash_([engine, input, options || ""].join("|"));
  var hit = cache.get(cacheKey);
  var data;
  if (hit) {
    data = JSON.parse(hit);
  } else {
    data = gridlodeRequest_(String(engine).trim(), input, options);
    var text = JSON.stringify(data);
    if (text.length < 90000) cache.put(cacheKey, text, GRIDLODE_CACHE_SECONDS);
  }
  return gridlodeFormat_(path ? gridlodePick_(data, String(path).split(".")) : data);
}

function gridlodeRequest_(engine, input, options) {
  var key = PropertiesService.getScriptProperties().getProperty("GRIDLODE_API_KEY");
  if (!key) throw new Error("Add GRIDLODE_API_KEY under Apps Script > Project Settings > Script Properties.");
  var info = gridlodeEngine_(engine);
  var params = { max_age: "86400" }; // accept Gridlode's own cache (billed at a discount); override with "max_age=0"
  params[info.field] = String(input).trim();
  String(options || "").split("&").forEach(function (pair) {
    var i = pair.indexOf("=");
    if (i > 0) params[decodeURIComponent(pair.slice(0, i).trim())] = decodeURIComponent(pair.slice(i + 1).trim());
  });
  var query = Object.keys(params).map(function (k) {
    return encodeURIComponent(k) + "=" + encodeURIComponent(params[k]);
  }).join("&");
  var url = GRIDLODE_API + info.route + "?" + query;

  for (var attempt = 0; attempt < 4; attempt++) {
    var res = UrlFetchApp.fetch(url, { headers: { Authorization: "Bearer " + key }, muteHttpExceptions: true });
    var status = res.getResponseCode();
    if (status === 429 || status >= 500) {
      var headers = res.getHeaders();
      var wait = Number(headers["Retry-After"] || headers["retry-after"] || attempt + 1);
      Utilities.sleep(Math.min(wait, 5) * 1000);
      continue;
    }
    var body = JSON.parse(res.getContentText());
    if (status >= 400 || body.status === "error") {
      throw new Error(body.error ? body.error.code + ": " + body.error.message : "HTTP " + status);
    }
    return body.data;
  }
  throw new Error("Gridlode is busy. Try again in a moment.");
}

/** Maps an engine slug to its route and main parameter, from the public engine list. */
function gridlodeEngine_(slug) {
  var cache = CacheService.getScriptCache();
  var cached = cache.get("gridlode:engines");
  var map;
  if (cached) {
    map = JSON.parse(cached);
  } else {
    var list = JSON.parse(UrlFetchApp.fetch(GRIDLODE_API + "/v1/engines").getContentText()).engines;
    map = {};
    list.forEach(function (e) {
      var schema = e.params_schema || {};
      var field = (schema.required && schema.required[0]) || Object.keys(schema.properties || {})[0];
      map[e.slug] = { route: e.route, field: field };
    });
    cache.put("gridlode:engines", JSON.stringify(map), GRIDLODE_CACHE_SECONDS);
  }
  if (!map[slug]) throw new Error("Unknown engine " + slug + ". See https://gridlode.com/docs/engines");
  return map[slug];
}

/** Follows a dot path. On a list, it picks the rest of the path from every element. */
function gridlodePick_(value, parts) {
  for (var i = 0; i < parts.length; i++) {
    if (value === null || value === undefined) return "";
    if (Array.isArray(value) && !/^[0-9]+$/.test(parts[i])) {
      var rest = parts.slice(i);
      return value.map(function (v) { return gridlodePick_(v, rest); });
    }
    value = value[parts[i]];
  }
  return value;
}

function gridlodeFormat_(value) {
  if (value === null || value === undefined) return "";
  if (Array.isArray(value)) {
    var flat = [].concat.apply([], value);
    if (flat.every(function (v) { return v === null || typeof v !== "object"; })) {
      return flat.filter(function (v) { return v !== null && v !== ""; }).join(", ");
    }
    return JSON.stringify(value).slice(0, 50000);
  }
  if (typeof value === "object") return JSON.stringify(value).slice(0, 50000);
  if (typeof value === "string") return value.slice(0, 50000);
  return value;
}

function gridlodeHash_(text) {
  var bytes = Utilities.computeDigest(Utilities.DigestAlgorithm.SHA_256, text, Utilities.Charset.UTF_8);
  return "gridlode:" + Utilities.base64EncodeWebSafe(bytes);
}

// Workflow > Custom code action (Node.js). Secrets: GRIDLODE_API_KEY. Property to include: domain
exports.main = async (event, callback) => {
  const domain = event.inputFields["domain"];
  const res = await fetch("https://api.gridlode.com/v1/domain/tech?domain=" + encodeURIComponent(domain), {
    headers: { Authorization: "Bearer " + process.env.GRIDLODE_API_KEY },
  });
  const body = await res.json();
  if (body.status !== "success") throw new Error(body.error.code + ": " + body.error.message);
  callback({
    outputFields: { tech_stack: body.data.technologies.map((t) => t.name).join(", ") },
  });
};

claude mcp add --transport http gridlode https://api.gridlode.com/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

{
  "mcpServers": {
    "gridlode": {
      "type": "http",
      "url": "https://api.gridlode.com/mcp",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}