How to Integrate Replit with Chanty

Chanty provides API access through a personal or team API token. To get yours, log in to your Chanty workspace at app.chanty.com and navigate to the account settings menu (click your avatar in the bottom-left corner, then select 'Settings'). Look for the 'API' or 'Integrations' section. If your Chanty plan supports API access, you will see an option to generate an API token — click 'Generate Token' and copy the token value. If you do not see this option, your plan may require an upgrade; check Chanty's pricing page for API availability. Next, you need the channel IDs for the channels your bot will post to. Make a GET request to https://api.chanty.com/v1/channels with your Authorization header to list all channels — the response includes each channel's ID. Note the IDs for the channels you plan to use. You will also need your team ID, which is returned in the same channels response or accessible from your Chanty workspace URL. Keep all three values (API token, channel ID, team ID) ready for the next step. Never put these values directly in code — store them exclusively in Replit Secrets.

1# Python — list Chanty channels to find channel IDs
2import requests
3import os
4
5CHANTY_API_TOKEN = os.environ["CHANTY_API_TOKEN"]
6
7headers = {
8    "Authorization": f"Bearer {CHANTY_API_TOKEN}",
9    "Content-Type": "application/json"
10}
11
12response = requests.get("https://api.chanty.com/v1/channels", headers=headers)
13if response.status_code == 200:
14    channels = response.json()
15    for channel in channels.get("data", []):
16        print(f"Name: {channel['name']}, ID: {channel['id']}")
17else:
18    print(f"Error {response.status_code}: {response.text}")

Open your Repl in Replit and click the lock icon (🔒) in the left sidebar to open the Secrets panel. Add the following keys: CHANTY_API_TOKEN (your API bearer token), CHANTY_CHANNEL_ID (the target channel ID where your bot will post), and CHANTY_TEAM_ID (your workspace team ID). Replit Secrets are stored AES-256 encrypted and injected as environment variables at runtime — they are never written to disk or exposed in your version history. Do not hardcode these values in your source files; Replit's Secret Scanner will flag hardcoded tokens and they could be exposed if your Repl is made public. After adding the secrets, run a quick verification script to confirm they load correctly before writing your main application code. Also install the required packages: for Node.js, run npm install express axios in the Shell; for Python, add requests and flask to requirements.txt or install via the Packages panel.

1// Node.js — verify Chanty secrets (verify-secrets.js)
2const required = ['CHANTY_API_TOKEN', 'CHANTY_CHANNEL_ID', 'CHANTY_TEAM_ID'];
3for (const key of required) {
4  const val = process.env[key];
5  if (!val) {
6    console.error(`MISSING: ${key} — add it in Replit Secrets (lock icon 🔒)`);
7    process.exit(1);
8  }
9  console.log(`OK: ${key} loaded (${val.length} chars)`);
10}
11console.log('All Chanty secrets verified.');

With your credentials in place, write the core message-sending function. Chanty's message API endpoint is POST https://api.chanty.com/v1/messages. The request body must include the channel_id and the message text. You can optionally include attachments, mentions, or task references. The response returns the created message object with its ID, timestamp, and author details. Build a thin Express or Flask server around this function so your other services can trigger Chanty notifications via HTTP POST. For an Express server, bind to 0.0.0.0:3000 so Replit correctly exposes the port — the .replit config handles the external port mapping automatically. Add an /api/notify endpoint that accepts a JSON body with a message field and posts it to the configured Chanty channel. This endpoint becomes the internal webhook for all your notification flows. Test it locally in the Replit preview by sending a POST request from the Shell using curl or from a simple test script.

1// Node.js — Express server with Chanty message sending (index.js)
2const express = require('express');
3const axios = require('axios');
4
5const app = express();
6app.use(express.json());
7
8const CHANTY_API_TOKEN = process.env.CHANTY_API_TOKEN;
9const CHANTY_CHANNEL_ID = process.env.CHANTY_CHANNEL_ID;
10
11if (!CHANTY_API_TOKEN || !CHANTY_CHANNEL_ID) {
12  console.error('Missing required secrets. Check Replit Secrets (lock icon 🔒).');
13  process.exit(1);
14}
15
16async function sendChantyMessage(text) {
17  const response = await axios.post(
18    'https://api.chanty.com/v1/messages',
19    { channel_id: CHANTY_CHANNEL_ID, content: text },
20    { headers: { Authorization: `Bearer ${CHANTY_API_TOKEN}`, 'Content-Type': 'application/json' } }
21  );
22  return response.data;
23}
24
25app.post('/api/notify', async (req, res) => {
26  const { message } = req.body;
27  if (!message) return res.status(400).json({ error: 'message field required' });
28  try {
29    const result = await sendChantyMessage(message);
30    res.json({ success: true, message_id: result.data?.id });
31  } catch (err) {
32    console.error('Chanty error:', err.response?.data || err.message);
33    res.status(500).json({ error: 'Failed to send message' });
34  }
35});
36
37app.listen(3000, '0.0.0.0', () => console.log('Server running on port 3000'));

To receive events from Chanty (such as new messages or task status changes), you need to configure a webhook URL in your Chanty workspace settings. First, make sure your Replit Repl is deployed or running so it has a stable public URL. In development, the Replit preview URL (visible in the browser address bar when the Repl is running) can be used for testing. For production, deploy as an Autoscale deployment (click the Deploy button, choose Autoscale) to ensure your webhook endpoint is always available. In Chanty's settings, navigate to Integrations > Webhooks and add a new webhook pointing to your Repl's public URL followed by your webhook path, e.g., https://your-repl-name.your-username.repl.co/chanty/webhook. Select the events you want to receive (message.created, task.created, task.updated are the most common). When Chanty fires a webhook, it sends a POST request with a JSON body containing the event type, timestamp, and the relevant object data. Your webhook handler should respond with HTTP 200 within a few seconds — if it times out, Chanty will retry. Process any heavy work asynchronously after returning the 200 response.

1# Python — Flask webhook receiver (app.py)
2from flask import Flask, request, jsonify
3import os
4import json
5
6app = Flask(__name__)
7
8@app.route('/chanty/webhook', methods=['POST'])
9def chanty_webhook():
10    payload = request.get_json()
11    if not payload:
12        return jsonify({'error': 'Invalid payload'}), 400
13
14    event_type = payload.get('type', 'unknown')
15    print(f"Received Chanty event: {event_type}")
16    print(json.dumps(payload, indent=2))
17
18    # Route events to handlers
19    if event_type == 'message.created':
20        handle_new_message(payload)
21    elif event_type == 'task.created':
22        handle_new_task(payload)
23
24    # Always return 200 quickly
25    return jsonify({'received': True}), 200
26
27def handle_new_message(payload):
28    message = payload.get('data', {}).get('message', {})
29    text = message.get('content', '')
30    print(f"New message: {text}")
31    # Add your routing logic here
32
33def handle_new_task(payload):
34    task = payload.get('data', {}).get('task', {})
35    print(f"New task: {task.get('title', 'Untitled')}")
36
37if __name__ == '__main__':
38    app.run(host='0.0.0.0', port=3000)

Webhook-driven integrations require your server to be running whenever Chanty sends an event. In Replit, a Repl that is not deployed goes to sleep after inactivity, meaning Chanty events sent while it is asleep will fail or be dropped. To solve this, deploy your Repl as an Autoscale deployment: click the Deploy button in the Replit toolbar, choose Autoscale as the deployment type, and confirm your start command. Autoscale deployments start from zero instances and scale up when traffic arrives — perfect for webhook servers that receive sporadic events. The deployment gets a stable production URL (distinct from your development preview URL) that you should use for the Chanty webhook configuration. After deploying, update the webhook URL in Chanty's settings to point to the production URL. Add a .replit configuration file to set the correct run command and port binding so deployments start reliably. Autoscale is the recommended deployment type for Chanty integrations because message frequency is unpredictable — you pay only when your server is processing requests rather than keeping a Reserved VM running continuously.

1# .replit deployment configuration
2# Add this to your .replit file
3
4# For Node.js:
5# [deployment]
6# run = ["node", "index.js"]
7# deploymentTarget = "cloudrun"
8#
9# [[ports]]
10# internalPort = 3000
11# externalPort = 80
12
13# For Python/Flask:
14# [deployment]
15# run = ["python", "app.py"]
16# deploymentTarget = "cloudrun"
17#
18# [[ports]]
19# internalPort = 3000
20# externalPort = 80