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:

The honest hackathon playbook, validated across years of post-mortems on r/hackathon and r/webdev: the winning teams are not the ones with the most sophisticated AI integration — they're the ones who ship a demo that runs reliably for three minutes on stage. Every hour you spend getting Claude to handle an edge case is an hour not spent on the slide deck, the landing page, or the moment in the demo where your co-founder accidentally clicks the wrong button. Treat Claude as a velocity multiplier on known tasks (scaffolding, boilerplate, copy), not as the load-bearing novelty of your submission.

Where the community correctly pushes back on AI-hackathon hype: judges at serious hackathons (MLH, Devpost flagship events, Y Combinator's AI hackathons) have seen the generic "ChatGPT wrapper" demo a thousand times. The projects that advance tend to do one concrete thing exceptionally well and use AI as infrastructure, not as the pitch. The Devpost winner archive and the MLH project gallery are a useful gut check before you commit to yet another RAG-over-documents idea.

Operating rule for 24-48h sprints: lock the model choice in the first hour, stub every API call in the first three, and freeze features at T-6h to focus exclusively on demo rehearsal. The Claude API pricing page makes the cost math trivial; the human planning is where the win happens.

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