Skip to content
ProofTell
Sign inSign up
Integrations

ProofTell, where your team already works.

A phone number, an email address or an IP address checked from the spreadsheet, the table or the workflow your team already uses. Each integration outside the dashboard takes an API key named for it, so one can be revoked without touching another.

A pt_test_ key is the free sandbox: simulated, deterministic answers. A pt_live_ key is charged per check from your balance.

API keys
Developers
Clay Live
pt_live_••••k2m9
Created today · Last used 2 minutes ago
Supabase Sandbox
pt_test_••••7q4d
Created today · Never used
One key per integration. Revoke one; the others keep running.
Works today

What you can use now.

Each card is an integration you can use today, with the steps to set it up.

Google Sheets

In the dashboard

Pick a tab from the dashboard’s Files page; the results come back as a new tab of the same spreadsheet.

Zapier

Connector

The four actions as steps of a Zap, and a trigger when a file completes.

n8n

Connector

A community node with the four actions, for a self-hosted n8n.

Make

Connector

A custom app: the four actions as modules of a scenario.

HubSpot

Connector

The four checks as workflow actions, and every contact checked with the results written back.

Activepieces

Connector

A piece with the four actions, installed from npm into a self-hosted Activepieces or a platform plan.

Node-RED

Connector

A ProofTell node with the four actions, installed from the palette; the answer in msg.payload.

Postman

Connector

The whole API as a Postman collection, its bodies filled with the sandbox’s inputs.

Claude

MCP server

ProofTell’s MCP server in Claude Desktop or Claude Code: ask Claude to check a number, an address or a sign-up.

Cursor

MCP server

ProofTell’s MCP server in Cursor: the four checks as tools for its agent.

VS Code

MCP server

ProofTell’s MCP server in VS Code’s agent mode: the four checks as tools.

Clay

Recipe

An HTTP API enrichment: a phone number or an email address checked for every row of a table.

Retool

Recipe

A REST API resource and a query per check, for the tables and forms of a Retool app.

Auth0

Recipe

A Pre User Registration Action that assesses each sign-up and denies the risky ones.

Supabase

Recipe

A Before User Created hook: an Edge Function that assesses each sign-up and refuses the risky ones.

In progress: Power Automate, Windmill and GoHighLevel. Each one is listed here the day it works. Missing the one your team uses? Write to support@prooftell.com.

The four actions

The same four actions, by the same names, everywhere.

A connector, a recipe or your own code: each action is one call to the API, charged per check from your balance; the sandbox is free. Every answer carries cost, what that check cost.

Read the API reference
ActionSendWhat comes back
Look up a phone number
POST /v1/phone
phone; country for a number in national format; level, one of basic, line_type, current_carrier, line_status, fraud_score (line_type when omitted)valid, line_type, e164, the formats, country_code, original_carrier, the level’s block, cost
Verify an email address
POST /v1/email
email; timeout in milliseconds, at most 45,000result, deliverable, reason, flags, did_you_mean, cost
Look up an IP address
POST /v1/ip
ipis_tor, is_vpn, is_datacenter, is_anonymous, country_code, city, asn, as_org, cost
Assess the risk of an identity
POST /v1/assess
any of phone, email, ip, one at least; country; reference, your own id, echoed backscore, verdict, reasons, each signal’s own result, cost
Google Sheets

A tab in, a new tab out.

No key to create: this one is the dashboard’s own. A tab of your spreadsheet becomes a file, runs like any file, and the results go back into the same spreadsheet as a new tab.

Bulk verification
  1. 1
    Open Files in the dashboard and choose Import from Google Sheets
    Google’s picker asks for access to the one spreadsheet you pick, nothing else in your Drive. Pick the tab, up to 200,000 rows.
  2. 2
    Confirm the columns, see the price, run
    We find the phone, email and IP columns and show you a sample; you choose the signals. The cost of every unique row is held on your balance before the first one runs, and duplicates run once.
  3. 3
    Write the results to the sheet
    When the file completes, one button writes your rows back as a new tab of the spreadsheet, our pt_ columns added to each. The CSV is there too. No Google token is stored.
Zapier

Four actions and one trigger, in any Zap.

Each action is a step of a Zap: the number, the address or the IP comes from the step before it, the answer’s fields go to the steps after. The trigger fires when a file of your organization completes.

  1. 1
    Create a key named Zapier
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Accept the invite and connect
    Open ProofTell in Zapier from the link on the card, add it to a Zap and paste the key when Zapier asks for the connection. The connection is labelled Live or Sandbox from the key.
  3. 3
    Add an action, or the trigger
    Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity: each answers with its fields, charged per check from your balance; the sandbox is free. File completed, the trigger, starts a Zap for each file that completes, with a live key: the sandbox runs no files.
n8n

A community node, in your own n8n.

The node ProofTell has four resources, Phone, Email, IP and Risk, one operation each. An AI agent in n8n can call it as a tool.

  1. 1
    Create a key named n8n
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Install the package
    In a self-hosted n8n: Settings → Community nodes → Install, and enter n8n-nodes-prooftell. Then create credentials of type ProofTell API with the key.
  3. 3
    Add the node
    Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity: each answers with its fields, charged per check from your balance; the sandbox is free.
Make

Four modules for your scenarios.

Each action is a module: map the number, the address or the IP from the modules before it, and the answer’s fields are there for the ones after.

  1. 1
    Create a key named Make
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Open the invite and connect
    The link on the card adds the ProofTell app to your Make organization. In a scenario, add a ProofTell module and create a connection with the key.
  3. 3
    Pick a module
    Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity: each answers with its fields, charged per check from your balance; the sandbox is free.
HubSpot

Four workflow actions, and every contact checked.

Connect a HubSpot account to your organization: its workflows get the four checks as actions, and its contacts can be checked all at once, the results written back to them as properties.

  1. 1
    Connect HubSpot
    In the dashboard, Developers → Integrations, Connect HubSpot. Pick Live, whose workflows run real checks charged to the account’s balance, or Sandbox, free, with simulated results for the documented test inputs. A HubSpot user allowed to install apps approves the access, then you confirm the account and the organization it joins. A HubSpot account belongs to one organization.
  2. 2
    Add a ProofTell action to a workflow
    In a HubSpot workflow, the four actions are under ProofTell: Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity. Each takes a property of the contact, its phone, email or IP address, and gives back the answer’s fields, which an Edit record action copies into properties or a branch acts on. Charged per check from your balance; the sandbox is free.
  3. 3
    Check all contacts
    On a live connection, Check all contacts reads the contacts with a phone, a mobile phone or an email into a file of your organization, up to 200,000. Pick the checks, see the estimate and run it, as for any file; then Write results to HubSpot puts the results on the contacts, as properties of a group named ProofTell. The file is charged per check; writing back is free.
  4. 4
    Disconnect
    Disconnect, on the account’s line in the dashboard, deletes the connection’s access and revokes it at HubSpot; the workflows’ ProofTell actions then answer that the account is not connected.
Activepieces

A piece, installed from npm.

ProofTell is a piece of its own, @prooftell/piece-prooftell on npm, not in the Activepieces catalogue: a self-hosted Activepieces installs it, and so does a platform plan on their cloud.

  1. 1
    Create a key named Activepieces
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Install the piece
    Settings → Pieces → Install Piece, source NPM Registry: Piece Name @prooftell/piece-prooftell, Piece Version 1.0.0.
  3. 3
    Add a step and pick an action
    In a flow, add a step, pick the ProofTell piece and one of its actions: Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity. The connection takes the key, and its label says Sandbox or Live. Each action answers with its fields, charged per check from your balance; the sandbox is free.
Node-RED

A node in the palette, the answer in msg.payload.

The node ProofTell runs one of the four actions per message. Its examples, under Import → Examples, run each action on the sandbox.

  1. 1
    Create a key named Node-RED
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Install the node
    Menu → Manage palette → Install, and search for @prooftell/node-red-prooftell (Node-RED 4 or later). In the node, add a connection with the key: Node-RED keeps it in its credentials, so an exported flow does not carry it.
  3. 3
    Pick the action and wire it
    Look up a phone number, Verify an email address, Look up an IP address and Assess the risk of an identity. Each field reads msg.payload.phone, .email or .ip by default, and the answer, with its fields, replaces msg.payload. A failed check goes to a Catch node with the API’s message. Charged per check from your balance; the sandbox is free.
Postman

The whole API, ready to send.

The collection is built from the API reference: the four actions, the balance and the files, every body filled with the sandbox’s inputs, the documented answers saved as examples.

  1. 1
    Create a key named Postman
    In the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Fork the collection
    From the ProofTell workspace on Postman, fork the collection into your own workspace, then set its variable api_key to the key. Leave base_url as it is.
  3. 3
    Send
    “Your account’s balance” first: a 200 proves the key. Then the four actions, each answering with its fields, charged per check from your balance; the sandbox is free.
MCP server

Ask your assistant to check a sign-up.

  1. 1
    Create a key named for the assistant
    Claude, Cursor or VS Code: in the dashboard, Developers → Integrations. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Add the server
    The configuration on the right, with the key. The server, @prooftell/mcp, runs on your machine (Node.js 18 or later; npx fetches it) and stores nothing.
  3. 3
    Ask
    “Is this sign-up risky: jane@example.com from 203.0.113.66?” The assistant has five tools, the four actions and the account’s balance, and reads the answer’s fields. Charged per check from your balance; the sandbox is free.
claude mcp add prooftell \
  --env PROOFTELL_API_KEY=pt_live_… \
  -- npx -y @prooftell/mcp
// Settings → Developer → Edit config: claude_desktop_config.json
{
  "mcpServers": {
    "prooftell": {
      "command": "npx",
      "args": ["-y", "@prooftell/mcp"],
      "env": { "PROOFTELL_API_KEY": "pt_live_…" }
    }
  }
}
Cursor: ~/.cursor/mcp.json
{
  "mcpServers": {
    "prooftell": {
      "command": "npx",
      "args": ["-y", "@prooftell/mcp"],
      "env": { "PROOFTELL_API_KEY": "pt_live_…" }
    }
  }
}
VS Code: .vscode/mcp.json
{
  "inputs": [
    { "type": "promptString", "id": "prooftell-key",
      "description": "ProofTell API key", "password": true }
  ],
  "servers": {
    "prooftell": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@prooftell/mcp"],
      "env": { "PROOFTELL_API_KEY": "${input:prooftell-key}" }
    }
  }
}
Clay

An enrichment column per check.

  1. 1
    Create a key named Clay
    In the dashboard, Developers → Integrations. Save it where Clay keeps the API keys of its HTTP API enrichment, so it never sits in a cell. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Add an enrichment: HTTP API
    Method POST, the URL, the two headers, and a JSON body that references your columns, as on the right. A number in national format needs "country" too, from a column or typed.
  3. 3
    Add the fields as columns
    For a phone: valid, line_type, e164, original_carrier. For an email: result, deliverable, reason. Each row is one check, charged from your balance; the sandbox is free, and a cell that cannot be read as a number or an address is answered and free.
Read the API reference
POST https://api.prooftell.com/v1/phone
Authorization: Bearer {{ProofTell key}}
Content-Type: application/json

{
  "phone": "{{Phone}}",
  "level": "line_type"
}
POST https://api.prooftell.com/v1/email
Authorization: Bearer {{ProofTell key}}
Content-Type: application/json

{
  "email": "{{Email}}"
}
{
  "status": "success",
  "valid": true,
  "line_type": "mobile",
  "e164": "+14155552671",
  "country_code": "US",
  "original_carrier": "T-Mobile USA, Inc.",
  "level": "line_type",
  …
}
{
  "status": "success",
  "result": "deliverable",
  "deliverable": true,
  "reason": "mailbox_exists",
  "did_you_mean": "",
  "flags": {
    "disposable": false,
    "role_account": false,
    "free_provider": false,
    "catch_all": false
  },
  …
}
Retool

A resource, then a query per check.

  1. 1
    Create a key named Retool
    In the dashboard, Developers → Integrations. It goes in the resource’s header: Retool keeps a resource’s headers on its server, out of the app. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Create the resource
    Resources → Create new → Resource → REST API: the base URL and one header, Authorization, as on the right. Retool sends the JSON content type itself.
  3. 3
    Add a query per check
    In an app, or in the Query Library to share it across apps: the resource, POST, the path after the base URL, and a JSON body whose values reference the app’s components, a table’s selected row or a form’s field. Show {{ query1.data.line_type }} or {{ query1.data.result }} beside it. Each run is one check, charged from your balance; the sandbox is free.
Read the API reference
# Resources → Create new → Resource → REST API
Name      ProofTell
Base URL  https://api.prooftell.com
Headers   Authorization   Bearer pt_live_…

# A query on the resource
Method    POST   v1/phone
Body      JSON
          phone   {{ table1.selectedRow.phone }}
          level   line_type
# A query on the same resource
Method    POST   v1/email
Body      JSON
          email   {{ table1.selectedRow.email }}
{
  "status": "success",
  "valid": true,
  "line_type": "mobile",
  "e164": "+14155552671",
  "country_code": "US",
  "original_carrier": "T-Mobile USA, Inc.",
  "level": "line_type",
  …
}
{
  "status": "success",
  "result": "deliverable",
  "deliverable": true,
  "reason": "mailbox_exists",
  "did_you_mean": "",
  "flags": {
    "disposable": false,
    "role_account": false,
    "free_provider": false,
    "catch_all": false
  },
  …
}
Auth0

Every sign-up assessed before the user is created.

  1. 1
    Create a key named Auth0
    In the dashboard, Developers → Integrations. Keep it as the Action’s secret PROOFTELL_KEY. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Create the Action
    Actions → Library → Create Action → Build from scratch, trigger Pre User Registration, with the code on the right: the email address and the IP address assessed together; a deny refuses the sign-up with a message, any other verdict lets it through, its score kept in the user’s app_metadata. Deploy it.
  3. 3
    Add it to the trigger
    Actions → Triggers → Pre User Registration: drag the Action into the flow, then Apply. It runs for database and passwordless sign-ups. Each sign-up is one assessment, charged from your balance; the sandbox is free.
Read the API reference
Pre User Registration
// Secrets: PROOFTELL_KEY, a key named Auth0.
exports.onExecutePreUserRegistration = async (event, api) => {
  const res = await fetch("https://api.prooftell.com/v1/assess", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${event.secrets.PROOFTELL_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      email: event.user.email,
      ip: event.request.ip,
    }),
  })
  // ProofTell did not answer, or the balance is out: the sign-up goes on.
  if (!res.ok) return
  const { id, score, verdict } = await res.json()
  if (verdict === "deny") {
    api.access.deny("prooftell_deny", "We could not create this account.")
    return
  }
  api.user.setAppMetadata("prooftell", { id, score, verdict })
}
The answer
{
  "id": "asm_uevezsnajjrt3t2r",
  "mode": "test",
  "reference": "signup-48213",
  "score": 95,
  "verdict": "deny",
  "reasons": [
    { "code": "phone_voip", "points": 20,
      "message": "The number is a VoIP line, easy to obtain anonymously." },
    { "code": "email_disposable", "points": 35,
      "message": "The email address uses a disposable provider." },
    { "code": "ip_tor", "points": 40,
      "message": "The IP address is a Tor exit node." }
  ],
  "signals": {
    "phone": { "status": "ok", "cost": "0.000000", "result": { … } },
    "email": { "status": "ok", "cost": "0.000000", "result": { … } },
    "ip":    { "status": "ok", "cost": "0.000000", "result": { … } }
  },
  "ruleset": "2026-10-07",
  "cost": "0.000000",
  "currency": "USD",
  "createdAt": "2026-10-02T08:27:43Z"
}
Supabase

A hook that assesses each sign-up before the user is created.

  1. 1
    Create a key named Supabase
    In the dashboard, Developers → Integrations. Keep it as the secret PROOFTELL_KEY: supabase secrets set PROOFTELL_KEY=…. A pt_test_ key is the free sandbox; a pt_live_ key spends the account’s balance.
  2. 2
    Deploy the Edge Function
    The code on the right, then supabase functions deploy before-user-created --no-verify-jwt: the hook signs its call instead of sending a user’s token. A deny refuses the sign-up with a message; any other verdict lets it through.
  3. 3
    Turn the hook on
    Authentication → Auth Hooks → Before User Created: HTTPS, the function’s URL. Generate its secret and keep it as BEFORE_USER_CREATED_HOOK_SECRET. Each sign-up is one assessment, charged from your balance; the sandbox is free.
Read the API reference
supabase/functions/before-user-created/index.ts
import { Webhook } from "https://esm.sh/standardwebhooks@1.0.0"

const secret = Deno.env.get("BEFORE_USER_CREATED_HOOK_SECRET")!
const hook = new Webhook(secret.replace("v1,whsec_", ""))

Deno.serve(async (req) => {
  let event
  try {
    event = hook.verify(await req.text(), Object.fromEntries(req.headers))
  } catch {
    return new Response("Bad signature", { status: 400 })
  }
  const { user, metadata } = event
  const res = await fetch("https://api.prooftell.com/v1/assess", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${Deno.env.get("PROOFTELL_KEY")}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      email: user.email || undefined,
      phone: user.phone || undefined,
      ip: metadata.ip_address,
    }),
  })
  // ProofTell did not answer, or the balance is out: the sign-up goes on.
  if (res.ok && (await res.json()).verdict === "deny") {
    return Response.json(
      { error: { http_code: 403, message: "We could not create this account." } },
      { status: 403 },
    )
  }
  return Response.json({})
})
The answer
{
  "id": "asm_uevezsnajjrt3t2r",
  "mode": "test",
  "reference": "signup-48213",
  "score": 95,
  "verdict": "deny",
  "reasons": [
    { "code": "phone_voip", "points": 20,
      "message": "The number is a VoIP line, easy to obtain anonymously." },
    { "code": "email_disposable", "points": 35,
      "message": "The email address uses a disposable provider." },
    { "code": "ip_tor", "points": 40,
      "message": "The IP address is a Tor exit node." }
  ],
  "signals": {
    "phone": { "status": "ok", "cost": "0.000000", "result": { … } },
    "email": { "status": "ok", "cost": "0.000000", "result": { … } },
    "ip":    { "status": "ok", "cost": "0.000000", "result": { … } }
  },
  "ruleset": "2026-10-07",
  "cost": "0.000000",
  "currency": "USD",
  "createdAt": "2026-10-02T08:27:43Z"
}

Bring ProofTell to the tool you open every morning.

Create an account, take a sandbox key, make your first call in minutes.

staging