> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chatsyncs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Understanding the ChatSyncs Developer API (Beginner's Guide)

> A beginner's guide to the ChatSyncs Developer API — what it is, the assistant analogy for how it works, what 'your application' means, and exactly where you paste the API code for a website, Google Sheets, CRM, PHP, Node.js, Python, or Postman. Use when a customer asks what the API is, when to use it, or where the code actually goes.

<Info>
  **Who is this guide for?** Beginners who have never used an API before. By the end, you'll
  understand what the ChatSyncs Developer API is, when to use it, and **where you actually write
  the code** — which is the part most beginners get stuck on.
</Info>

## What is the ChatSyncs Developer API?

The **Developer → API** section in ChatSyncs lets **other software** talk to ChatSyncs
automatically — instead of you manually opening ChatSyncs and clicking buttons, another
application can ask ChatSyncs to do something for you.

For example, another application can ask ChatSyncs to:

* Send a WhatsApp message
* Create a subscriber
* Assign a label
* Trigger a chatbot
* Upload media
* Check message status

## Think of ChatSyncs as a person

Imagine ChatSyncs is your assistant. Normally, you tell your assistant:

> "Please send a WhatsApp message to Rahul."

Your assistant sends the message. Now imagine your **website** tells the assistant
automatically, instead of you:

```
Website
   │
   ▼
ChatSyncs
   │
   ▼
WhatsApp
```

That's exactly what the API does.

## What does "Your Application" mean?

API guides constantly say **"Your Application"** — this just means:

**Any software you build or use that talks to ChatSyncs.**

That could be a:

<CardGroup cols={3}>
  <Card title="Website" />

  <Card title="Mobile App" />

  <Card title="CRM" />

  <Card title="ERP" />

  <Card title="Google Sheets" />

  <Card title="Google Apps Script" />

  <Card title="n8n" />

  <Card title="Make.com" />

  <Card title="Zapier" />

  <Card title="Bubble" />

  <Card title="FlutterFlow" />

  <Card title="Python / PHP / Node.js" />
</CardGroup>

## Where do I paste the API code?

This is the most common question — and the answer surprises most beginners:

<Warning>
  **You do NOT paste API code inside the ChatSyncs dashboard.** You paste it into **your own
  application**. Where exactly depends on what you're building.
</Warning>

| Your application | Where the code goes                  |
| ---------------- | ------------------------------------ |
| Website          | Your PHP, Node.js, or Python backend |
| Mobile App       | Your Android or iOS project          |
| Google Sheets    | Extensions → Apps Script             |
| n8n              | An HTTP Request node                 |
| Make             | An HTTP module                       |
| Zapier           | A Webhooks step                      |
| Bubble           | The API Connector                    |
| FlutterFlow      | An API Call action                   |
| Postman          | A New Request (no coding at all)     |

## Real-life example 1 — a website contact form

Say you own `www.mycompany.com`, and a customer fills out your contact form:

```
Name: Rahul
Phone: 919876543210
Message: I need pricing.
```

**Without the API** — nothing happens by itself. Someone has to open ChatSyncs and send the
message by hand:

```
Customer → Website → Employee opens ChatSyncs → Employee clicks Send
```

**With the API** — everything happens automatically:

```
Customer → Website → ChatSyncs API → WhatsApp → Customer receives:
"Hi Rahul, Thanks for contacting us."
```

The website's files might look like this:

```
Website
├── index.html
├── contact.html
└── submit.php
```

The API code goes inside **`submit.php`** — **not** inside ChatSyncs.

## Real-life example 2 — Google Sheets

Say you store leads in a Google Sheet:

| Name  | Phone        |
| ----- | ------------ |
| Rahul | 919876543210 |

Whenever a new row is added:

```
Google Sheet → Apps Script → ChatSyncs API → WhatsApp
```

The API code goes inside **Extensions → Apps Script**.

## Real-life example 3 — a CRM

When your sales team's CRM creates a new lead:

```
CRM → ChatSyncs API → WhatsApp → Welcome Message
```

The CRM itself is what calls the API — usually from a "webhook" or "automation" setting inside
the CRM.

## Real-life example 4 — a PHP website

<Steps>
  <Step title="Create a file">Create `send-message.php`.</Step>
  <Step title="Paste the code">Paste the API code from the [reference](/developer-api/whatsapp/send-text-message) into it.</Step>
  <Step title="Run it">Visit `http://localhost/send-message.php` — PHP sends the request to ChatSyncs.</Step>
</Steps>

## Real-life example 5 — Node.js

<Steps>
  <Step title="Create a folder">Create `my-project`.</Step>
  <Step title="Create a file">Inside it, create `index.js`.</Step>
  <Step title="Paste the code">Paste the API code into `index.js`.</Step>
  <Step title="Run it">Run `node index.js` — Node.js sends the request.</Step>
</Steps>

## Real-life example 6 — Python

<Steps>
  <Step title="Create a file">Create `send.py`.</Step>
  <Step title="Paste the code">Paste the API code into it.</Step>
  <Step title="Run it">Run `python send.py` — Python sends the request.</Step>
</Steps>

## Real-life example 7 — Postman (no coding)

If you don't know how to code yet, **Postman** is the easiest way to try the API:

```
Open Postman → New Request → Paste URL → Add API Token → Add Parameters → Click Send
      ↓
  ChatSyncs
      ↓
  WhatsApp
```

No file, no folder, no programming language — just a URL, your API key, and a Send button.

## Why does ChatSyncs provide an API?

Because developers want to automate tasks. Instead of manually opening ChatSyncs, their
software tells ChatSyncs what to do — sending messages, creating subscribers, assigning
labels, triggering chatbot flows, uploading media, fetching conversations, checking delivery
status.

## Real business example — a hospital

**Without the API**, every appointment needs manual work:

```
Receptionist → Opens ChatSyncs → Types patient number → Clicks Send
```

**With the API**, it's automatic:

```
Patient books appointment → Hospital software → ChatSyncs API → WhatsApp
→ "Your appointment has been confirmed."
```

## Real business example — an online store

```
Customer buys a product → Shopify → ChatSyncs API → WhatsApp
→ "Your order has been confirmed."
```

No employee sends that message by hand.

## Real business example — lead generation

```
Customer fills a Facebook Lead Form → CRM → ChatSyncs API → WhatsApp
→ "Thank you for contacting us."
```

## When should I use the API?

Use it whenever another application needs ChatSyncs to do something automatically — a website,
CRM, ERP, Google Sheets, mobile app, or an automation tool like n8n, Make, Zapier, Bubble, or
FlutterFlow.

## When do I NOT need the API?

If you're already inside the ChatSyncs dashboard, clicking buttons by hand, you usually don't
need the API at all. For example:

```
Open ChatSyncs → Click Send Message → Choose Customer → Click Send
```

That doesn't need the API — you're already doing it yourself.

## Summary

The ChatSyncs API isn't something you use **inside** ChatSyncs — it's a way for **other
applications** to talk to ChatSyncs automatically:

```
Your Software → ChatSyncs API → WhatsApp → Customer
```

"Your Software" can be a website, CRM, Google Sheets, a Python/PHP/Node.js script, a mobile
app, or an automation platform. The API lets all of these automate WhatsApp messaging and
subscriber management, without anyone needing to manually open the ChatSyncs dashboard.

<Tip>
  Ready to actually try it? The [Quickstart](/developer-api/introduction#quickstart) walks
  through sending your very first message, with exact copy-paste steps.
</Tip>

## Frequently asked

<AccordionGroup>
  <Accordion title="Where do I paste the API code?">
    Never inside ChatSyncs itself — always inside **your own application**: a backend file on
    your website, an Apps Script on a Google Sheet, a node in n8n/Make/Zapier, or a Postman
    request if you're not coding at all. See the table above for your exact case.
  </Accordion>

  <Accordion title="Do I need to know how to code?">
    Not necessarily — **Postman** lets you try any API call by pasting a URL and clicking Send,
    no programming required. Coding is only needed if you want this to run automatically
    inside your own website, app, or script.
  </Accordion>

  <Accordion title="Is the API a replacement for using the ChatSyncs dashboard?">
    No — it's an extra option. If you're happy clicking buttons in ChatSyncs by hand, you don't
    need the API. It's only useful when some *other* software needs to talk to ChatSyncs
    automatically.
  </Accordion>

  <Accordion title="What's the difference between this and the Meta WhatsApp API?">
    Meta's API is the messaging system underneath WhatsApp itself — see
    [WhatsApp Business API Explained](/learn/whatsapp-api-explained). ChatSyncs's own API sits
    on top and covers everything ChatSyncs does — bots, subscribers, labels, catalogs — through
    one simpler set of instructions.
  </Accordion>

  <Accordion title="Where's the exact code for sending a message, creating a subscriber, etc.?">
    Every action has its own page with the exact request to copy in the
    [Developer API reference](/developer-api/introduction), starting with the
    [Quickstart](/developer-api/introduction#quickstart).
  </Accordion>
</AccordionGroup>