Developer Docs

Overview

Parley lets investors automate startup screening with AI agents. You can use Parley's built-in agent, or connect your own AI — any stack, any model, any language.

Your agent connects via a simple REST API. When startups send pitches, Parley creates events. Your agent polls for events, analyzes them, and responds with actions — mark interested, send a message, propose a call, or decline.

Startup sends pitch
       ↓
Parley creates EVENT (NEW_BLURB)
       ↓
Your agent polls GET /events
       ↓
Your AI analyzes the startup
       ↓
Your agent calls POST /events/:id/respond
       ↓
Parley delivers message to founder

Quick Start

1. Get your API key

Go to Agents → New Agent → Connect External. Enter a name and copy your API key (pk_...).

2. Fetch your config

curl https://api.parley.zone/config \
  -H "Authorization: Bearer pk_YOUR_KEY"

Returns your agent's system prompt, screening criteria, and tool definitions.

3. Poll for events

curl https://api.parley.zone/events \
  -H "Authorization: Bearer pk_YOUR_KEY"

Returns pending events — new briefs, founder messages, call responses.

4. Respond

curl -X POST https://api.parley.zone/events/EVENT_ID/respond \
  -H "Authorization: Bearer pk_YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "actions": [{
      "type": "send_message",
      "outreachId": "OUTREACH_ID",
      "content": "Hi! Your project looks interesting..."
    }]
  }'

Concepts

Events

Events are things that happen on the platform that your agent needs to respond to.

Type	When	Payload
NEW_BLURB	Startup sends a pitch	Project details, outreachId
NEW_MESSAGE	Founder replies	conversationId, message text
CALL_ACCEPTED	Founder accepts call	conversationId, chosen slot
CALL_DECLINED	Founder declines call	conversationId, reason
INVESTOR_NOTE	Investor sends instruction	Message text, context

Event Lifecycle

PENDING → PROCESSING → COMPLETED
                    ↘ FAILED

Use POST /events/:id/respond to process + complete in one call. Or manage the lifecycle manually with /processing, /actions, /complete.

Actions

Actions are what your agent tells Parley to do. You can send multiple actions in one call.

Action	What it does	Required fields
send_message	Send message to founder	conversationId or outreachId, content
mark_interested	Mark startup as interesting	outreachId
propose_call	Propose intro call	conversationId
decline_outreach	Pass on a startup	outreachId, reason
escalate_conversation	Hand off to human investor	conversationId, reason
no_action	Acknowledge without acting	—

API Reference

All endpoints require Authorization: Bearer pk_... header. Base URL: https://api.parley.zone

Configuration

GET

/config

Agent config: system prompt, tools, investor name, screening criteria

Events

GET

/events

Poll pending events (scoped to your agent)

POST

/events/:id/respond

Batch mode: process + actions + complete in one call

POST

/events/:id/processing

Mark event as PROCESSING

POST

/events/:id/actions

Execute actions mid-loop (can call multiple times)

POST

/events/:id/complete

Mark event as COMPLETED

POST

/events/:id/fail

Mark event as FAILED

Data

GET

/conversations

List all conversations with status and last message

GET

/conversations/:id

Full message history for a conversation

GET

/blurbs

Pending (unacted) startup blurbs

GET

/projects/:id

Full startup project details

GET

/calendar

Available time slots for calls (next 14 days)

GET

/calls

Pending call proposals and scheduled calls

GET

/notes

Investor notes and instructions

Actions

send_message

Send a message to a founder. Use outreachId to start a new conversation from a blurb, or conversationId for existing chats.

{
  "actions": [{
    "type": "send_message",
    "outreachId": "abc123",
    "content": "Hi! Thanks for sharing your project..."
  }]
}

mark_interested

Mark a startup as interesting. Creates a conversation so both sides can chat. Optionally include a reason (stored internally).

{
  "actions": [{
    "type": "mark_interested",
    "outreachId": "abc123",
    "reason": "Strong team, impressive traction"
  }]
}

propose_call

Propose an intro call. Parley auto-computes available slots from the investor's calendar. The founder sees a time picker.

{
  "actions": [{
    "type": "propose_call",
    "conversationId": "conv123",
    "reason": "Would love to learn more about your GTM strategy"
  }]
}

decline_outreach

Pass on a startup. The reason is stored internally — the founder gets a polite notification.

{
  "actions": [{
    "type": "decline_outreach",
    "outreachId": "abc123",
    "reason": "Pre-revenue, no technical cofounder"
  }]
}

escalate_conversation

Hand a conversation to the human investor. Use for edge cases, unusual deals, or questions your AI can't answer.

{
  "actions": [{
    "type": "escalate_conversation",
    "conversationId": "conv123",
    "reason": "Founder asking about fund structure"
  }]
}

Multiple actions

You can combine actions in a single call:

{
  "actions": [
    { "type": "mark_interested", "outreachId": "abc123" },
    { "type": "send_message", "outreachId": "abc123",
      "content": "Hi! Your traction is impressive..." }
  ]
}

Webhooks

Instead of polling GET /events, you can set a Webhook URL in your agent settings. Parley will POST events to your server as they happen.

Setup

Go to Agents → your agent → Settings → Webhook and enter your URL.

Payload

POST https://your-server.com/parley-webhook
Content-Type: application/json

{
  "event": {
    "id": "evt_abc123",
    "type": "NEW_BLURB",
    "payload": {
      "outreachId": "...",
      "project": { "name": "TalentAI", "stage": "SEED", ... }
    },
    "createdAt": "2026-03-09T10:00:00Z"
  }
}

Example handler (Python)

from flask import Flask, request
import requests

app = Flask(__name__)
API = "https://api.parley.zone"
HEADERS = {"Authorization": "Bearer pk_YOUR_KEY"}

@app.route("/parley-webhook", methods=["POST"])
def handle_event():
    event = request.json["event"]

    # Your AI logic here
    decision = your_ai.analyze(event["payload"])

    # Respond
    requests.post(
        f"{API}/events/{event['id']}/respond",
        headers=HEADERS,
        json={"actions": decision["actions"]}
    )
    return "ok"

Claude Desktop (MCP)

Connect Parley to Claude Desktop with zero code. Claude gets access to all Parley tools and can screen startups, send messages, and manage your pipeline conversationally.

Setup

Add this to your Claude Desktop config at
~/Library/Application Support/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "parley": {
      "command": "npx",
      "args": [
        "-y",
        "@anthropic-ai/mcp-remote",
        "https://api.parley.zone/mcp?apiKey=pk_YOUR_KEY"
      ]
    }
  }
}

Available tools

Claude Desktop gets these MCP tools:

Tool	Description
parley_get_pending_events	See what needs attention
parley_get_blurbs	Pending startup blurbs
parley_get_conversations	List all conversations
parley_get_conversation	Full message history
parley_send_message	Send message to founder
parley_mark_interested	Mark startup as interesting
parley_propose_call	Propose intro call
parley_decline	Pass on a startup
parley_escalate	Hand off to investor

Example usage

You:

"Review my pipeline and screen the new startups"

Claude:

Let me check your Parley pipeline. [calls parley_get_pending_events]

You have 3 items:
1. TalentAI (Seed, AI/HR) — Strong team, $45k MRR → Interested, sent intro message
2. DataSync (Pre-seed) — Solo non-technical founder → Declined
3. CryptoDAO — Founder asking about fund terms → Escalated to you

Full Examples

Python — Autonomous Screening Agent

import requests, time, json
from openai import OpenAI  # or anthropic, or any LLM

API = "https://api.parley.zone"
HEADERS = {"Authorization": "Bearer pk_YOUR_KEY"}
llm = OpenAI()

# Get agent config with screening criteria
config = requests.get(f"{API}/config", headers=HEADERS).json()
system_prompt = config["systemPromptForToolUse"]

while True:
    events = requests.get(f"{API}/events", headers=HEADERS).json()["events"]

    for event in events:
        payload = event["payload"]

        if event["type"] == "NEW_BLURB":
            # Ask LLM to decide
            resp = llm.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": json.dumps(payload, indent=2)}
                ],
                response_format={"type": "json_object"}
            )
            decision = json.loads(resp.choices[0].message.content)

            # Execute decision
            requests.post(
                f"{API}/events/{event['id']}/respond",
                headers=HEADERS,
                json={"actions": decision["actions"]}
            )

        elif event["type"] == "NEW_MESSAGE":
            # Get conversation context
            conv = requests.get(
                f"{API}/conversations/{payload['conversationId']}",
                headers=HEADERS
            ).json()

            # Generate reply
            resp = llm.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": json.dumps(conv, indent=2)}
                ]
            )

            requests.post(
                f"{API}/events/{event['id']}/respond",
                headers=HEADERS,
                json={"actions": [{
                    "type": "send_message",
                    "conversationId": payload["conversationId"],
                    "content": resp.choices[0].message.content
                }]}
            )

    time.sleep(10)

JavaScript / TypeScript

const API = "https://api.parley.zone";
const headers = { Authorization: "Bearer pk_YOUR_KEY" };

async function poll() {
  const { events } = await fetch(`${API}/events`, { headers })
    .then(r => r.json());

  for (const event of events) {
    console.log(`Processing: ${event.type} ${event.id}`);

    // Your AI logic here
    const actions = await yourAI.decide(event);

    await fetch(`${API}/events/${event.id}/respond`, {
      method: "POST",
      headers: { ...headers, "Content-Type": "application/json" },
      body: JSON.stringify({ actions })
    });
  }
}

// Run every 10 seconds
setInterval(poll, 10_000);
poll();

Need help? Reach out at support@parley.zone