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.
What you can use now.
Each card is an integration you can use today, with the steps to set it up.
Google Sheets
Pick a tab from the dashboard’s Files page; the results come back as a new tab of the same spreadsheet.
Zapier
The four actions as steps of a Zap, and a trigger when a file completes.
n8n
A community node with the four actions, for a self-hosted n8n.
HubSpot
The four checks as workflow actions, and every contact checked with the results written back.
Activepieces
A piece with the four actions, installed from npm into a self-hosted Activepieces or a platform plan.
Node-RED
A ProofTell node with the four actions, installed from the palette; the answer in msg.payload.
Postman
The whole API as a Postman collection, its bodies filled with the sandbox’s inputs.
Claude
ProofTell’s MCP server in Claude Desktop or Claude Code: ask Claude to check a number, an address or a sign-up.
Cursor
ProofTell’s MCP server in Cursor: the four checks as tools for its agent.
VS Code
ProofTell’s MCP server in VS Code’s agent mode: the four checks as tools.
Clay
An HTTP API enrichment: a phone number or an email address checked for every row of a table.
Retool
A REST API resource and a query per check, for the tables and forms of a Retool app.
Auth0
A Pre User Registration Action that assesses each sign-up and denies the risky ones.
Supabase
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 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.
| Action | Send | What 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,000 | result, deliverable, reason, flags, did_you_mean, cost |
Look up an IP address POST /v1/ip | ip | is_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 back | score, verdict, reasons, each signal’s own result, cost |
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- 1Open Files in the dashboard and choose Import from Google SheetsGoogle’s picker asks for access to the one spreadsheet you pick, nothing else in your Drive. Pick the tab, up to 200,000 rows.
- 2Confirm the columns, see the price, runWe 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.
- 3Write the results to the sheetWhen 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.
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.
- 1Create a key named ZapierIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Accept the invite and connectOpen 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.
- 3Add an action, or the triggerLook 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.
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.
- 1Create a key named n8nIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Install the packageIn a self-hosted n8n: Settings → Community nodes → Install, and enter
n8n-nodes-prooftell. Then create credentials of type ProofTell API with the key. - 3Add the nodeLook 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.
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.
- 1Create a key named MakeIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Open the invite and connectThe 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.
- 3Pick a moduleLook 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.
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.
- 1Connect HubSpotIn 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.
- 2Add a ProofTell action to a workflowIn 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.
- 3Check all contactsOn 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.
- 4DisconnectDisconnect, 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.
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.
- 1Create a key named ActivepiecesIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Install the pieceSettings → Pieces → Install Piece, source NPM Registry: Piece Name
@prooftell/piece-prooftell, Piece Version1.0.0. - 3Add a step and pick an actionIn 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.
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.
- 1Create a key named Node-REDIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Install the nodeMenu → 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. - 3Pick the action and wire itLook 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,.emailor.ipby default, and the answer, with its fields, replacesmsg.payload. A failed check goes to a Catch node with the API’s message. Charged per check from your balance; the sandbox is free.
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.
- 1Create a key named PostmanIn the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Fork the collectionFrom the ProofTell workspace on Postman, fork the collection into your own workspace, then set its variable
api_keyto the key. Leavebase_urlas it is. - 3Send“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.
Ask your assistant to check a sign-up.
- 1Create a key named for the assistantClaude, Cursor or VS Code: in the dashboard, Developers → Integrations. A
pt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Add the serverThe configuration on the right, with the key. The server,
@prooftell/mcp, runs on your machine (Node.js 18 or later;npxfetches it) and stores nothing. - 3Ask“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_…" }
}
}
}{
"mcpServers": {
"prooftell": {
"command": "npx",
"args": ["-y", "@prooftell/mcp"],
"env": { "PROOFTELL_API_KEY": "pt_live_…" }
}
}
}{
"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}" }
}
}
}An enrichment column per check.
- 1Create a key named ClayIn 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; apt_live_key spends the account’s balance. - 2Add an enrichment: HTTP APIMethod 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. - 3Add the fields as columnsFor 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.
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
},
…
}A resource, then a query per check.
- 1Create a key named RetoolIn 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; apt_live_key spends the account’s balance. - 2Create the resourceResources → Create new → Resource → REST API: the base URL and one header, Authorization, as on the right. Retool sends the JSON content type itself.
- 3Add a query per checkIn 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.
# 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
},
…
}Every sign-up assessed before the user is created.
- 1Create a key named Auth0In the dashboard, Developers → Integrations. Keep it as the Action’s secret
PROOFTELL_KEY. Apt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Create the ActionActions → 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
denyrefuses the sign-up with a message, any other verdict lets it through, its score kept in the user’sapp_metadata. Deploy it. - 3Add it to the triggerActions → 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.
// 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 })
}{
"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"
}A hook that assesses each sign-up before the user is created.
- 1Create a key named SupabaseIn the dashboard, Developers → Integrations. Keep it as the secret
PROOFTELL_KEY:supabase secrets set PROOFTELL_KEY=…. Apt_test_key is the free sandbox; apt_live_key spends the account’s balance. - 2Deploy the Edge FunctionThe 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. Adenyrefuses the sign-up with a message; any other verdict lets it through. - 3Turn the hook onAuthentication → 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.
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({})
}){
"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.