LinkedIn profiles in Flowise: a LinkedIn tool through MCP or a Custom Tool

In an agentflow, a Flowise agent uses the tools in its Agent node's Tools list (Flowise's Tools & MCP page). A Custom MCP tool gives the agent an MCP server's tools, and a Custom Tool is a JavaScript function you save in Flowise. No tool reads a LinkedIn profile from its URL.

On October 12, 2026, we searched Flowise's code, its other repositories and its npm package. "linkedin" appears in none of its 64 marketplace templates, and in one tool's options: Exa Search, whose Category option "linkedin profile" narrows a web search. The Composio tool loads its list of apps from Composio, LinkedIn among them. Composio's LinkedIn tools use your LinkedIn login: they post as you and read your own profile. Their person profile tool takes a member's person ID, not a profile URL.

• Flowise, on Node.js. We ran it on Node.js 22.18.0, though npm warned that the flowise 3.1.4 package asks for Node.js 24. Flowise's docs list 18.15.0, or 20 and above.

  npm install -g flowise
  npx flowise start

  Then open http://localhost:3000 and create the admin account Flowise asks for. In our test, npm installed 3,206 packages.
• A Datacircle API key: Sign up at datacircle.dev with your work email: a $5 credit, that's 2,105 LinkedIn profiles at $2.375 per 1,000. Log in at datacircle.dev/login with your work email. Your API key is on the page once you're in.
• Your key in a Flowise variable, so it stays out of the flow. In Variables, click Add Variable: Variable Name datacircleApiKey, Type Static, Value your key. The MCP config and the Custom Tool below both read it.
• A language model for the Agent. We picked OpenAI and gpt-5.4-mini in the Agent node's Model, with an OpenAI credential. We tested with a script that answers like OpenAI's API in place of a real model, and tried no other provider.

Our MCP server is at https://api.datacircle.dev/mcp. It gets a LinkedIn profile from its URL, through Up2Data, HarvestAPI or Fetchin. Per Flowise's Tools & MCP page, add a Custom MCP tool to the Agent node and give it the server's URL and headers. Create an agentflow, connect a Start node to an Agent node, and set:

The MCP Server Config, where {{$vars.datacircleApiKey}} is the variable with your API key:

{
  "url": "https://api.datacircle.dev/mcp",
  "headers": {
    "Authorization": "Bearer {{$vars.datacircleApiKey}}"
  }
}

The System message:

If get_linkedin_profile says up2data's daily limit is reached, call it again with provider fetchin.

Save the agentflow, open its chat and ask:

Read the LinkedIn profile at https://www.linkedin.com/in/example-profile: the job title, company, location and headline.

Flowise gives the model our whole answer, as JSON text

The model got our tool's name, its whole description and its two inputs, url and provider, but not its output schema or our server's instructions. Flowise cuts a tool's description at 1,024 characters by default, and ours is 804. The first request to the model was 1,879 bytes with only get_linkedin_profile picked, and 3,993 with all our tools.

Our server sends each answer as text and as structuredContent. Flowise gives the model the text, inside MCP's content list, as JSON: the provider's JSON, plus datacircle_meta, what the call cost and your balance after it.

[{"type":"text","text":"{\"data\": {…}, \"meta\": {…}, \"datacircle_meta\": {…}}"}]

Up2Data's example answer reached the model as 1,390 characters. A saved Fetchin answer of 65,229 characters reached it whole, 68,885 with the list around it.

Flowise doesn't retry a call, and the model reads our errors

The tool takes url, and provider: up2data (the default), harvestapi or fetchin. At Up2Data's limit, the server tells your agent to call again through Fetchin or HarvestAPI. HarvestAPI costs more per 1,000 profiles than the other two, so we name Fetchin in the System message.

Flowise passes our errors to the model like any answer, and sends each call once. At Up2Data's limit, the model reads:

[{"type":"text","text":"{\"error\": \"daily up2data limit reached for your account …\"}"}]

Our 429 was free, and our scripted model called again with fetchin and got the profile. Every other error reached our server once too, and the model read our JSON. If Fetchin can't find the profile, we bill one lookup. Our MCP server docs list every tool.

With a wrong key, the flow stops before any model call

With a wrong key in datacircleApiKey, Custom MCP's Available Actions showed No Available Actions, with "No available actions, please check your API key and refresh". On api.datacircle.dev, Flowise tried MCP's Streamable HTTP and then its older SSE transport, got a 401 from each, and answered HTTP 500:

Error: predictionsServices.buildChatflow - Error in Agent node: Invalid MCP Server Config:
Error: SSE error: Non-200 status code (401)

Set the right key in datacircleApiKey.

Flowise waits 60 seconds for an MCP tool

Flowise's MCP client waits up to 60 seconds for a tool call, above the 45 seconds our API waits for a provider. Our stand-in server answered after 50 seconds, and the model got the profile. We then delayed its answer to 65 seconds, and Flowise stopped the run at 60 seconds with HTTP 500 and:

Error in Agent node: MCP error -32001: Request timed out

On api.datacircle.dev, we answer 503, at no charge, when a provider hasn't answered within 45 seconds, before Flowise stops waiting.

You send the provider's own request to api.datacircle.dev, with your Datacircle key. That's the only change. The function sends Up2Data's and Fetchin's own requests, with X-Data-Provider naming the provider. Up2Data's request is in our API reference. In Tools, click Create and fill in:

Get the current job title, company, location and headline on a LinkedIn profile, from the profile's URL, like https://www.linkedin.com/in/example-profile. Returns the keys job_title, company, location and headline, or one key, error, when the profile can't be read. Each call asks the provider live and may be billed to the Datacircle balance.

const fetch = require("node-fetch");
const api = $vars.datacircleApiUrl || "https://api.datacircle.dev";

// One call to Datacircle's API through one provider. Fetchin's 429 is its rate limit: wait a second and send it again.
async function send(provider, path, request) {
  let answer;
  for (const wait of [0, 1, 2]) {
    await new Promise((resolve) => setTimeout(resolve, wait * 1000));
    answer = await fetch(api + path, {
      ...request,
      headers: { "Authorization": "Token " + $vars.datacircleApiKey, "X-Data-Provider": provider, "Content-Type": "application/json" },
      timeout: 60000,
    });
    if (provider !== "fetchin" || answer.status !== 429) return answer;
  }
  return answer;
}

let answer = await send("up2data", "/v1/profiles/enrich", { method: "POST", body: JSON.stringify({ url: $url }) });
if (answer.status === 200) {
  const profile = (await answer.json()).data;
  const company = profile.current_company || {};
  return JSON.stringify({ job_title: company.title, company: company.name, location: (profile.location || {}).raw, headline: profile.headline });
}
if (answer.status === 429) { // Up2Data's daily limit: Fetchin answers instead
  answer = await send("fetchin", "/api/v1/profile?profileUrlOrUrn=" + encodeURIComponent($url), { method: "GET" });
  if (answer.status === 200) {
    const profile = await answer.json();
    return JSON.stringify({ job_title: profile.jobTitle, company: profile.companyName, location: profile.location, headline: profile.title });
  }
}
if (answer.status === 404 || answer.status === 422) return JSON.stringify({ error: "This LinkedIn profile is private or deleted." });
if (answer.status === 400) return JSON.stringify({ error: "This is not a LinkedIn profile URL. Send one like https://www.linkedin.com/in/example-profile" });
if (answer.status === 402) return JSON.stringify({ error: "The Datacircle balance is too low for this call. Tell the user to add funds on their Datacircle dashboard." });
if ([429, 500, 502, 503, 504].includes(answer.status)) return JSON.stringify({ error: "The provider didn't answer (" + answer.status + "), and the call wasn't charged. Try again in a minute." });
throw new Error("Datacircle answered " + answer.status + ": " + (await answer.text())); // 401: the datacircleApiKey variable is wrong

Save it. Then build the same agentflow as above, with no System message, and in the Agent node's Tools pick Custom Tool and, in its Select Tool, get_linkedin_profile.

The model gets the tool's name, its description, which names the answer's keys, and url with its description. The function reads the URL as $url and your key as $vars.datacircleApiKey, as Flowise's Custom Tool page shows.

It sends the URL to Up2Data. At Up2Data's daily limit (its 429), it sends the same URL to Fetchin. Fetchin takes 5 requests a second across all our customers, and returns a 429 past that: the function waits one second and sends it again, then waits two seconds and sends it once more.

The function returns JSON text, and Flowise gives it to the model unchanged:

{"job_title": …, "company": …, "location": …, "headline": …}

For a private or deleted profile, a URL that isn't a profile, a low balance or a provider error, it returns one key, error, so the agent can tell the user and go on. In our tests, Flowise sent each of these calls to our API once. Each field comes from the same JSON path as in our Python post:

With a wrong key (401), the function throws, and Flowise stops the agentflow. We tried a wrong key on api.datacircle.dev: after one model call, Flowise answered HTTP 500 with:

Error: predictionsServices.buildChatflow - Error in Agent node: NodeVM Execution Error:
Error: Datacircle answered 401: {"error": "invalid api key"}

Set the right key in datacircleApiKey. The function waits up to 60 seconds for our answer: our stand-in server answered after 50 seconds, and the model got the profile. We then delayed its answer to 65 seconds, and Flowise stopped the run at 60 seconds with a network timeout.

A second variable, datacircleApiUrl, is for tests: when it exists, the function calls that address in place of api.datacircle.dev, so you can run the flow against a stand-in for our API without spending your balance. Flowise blocks calls to 127.0.0.1 and private addresses unless you start it with HTTP_SECURITY_CHECK=false.

Flowise sends each tool call to our API. We bill each call that gets a profile, and each call for a profile Fetchin or HarvestAPI can't find, at the price on our pricing page. The function sends up to four requests per call, and we bill at most one of them: Up2Data's 429 and Fetchin's 429 are free.

The agentflow's Agent node calls a tool each time the model asks, with no limit. A scripted model that asked for the tool at every turn made more than 1,000 calls to a stand-in for our API in 15 seconds, through either tool, until we stopped the script. At each turn, Flowise sends the model every tool result so far: through Custom MCP, the last request was more than 2,000,000 bytes.

For a cap, build the agent as a chatflow: an OpenAI chat model node, a Buffer Memory node and the same Custom MCP or Custom Tool, all connected to a Tool Agent node:

With Max Iterations empty, our scripted model made 15 calls. With 4, it made 4. At the limit, the agent answers with this line, and no profile:

Agent stopped due to max iterations.

With the long Fetchin answer at each turn, the requests grew from 1,911 bytes to 78,352, 154,793 and 231,234. With a wrong key in Custom MCP, Flowise stopped the chatflow before any model call. The Custom Tool's 401 didn't stop it: the model read the error and answered.

The Agent node has a Require Human Input setting on each tool, and Flowise's Agentflow page says "Agents can also be configured to request permission before executing tools". We set it on our tool and ran the flow through Flowise's prediction API. The run stopped with the tool call and two actions, Proceed and Reject, and our server got no call. We sent Proceed back on the same chat, as the Human In The Loop tutorial's flow does, and the agent made one call and answered with the profile. With Reject, our server got no call.

Flowise keeps a Custom MCP server's tools in memory, and Require Human Input stays on them. After we ran a flow with the setting on, Flowise asked for approval in another flow with the same MCP Server Config and the setting off, until we restarted Flowise.

Through Custom MCP, the model reads our JSON for every answer but the 401, error or not: a wrong key stops the flow before any model call. Up2Data takes $1 a day per account (421 profiles), with a shared daily limit for all customers, then answers 429 until 00:00 UTC. HarvestAPI has no daily limit. Fetchin has no daily limit either.

• We tested on October 12, 2026, with flowise 3.1.4 (flowise-components 3.1.4) on Node.js 22.18.0, the TypeScript MCP SDK 1.29.0, @langchain/openai 1.2.5 and node-fetch 2.7.0.
• We ran Flowise without a browser and built each flow through its REST API: the Custom Tool from the fields and code above, unchanged, and Custom MCP with the config above. We ran each flow through Flowise's prediction API, with the OpenAI node's Base Path pointed at a scripted stand-in for OpenAI's API.
• We tested the Custom Tool against a stand-in for our API that returned each answer in the table. We ran the MCP flow against a stand-in for our MCP server with the tools our live server lists, and tried each error, a 50 and a 65 second answer, the long answer, Require Human Input, and both agent nodes with a model that never stops.
• We didn't try a real Datacircle key or a real model, and didn't open Flowise's canvas or chat window: the Available Actions texts above are what Flowise's REST API sent for that list.

We charge your balance the prices on our pricing page, with no markup:

Say your agent looks up 1,000 profiles in a day, one call each, and the providers find every one. You pay us at most $1.86: $1.00 for 421 through Up2Data and $0.86 for the other 579 through Fetchin. Through Fetchin alone, the same 1,000 would cost less: $1.485. Both tools call Up2Data first because it bills nothing for a profile it can't find, and all our customers share Fetchin's rate limit. Your agent may call the tool more than once per question. Your model's provider bills you for its tokens.

The same agent in Langflow's visual editor: LinkedIn profiles in Langflow. In Dify: LinkedIn profiles in Dify. The same call as an n8n workflow, without an agent: LinkedIn profiles in n8n. In code, as a tool for an agent: LinkedIn profiles in LangChain and other frameworks on our blog. The same call from a script: get LinkedIn profile data with Node.js. In Claude, ChatGPT or Cursor: our LinkedIn MCP server. Other vendors' prices per 1,000: LinkedIn profile API pricing compared.