How to Use Claude Code Routines: The Complete Setup Guide

Routines are named, reusable Claude Code scripts that run independently of the Claude Code desktop app. You can:

• Schedule them to run on a cron schedule (e.g., "every Monday at 9am")
• Trigger them via API from your own app or service
• Listen to webhooks from GitHub, Slack, or other platforms to auto-trigger

Unlike one-off code execution, Routines persist, log execution history, and integrate into your broader automation stack.

The easiest way to start is with a scheduled routine—Claude Code runs your script on autopilot.

1. Create the routine in Claude Code Desktop

   • Open Claude Code on your machine
   • Click "New Routine"
   • Write your code (or paste an existing script)
   • Give it a clear name: daily_report_generator (not "script1")

2. Set the schedule

   • Choose "Scheduled" mode
   • Pick your timezone (this matters—a lot)
   • Set the cron expression or use the UI picker
   • Examples: 0 9 * * 1-5 (9am weekdays) or 0 0 * * 0 (midnight Sunday)

3. Test it once before scheduling

   • Click "Run Now" to verify it works
   • Check logs for errors
   • Fix any issues, then enable the schedule

API Routines are the same script, but triggered on-demand from your application.

Setup:

1. Create the routine with the same steps as above
2. Switch mode to "API"
3. Claude Code generates a unique endpoint URL and API key
4. Copy both—you'll need them in your code

Making the API call:

curl -X POST [https://routines.anthropic.com/api/v1/execute/YOUR_ROUTINE_ID](https://routines.anthropic.com/api/v1/execute/YOUR_ROUTINE_ID) \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"input": "optional data to pass to the routine"}'

Example: Trigger from a Node.js app

const response = await fetch('[https://routines.anthropic.com/api/v1/execute/my-routine-id](https://routines.anthropic.com/api/v1/execute/my-routine-id)', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk-routine-xxxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ input: 'my data' })
});
const result = await response.json();
console.log(result.execution_id); // Track the execution

Key points:

• API calls are async—you get back an execution_id, not the result
• Poll the execution status endpoint to check when it's done
• Results are stored in the Routine's history in Claude Code Desktop

The most powerful setup: your routine triggers automatically when something happens in GitHub.

Setup:

1. In Claude Code, create your routine in "Webhook" mode
2. Claude Code generates a webhook URL
3. Go to your GitHub repo → Settings → Webhooks
4. Add a new webhook:
   • Payload URL: paste Claude Code's webhook URL
   • Content type: application/json
   • Events: Pick what triggers it (push, pull_request, issues, etc.)
   • Check "Active"
5. Save—GitHub will immediately test it

Example use case: Auto-fix code quality on push

// Your routine code
const payload = process.env.WEBHOOK_PAYLOAD; // GitHub sends the event data
const commit = JSON.parse(payload).commits[0];
console.log(`Analyzing commit: ${commit.id}`);
// Run your linter, formatter, or analysis here

Webhook events to watch for:

• push — runs when code is pushed
• pull_request — runs when a PR is opened/updated
• issues — runs when an issue is created
• workflow_run — runs when a GitHub Action completes (great for post-CI tasks)

Pro tip: Use GitHub's webhook history to debug if your routine isn't triggering.

Daily report generator (Scheduled)

• Routine: Query your database, format a report, email it
• Schedule: 0 9 * * 1-5 (9am weekdays)
• Result: Your inbox gets the report automatically every morning

Slack notification on merged PR (Webhook)

• Trigger: GitHub webhook on pull_request (action: closed + merged)
• Routine: Parse the PR data, call Slack API, post a summary
• Result: Your team sees PR changes in real-time, no manual pinging

On-demand analysis (API)

• Your web app has a "Analyze my data" button
• Button calls the API Routine endpoint
• Routine processes the data, stores results in your database
• Your app polls for the result and shows it to the user

Nightly data sync (Scheduled + Webhook)

• Combine scheduled (nightly at 2am) with webhook (on demand after a manual GitHub release tag)
• Same routine, triggered two ways, logs to the same history

Routines unlock true automation with Claude Code—no servers to manage, no deployment complexity. Pick the trigger type that fits your workflow:

• Scheduled for predictable, recurring tasks
• API when you need on-demand execution from your app
• Webhooks when external services should kick off your routine

Start simple. Test one routine end-to-end. Once you see it working, scale up. The hardest part isn't the setup—it's resisting the urge to automate everything at once.

Next step: Go write your first routine and set it to run tomorrow morning. You'll be hooked.

Claude Code Documentation: Routines — Official setup guide and API reference. Claude Code Desktop App — Where you create and manage routines. GitHub Webhooks Docs — Setting up GitHub triggers. Our previous post: Claude Code Gets a Full Redesign — and Routines — The announcement of Routines and what they mean for enterprises.