Integration

Pipefy integration

Pipefy process management through its GraphQL API. Pipefy exposes no REST surface at all: every call is a POST of a GraphQL document to the same endpoint. This integration covers the structure of a workspace (organizations, pipes, phases, database tables) and the work items inside it (cards): listing and reading them, creating one, moving it between phases and writing a single field value.

Connect Pipefy How integrations work

Ask it in chat

Say what should happen.
The workflow builds itself.

When this happens, do that in Pipefy.Built from the 11 Pipefy tools below, on the connection you add once.

Common Pipefy use cases

retitling a card after triage
exporting the current state of a process
reading a lookup table used by a process
discovering which pipes a token can reach
listing the database tables of a workspace
writing an enriched value back onto a card
advancing a request once an approval arrives
discovering the columns of a Pipefy database
turning an inbound request into a tracked card
reading the answers on a request before acting on it

What you can do with Pipefy

Each of these is one operation on one endpoint, available both as a workflow step and as a tool an AI agent can call on its own. Nothing bundles several operations into one action, so what a run did stays readable afterwards.

Most endpoints run on the free plan. A few, mainly the ones that publish on your behalf, need a paid plan.

Card, 5 operations

create_cardCreate cardPOSTCreates one card and returns its identifier and starting phase.
get_cardGet cardPOSTReturns a single card and everything currently filled on it.
list_cardsList cardsPOSTReturns a page of cards of a pipe, with paging state under pageInfo.
move_card_to_phaseMove card to phasePOSTMoves one card to a destination phase and returns the phase it ended up in.
update_cardUpdate cardPOSTUpdates a card and returns its new state.

Organization, 2 operations

get_organizationGet organizationPOSTReturns the structure of a single organization.
list_organizationsList organizationsPOSTReturns every reachable organization with its pipes.

Card field, 1 operation

update_card_fieldUpdate card fieldPOSTSets one field of one card and reports whether the write was accepted.

Pipe, 1 operation

get_pipeGet pipePOSTReturns the structure of a single pipe: its phases, its start form and its labels.

Table, 1 operation

get_tableGet tablePOSTReturns the structure of a Pipefy database table.

Table record, 1 operation

list_table_recordsList table recordsPOSTReturns the records of a Pipefy database table as a connection.

Use Pipefy from Claude Code, Cursor or Codex

Connect Pipefy in LiveContext, create an API key in Settings, then add the LiveContext MCP server to your client. Its Pipefy operations become tools the client can call, next to every other integration you connected.

Claude Code

claude mcp add --transport http livecontext https://livecontext.ai/mcp --header "X-API-Key: YOUR_API_KEY"

Codex (~/.codex/config.toml)

[mcp_servers.livecontext]
url = "https://livecontext.ai/mcp"

[mcp_servers.livecontext.http_headers]
"X-API-Key" = "YOUR_API_KEY"

Cursor, Claude Desktop and other JSON configs

{
  "mcpServers": {
    "livecontext": {
      "type": "http",
      "url": "https://livecontext.ai/mcp",
      "headers": {
        "X-API-Key": "YOUR_API_KEY"
      }
    }
  }
}

Set up the MCP server step by step

How to connect Pipefy

Create your workspace
Sign up free. Nothing to install.
Connect Pipefy once
Add your Pipefy connection in Settings. Every tool from this integration reuses it, and secrets are encrypted at rest and visible only to you.
Describe the job in chat
The workflow builds itself in front of you and picks the endpoints it needs. Drag the steps yourself on the canvas whenever you would rather be explicit.

Pipefy integration FAQ

What can you do with the Pipefy integration?

LiveContext exposes 11 operations on Pipefy, covering card, organization, card field and pipe. Common uses include retitling a card after triage, exporting the current state of a process and reading a lookup table used by a process.