Claude Hackathon Guide: Quick Start with API & Claude Code

Phase 1: Setup (5 minutes)

Step 1: Get the API Key

1. →Go to console.anthropic.com
2. →Create an account (email + verification)
3. →Add $5-10 in credits (Settings > Billing)
4. →Create an API key (Settings > API Keys)
5. →Copy the key: sk-ant-api03-...

Step 2: Install the SDK

# Python
pip install anthropic

# TypeScript/Node.js
npm install @anthropic-ai/sdk

Step 3: First Call (in 60 seconds)

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-api03-YOUR-KEY")

msg = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello Claude! Confirm the API is working."}]
)
print(msg.content[0].text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({ apiKey: "sk-ant-api03-YOUR-KEY" });

const msg = await client.messages.create({
  model: "claude-sonnet-4-20250514",
  max_tokens: 1024,
  messages: [
    { role: "user", content: "Hello Claude! Confirm the API is working." },
  ],
});
console.log(msg.content[0].text);

If it works → move to Phase 2. If it doesn't:

Phase 2: Useful Patterns (Copy-Paste Ready)

Pattern 1: Chatbot with Memory

import anthropic

client = anthropic.Anthropic()
conversation = []

def chat(message):
    conversation.append({"role": "user", "content": message})
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        system="You are the assistant for [YOUR APP]. You help users [GOAL].",
        messages=conversation
    )
    
    reply = response.content[0].text
    conversation.append({"role": "assistant", "content": reply})
    return reply

# Test
print(chat("Hello, what do you do?"))
print(chat("Give me an example."))

Pattern 2: Streaming (Real-time UI)

import anthropic

client = anthropic.Anthropic()

def stream_response(prompt):
    with client.messages.stream(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    ) as stream:
        full_response = ""
        for text in stream.text_stream:
            print(text, end="", flush=True)
            full_response += text
    return full_response

Pattern 3: Structured JSON Extraction

import anthropic
import json

client = anthropic.Anthropic()

def extract_json(text, schema_description):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"""Extract the following information from the text and return ONLY valid JSON.

Expected schema: {schema_description}

Text: {text}"""
        }]
    )
    return json.loads(response.content[0].text)

# Usage
result = extract_json(
    "Marie, 28 years old, Python dev at TechCorp in London, marie@tech.com",
    '{"name": str, "age": int, "role": str, "company": str, "city": str, "email": str}'
)
print(result)
# {"name": "Marie", "age": 28, "role": "Python dev", ...}

Pattern 4: Image Analysis

import anthropic
import base64

client = anthropic.Anthropic()

def analyze_image(image_path, question):
    with open(image_path, "rb") as f:
        image_data = base64.standard_b64encode(f.read()).decode("utf-8")
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": [
                {"type": "image", "source": {
                    "type": "base64",
                    "media_type": "image/png",
                    "data": image_data
                }},
                {"type": "text", "text": question}
            ]
        }]
    )
    return response.content[0].text

# Usage
print(analyze_image("screenshot.png", "Describe what you see and identify UX issues."))

Pattern 5: Tool Use (Agent)

import anthropic
import json

client = anthropic.Anthropic()

tools = [{
    "name": "search_database",
    "description": "Search for a product by name or category in the database.",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Search term"},
            "category": {"type": "string", "enum": ["tech", "food", "clothing"]}
        },
        "required": ["query"]
    }
}]

def handle_tool_call(name, input_data):
    if name == "search_database":
        # Simulate your real database here
        return [{"name": "MacBook Pro", "price": 2499}, {"name": "iPad Air", "price": 799}]
    return {"error": "Tool not found"}

def agent_chat(message):
    messages = [{"role": "user", "content": message}]
    
    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            tools=tools,
            messages=messages
        )
        
        if response.stop_reason == "end_turn":
            return response.content[0].text
        
        messages.append({"role": "assistant", "content": response.content})
        
        tool_results = []
        for block in response.content:
            if block.type == "tool_use":
                result = handle_tool_call(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": json.dumps(result)
                })
        
        messages.append({"role": "user", "content": tool_results})

Phase 3: Claude Code for Prototyping

Claude Code massively accelerates development during a hackathon.

Key Commands

Hackathon Workflow with Claude Code

# 1. Initialize the project
mkdir my-hackathon && cd my-hackathon
claude "Create a Python project with FastAPI, a /chat endpoint that uses the Claude API, 
and a simple HTML frontend. Include a Dockerfile and README."

# 2. Iterate quickly
claude "Add SSE streaming for Claude responses"
claude "Add an in-memory conversation history"
claude "Add support for uploaded images"

# 3. Fix issues
claude "The streaming doesn't work on the frontend, fix the JavaScript code"

# 4. Prepare for deployment
claude "Configure the Dockerfile for Railway/Render"

Phase 4: Quick Deployment

Option 1: Vercel (Frontend + API Routes)

# Next.js with API Routes
npx create-next-app@latest my-app
cd my-app
npm install @anthropic-ai/sdk
# Add your code in app/api/chat/route.ts
vercel deploy

Option 2: Railway (Python Backend)

# Create a Procfile
echo "web: uvicorn app:app --host 0.0.0.0 --port $PORT" > Procfile

# Deploy
railway login
railway init
railway up
# Add ANTHROPIC_API_KEY in environment variables

Option 3: Render

# render.yaml
# services:
#   - type: web
#     name: claude-hackathon
#     runtime: python
#     buildCommand: pip install -r requirements.txt
#     startCommand: uvicorn app:app --host 0.0.0.0 --port $PORT

# Push to GitHub → connect to Render → auto deployment

Deployment Platform Comparison

API Budget: How Much to Plan?

Tips to reduce costs:

1. →Use Haiku for simple tasks (classification, extraction)
2. →Enable prompt caching for repetitive system prompts
3. →Limit max_tokens — don't request 4096 if 512 is enough
4. →Add a rate limit on the application side

Top 10 Hackathon Mistakes to Avoid

Hackathon Checklist

Before the hackathon (Day -1)

• → Anthropic account created and credits added
• → API key generated and tested
• → SDK installed in your development environment
• → First successful API call
• → Claude Code installed

During the hackathon

• → Idea validated and scope reduced to minimum viable
• → First working prototype (1st hour)
• → Main feature complete (mid-hackathon)
• → Successful deployment (2h before end)
• → Demo prepared and tested (1h before end)

Essential Resources