Most AI tutorials start with a setup checklist. Pick a model provider. Create an account. Wire up a vector database for memory. Stand up a server to hold conversation state. Glue it all together. Then, finally, you send a message.
Backboard skips all of that. One API call sends your first message. A thread, an assistant, memory, and routing across thousands of models are already running behind that single call. You do not assemble the stack. It is the stack.
Here is the whole thing.
Step 1: Get a key
Sign up at app.backboard.io, go to Settings then API Keys, and copy your key. New accounts get $5 in free credits for 30 days. No credit card.
That is the only setup. Keep your key server-side, never in frontend or mobile code.
Step 2: Send the message
Pick your language. Same call in all three.
Python
pip install backboard-sdk
import asyncio
from backboard import BackboardClient
async def main():
client = BackboardClient(api_key="YOUR_API_KEY")
response = await client.send_message(
"Hello! Tell me a fun fact about space."
)
print("Reply:", response.content)
print("Thread ID:", response.thread_id)
print("Assistant ID:", response.assistant_id)
asyncio.run(main())
JavaScript (Node 18+)
No install needed. Just fetch.
const response = await fetch("https://app.backboard.io/api/threads/messages", {
method: "POST",
headers: {
"X-API-Key": "YOUR_API_KEY",
"Content-Type": "application/json",
},
body: JSON.stringify({
content: "Hello! Tell me a fun fact about space.",
}),
});
const result = await response.json();
console.log("Reply:", result.content);
console.log("Thread ID:", result.thread_id);
console.log("Assistant ID:", result.assistant_id);
cURL
curl -X POST "https://app.backboard.io/api/threads/messages" \
-H "X-API-Key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"content": "Hello! Tell me a fun fact about space."}'
Run it. You get a reply. That is your first AI message.
What just happened
You sent one string. Backboard did the rest:
-
Created a thread. The
thread_idin the response is a live conversation. Send the next message with it and the model remembers what was said. -
Created an assistant. The
assistant_idis a reusable profile. Attach memory, documents, and tools to it later without changing your call. -
Picked a model. No provider config required. It defaulted to
openai/gpt-4o. You can change that with two arguments, shown below.
No vector DB. No state server. No provider SDK. One call.
Continue the conversation
Pass the thread_id back. The model now has context.
follow_up = await client.send_message(
"Make it shorter.",
thread_id=response.thread_id,
)
print(follow_up.content) # knows you mean the space fact
That is stateful conversation with zero extra infrastructure.
Swap the model with two arguments
One key gives you thousands of models. Change the provider and model per message. Same thread, same code.
response = await client.send_message(
"Explain quantum computing simply.",
llm_provider="anthropic",
model_name="claude-sonnet-4-20250514",
)
Want a different model next turn? Change two strings. You are never locked to one provider.
Turn on memory
Add memory="Auto" and the assistant remembers facts across conversations, not just within one thread.
# Thread 1: tell it something
await client.send_message(
"My name is Sarah and I prefer dark mode.",
assistant_id="your-assistant-id",
memory="Auto",
)
# Thread 2, same assistant: it remembers
reply = await client.send_message(
"What do you remember about me?",
assistant_id="your-assistant-id",
memory="Auto",
)
print(reply.content) # "Your name is Sarah and you prefer dark mode."
Persistent memory, one argument. No database to provision.
The point
The first call is one line because the platform is full-stack. Memory, model routing, RAG, and stateful threads sit behind a single key. You start with a working AI message, then turn on capabilities as you need them by adding arguments, not services.
Sign up, grab a key, and send your first message: app.backboard.io
Full docs: docs.backboard.io