Package Information
Available Nodes
Documentation generating…
Documentation
n8n-nodes-connecttoteams-connector
This is an n8n community node. It lets you send and receive SMS-style messages
through ConnecttoTeams in your n8n workflows.
Who this is for
ConnecttoTeams lets a business's phone numbers send and
receive SMS inside Microsoft Teams: customers text a business number, and
staff read and reply in a Teams conversation. Each of those business phone
numbers is a DID (direct inward dialing number) — the term used throughout
this README. The SMS Responder is ConnecttoTeams' messaging backend; every
node in this package talks to it.
You need a ConnecttoTeams account and, for each DID you want to use from n8n,
a token issued by ConnecttoTeams (see Authentication). Without a
ConnecttoTeams account these nodes have nothing to connect to.
The nodes send to the production ConnecttoTeams SMS Responder
(smsbot.connecttoteams.com).
Nodes
The package adds ConnecttoTeams to n8n's node panel. Open it to see its
actions and its trigger:
| In the panel | What it does |
|---|---|
| Message → Send an SMS | Sends a text or picture message from one of your DIDs to a single recipient, e.g. one message per row of a Google Sheet. |
| Message → Send a group SMS | Sends one group text (SMS/MMS) from one of your DIDs to several recipients, as a single group conversation in Teams. |
| Message → Relay an inbound SMS | Delivers an inbound SMS/MMS that a customer sent to one of your DIDs into the matching Teams conversation. |
| Delivery Status → Update a delivery status | Reports what the carrier said happened to a message you sent (MT_DELIVERED / MT_REJECTED), so the Teams conversation shows the real delivery status. |
| On outbound SMS from ConnecttoTeams (the ConnecttoTeams Trigger) | Starts a workflow whenever ConnecttoTeams hands it an outgoing SMS to deliver (generic carrier), e.g. to send it through your own SMS provider. Acknowledges each message immediately with a carrier_msg_id and outputs a fixed set of fields. |
The four actions are operations of one node, ConnecttoTeams (pick them
with its Resource and Operation fields); the trigger is a separate
node. This README calls the actions Send SMS, Send Group SMS, Relay
Inbound SMS and Update Delivery Status.
Search for "ConnecttoTeams" or "SMS" in the node panel to find
them. For a step-by-step guide to each action, with screenshots, see the
node guide.
Upgrading from the separate nodes? Earlier builds had four action nodes
(Send Outbound SMS, Send Outbound Group SMS, SMS To ConnecttoTeams, Delivery
Status Update). They were replaced by the ConnecttoTeams node's actions and
removed, so workflows that use them show "unknown node" and must be rebuilt
with the matching action; the fields are the same, except Send Group SMS's
Destination(s) is now Recipients. The trigger was renamed too (from
"SMS From ConnecttoTeams Trigger", internal typeconnecttoTeamsSmsTrigger,
to "ConnecttoTeams Trigger",connecttoTeamsTrigger), so saved trigger
workflows also show "unknown node". Changing the node'stypein the saved
workflow JSON fixes them and keeps their webhook URL; re-adding the trigger
instead gives it a new URL, which the generic carrier must then be pointed at.
n8n is a fair-code licensed workflow automation platform.
Installation
Operations
Authentication
Compatibility
Usage
Support
Resources
Version history
Installation
This package is only installable on a self-hosted n8n instance — n8n Cloud
only allows community nodes that have gone through n8n's own verification
program, which this package has not (see Compatibility).
New to community nodes? See n8n's
community nodes documentation
for the platform-level requirements n8n imposes on any community node
before it'll install — self-hosted only, the Owner/Admin role requirement,
and the risk acknowledgment. The steps below are specific to this package.
Option A — from the Manager UI (recommended)
- Go to Settings → Community Nodes.
- Select Install a community node.
- Enter the package name:
n8n-nodes-connecttoteams-connector. - Check "I understand the risks of installing unverified code from a
public source" — n8n shows this for every community node that isn't
independently verified — and select Install. - Wait for the install to finish; n8n restarts its internal node registry
automatically, no server restart needed.
Docker note: in most Docker deployments, packages installed this way
live in the container's writable layer. Unless~/.n8n(or whereverN8N_USER_FOLDERpoints) is on a persistent volume, a container
recreation (not just a restart) can wipe the installed package — you'd
need to reinstall it. If you manage n8n via a custom Dockerfile ordocker-compose.yml, installing at build/deploy time (Option B) is more
durable.
Option B — pinned at deploy time (Docker/Kubernetes)
For deployments where you build n8n's image yourself, install the package
into the image so it's present on every container start, without relying on
the Manager UI or a persistent volume:
n8n loads community packages from ~/.n8n/nodes (not from globalnode_modules), and the n8nio/n8n image runs as the node user, so a
global npm install -g fails with EACCES and wouldn't be loaded anyway.
Install into the nodes folder instead:
FROM n8nio/n8n:latest
# Replace <version> with a published version — avoid a bare install with no
# version, so a new release can't change behavior under you.
USER root
RUN mkdir -p /home/node/.n8n/nodes \
&& cd /home/node/.n8n/nodes \
&& npm install n8n-nodes-connecttoteams-connector@<version> \
&& chown -R node:node /home/node/.n8n
USER node
Verify against your n8n version — this snippet hasn't been tested
against every n8n image. Caution: if/home/node/.n8nis mounted as a
volume (the usual way to persist n8n data), the volume shadows the image's
copy and the package won't be there. In that case install via
Settings → Community Nodes (Option A) or into the volume itself instead.
Use the latest version shown on the package's npm page (for example0.1.1).
Community package installs are enabled by default on recent n8n versions;
if yours has it disabled, set N8N_COMMUNITY_PACKAGES_ENABLED=true in the
environment first.
Verifying the install
Open the node panel (the + button on the canvas) and search for
"ConnecttoTeams" — you should see ConnecttoTeams. Open it: it lists the
four actions (Send an SMS, Send a group SMS, Relay an inbound SMS, Update a
delivery status) and the ConnecttoTeams Trigger. If nothing shows up, check
Settings → Community Nodes to confirm the package installed without
error, and see n8n's
community node troubleshooting guide
if it didn't.
Once installed, set up the ConnecttoTeams Enterprise API credential before
using any ConnecttoTeams action, and the ConnecttoTeams Gateway API credential before
using the trigger — see Authentication below.
Operations
ConnecttoTeams Trigger (receive a message)
Prerequisite: a phone number provisioned through ConnecttoTeams on the
generic carrier. In that carrier's setup, set its Callback URL to
this node's production webhook URL (shown in the node once you activate the
workflow) — otherwise the carrier has nowhere to deliver incoming messages
and this trigger never fires. Also set the generic carrier's api_secret (the
generic carrier's shared secret, set by ConnecttoTeams) to the same value as the
trigger's ConnecttoTeams Gateway API Auth Key — otherwise every request is
rejected with 401.
Registers a POST webhook at the Webhook Path you configure (defaultconnecttoteams-incoming). The path must be unique across your active
workflows — give each trigger its own path (e.g. one per generic carrier or
DID); two active workflows on the same path conflict. Both sides of this node
are a fixed contract.
The incoming message is acknowledged immediately, before the workflow
runs — the carrier never waits for the rest of the workflow to finish.
Output — always these fields, whatever the caller posts:
| Output field | Type | From | If missing |
|---|---|---|---|
source |
string | source |
'' |
destination |
string | recipients, comma-joined |
'' |
recipients |
string[] |
destination |
[] |
is_group |
boolean | destination sent as an array |
false |
text |
string | text |
'' |
media_url |
string[] |
media_url |
[] |
carrier_msg_id |
string | generated | always set |
media_url entries can arrive as plain URLs or as { url, fileName }
objects — the latter is how media already hosted by ConnecttoTeams (e.g. an
image sent from Teams) is forwarded. Either way the output is a list of URL
strings, which can be mapped straight into a send node's Media URLs.
Phone numbers are emitted in E.164 with a leading + (e.g.+15553334444): the dispatcher sends destination as bare digits (source
already has its +), so bare-digit values get + prepended; anything else is
passed through trimmed.
recipients is every number the message is to be delivered to — one entry
for a 1:1 message; for a group text, every participant except the sender (the
dispatcher sends destination as an array for groups, which also setsis_group to true). destination is the same list comma-joined, so for a
1:1 message it is a single number and 1:1 workflows can keep mapping it as a
string.
carrier_msg_id is the same id sent in the acknowledgement, so the workflow can
correlate its own work with what the dispatcher recorded.
Because the shape is fixed, you can map $json.source, $json.destination,$json.recipients, $json.is_group, $json.text, $json.media_url and$json.carrier_msg_id in later nodes
before the trigger has ever run. Every request must carry Authorization: Bearer <auth key> matching
the trigger's ConnecttoTeams Gateway API credential (see
Authentication); anything else is rejected with 401 and
the workflow does not start.
ConnecttoTeams → Relay Inbound SMS (relay an inbound message)
Sends one request per input item to the SMS Responder's fixed inbound
endpoint. The request body is assembled from these fields (empty fields are
omitted):
| Field | Body key | Notes |
|---|---|---|
| (credential) | — | ConnecttoTeams Enterprise API credential's Access Token |
| Source | source |
Sender ("from") — required |
| Destination | destination |
Recipient ("to") — required |
| Message | text |
Message body |
| Message ID | message_id |
Optional id; stored server-side as carrier_msg_id |
| Media URLs | media_url |
List of media links (flattened array) |
| Group Recipients | group_recipients |
Optional; the other participants in a group conversation, any number format (flattened array) |
| — | timestamp |
Set automatically (ISO 8601) |
Leave Group Recipients empty for a normal 1:1 relay. Set it to route the
message into a group Teams conversation instead of a 1:1 chat. List only the
other participants, in any common format (+14135550111, 4135550111,(413) 555-0111): the responder normalizes them, adds the receiving DID
(Destination) and the sender (Source) itself, so the message lands in
the same Teams group conversation as an outbound group text to those numbers.
A list that leaves only the DID is treated as a 1:1 message.
Acknowledging the carrier dispatcher is the trigger's job, not this node's, so
this node can sit anywhere in the workflow.
This action supports Continue On Fail. The ConnecttoTeams node can be attached to an n8n AI Agent as a tool. The workflow
builder picks the action when attaching it, so an agent can only relay inbound
messages if a builder deliberately attaches this action.
Output on success:
{ "message": "Received JSON message", "content": "RECEIVED" }
ConnecttoTeams → Send SMS (send a message)
Prerequisite: the Source number must be properly configured in
the ConnecttoTeams portal before you can send with it.
Sends one request per input item to the SMS Responder's fixed outbound
endpoint. The request body is assembled from these fields (empty fields are
omitted):
| Field | Body key | Notes |
|---|---|---|
| (credential) | — | ConnecttoTeams Enterprise API credential's Access Token |
| Source | source |
Sender ("from") — required |
| Destination | destination |
Exactly one recipient — required; a list separated by commas, semicolons or new lines is rejected (spaces are not separators, so (413) 414-4414 is one number) |
| Message | message |
Message body |
| Media URLs | media |
Publicly reachable image URLs, separated by commas or new lines, or an array from an expression (MMS) |
Numeric values from an expression (e.g. a phone number stored as a number in
Google Sheets) are accepted. The SMS Responder resolves the carrier from the
source number server-side; there are no carrier fields on the node. For
more than one recipient, use ConnecttoTeams → Send Group SMS below
instead. Both send actions support Continue On Fail and can be used as
tools by the n8n AI Agent.
Output on success — the stored message record (a subset shown; numbers
come back as E.164 digits without the +):
{
"smsr_id": 482913,
"to": "15559876543",
"from": "15551230000",
"message": "Your appointment is confirmed for 3pm.",
"action_type": "SMS",
"direction": "outbound",
"status": 200,
"delivery_status": "SENT",
"carrier_msg_id": "SM2f1c0e9a7b4d4a11b3c2d1e0f9a8b7c6",
"created_at": "2026-10-09T15:04:05.000Z",
"type": "broadcast_sms",
"errors": null
}
The full record also has group_name, group_recipients and images.carrier_msg_id is the carrier's id for the message — map it into
ConnecttoTeams → Update Delivery Status's Message ID when the carrier
later reports delivery. Its format depends on the carrier.
ConnecttoTeams → Send Group SMS (send a group message)
Prerequisite: same as Send SMS — the Source number must be
properly configured in the ConnecttoTeams portal.
Sends one request per input item to the same fixed outbound endpoint as Send
SMS, but as a group message (msg_type: group_text) rather than a
broadcast:
| Field | Body key | Notes |
|---|---|---|
| (credential) | — | ConnecttoTeams Enterprise API credential's Access Token |
| Source | source |
Sender ("from") — required |
| Recipients | destination |
Phone numbers in the group — required, at least one; a row may also hold several numbers (commas, semicolons or new lines) or an array from an expression |
| Message | message |
Message body |
| Group Name | group_name |
Required — the group conversation's name in Teams; each send sets it, replacing a different stored name |
| Media URLs | media |
Publicly reachable image URLs, separated by commas or new lines, or an array from an expression (MMS) |
The responder adds the source number to the group automatically — list only
the other participants under Recipients (Add Recipient adds a row).
Output on success has the same fields as Send SMS, with"type": "group_text", "action_type": "MMS", and group_name /group_recipients (every participant, including your DID) filled in.
ConnecttoTeams → Update Delivery Status (report what happened to a sent message)
Purpose. Sending a message through Send SMS / Send Group
SMS tells you it reached the carrier — it doesn't tell you whether the carrier
actually delivered it to the handset. If your carrier reports delivery
asynchronously (its own webhook, a polling job, a status feed, …), this node
is how you feed that event back into the responder so its records — and
anything built on them (delivery ticks in the Teams UI, delivery-rate
reporting, alerting on failures) — reflect reality instead of stopping at
"sent to carrier." It posts to the same endpoint Relay Inbound SMS uses;
the responder tells the two apart purely by the Delivery Status you send.
Use it to, for example: close the loop on a message that silently never
arrived (report MT_REJECTED, rather than leaving it ambiguous forever); build a
per-carrier or per-DID delivery-rate report from real receipts; or trigger an
alert/retry the moment a carrier reports a failure, instead of a customer
finding out first.
| Field | Body key | Notes |
|---|---|---|
| (credential) | — | ConnecttoTeams Enterprise API credential's Access Token |
| Source | source |
Sender of the original message (your DID) — required; the credential is verified against this number |
| Destination | destination |
Recipient of the original message — required |
| Message ID | message_id |
Required — the carrier_msg_id returned by Send SMS / Send Group SMS for the original message (for the generic carrier, the id the ConnecttoTeams Trigger acknowledged with); it must have been sent from Source — no match = 404 error |
| Delivery Status | status |
Dropdown: Delivered (MT_DELIVERED) / Rejected (MT_REJECTED) — any other value is rejected by the responder |
There's no Message or Media URLs field here — a delivery report doesn't carry
message content, only a status update against an id.
This action supports Continue On Fail. The ConnecttoTeams node can be attached to an n8n AI Agent as a tool. The workflow
builder picks the action when attaching it, so an agent can only report delivery
status if a builder deliberately attaches this action; receipts should come from
the carrier.
Output on success:
{ "message": "Received JSON message", "content": "MT_DELIVERED" }
Errors and Continue On Fail (all actions)
When the SMS Responder rejects a request, the node error shows the
responder's own message and the HTTP status — for example:
| HTTP | Example message |
|---|---|
400 |
Missing or invalid destination phonenumber |
400 |
SMS gateway rejected the credentials for … (HTTP 401): … |
401 |
Unauthorized request (wrong token for the DID) |
404 |
No message with message_id "x" sent from 15551230000 (Update Delivery Status) |
With Continue On Fail on, a failed item is output instead of stopping the
workflow:
{
"error": "No message with message_id \"x\" sent from 15551230000",
"http_code": 404,
"response": { "errors": "No message with message_id \"x\" sent from 15551230000" }
}
http_code and response are only present when the responder answered. A
network error (no response at all) gives just { "error": "<n8n's message>" },
and so do the node's own checks (e.g. more than one Destination on Send
SMS, or a missing Access Token).
Authentication
All four actions of the ConnecttoTeams node (Send SMS, Send Group SMS,
Relay Inbound SMS and Update Delivery Status) require a ConnecttoTeams Enterprise API
credential — a single, required Access Token field: the token ConnecttoTeams
issued for that DID, found in the ConnecttoTeams portal. If you are an enterprise
admin, this can be requested from your reseller. If the Access Token is empty
for an item (including an expression that resolves to nothing), the node
stops with "The ConnecttoTeams Enterprise API credential has no Access Token
for this item." and sends nothing. The credential also works with n8n's own
HTTP Request node (it adds the same Authorization: Bearer header).
The ConnecttoTeams Trigger requires a separate ConnecttoTeams
Gateway API credential — a single Auth Key field. Set it to theapi_secret (the generic carrier's shared secret, set by ConnecttoTeams) of the
generic carrier whose URL points at this trigger's webhook:
the SMS Responder sends that secret as Authorization: Bearer <api_secret> on
every request, and the trigger rejects anything that doesn't match with 401.
The responder checks the Access Token against the auth key on file for the
node's DID — Source for Send SMS, Send Group SMS and
Update Delivery Status; Destination for Relay Inbound SMS. That number
can be typed in any common format (+14134144414, 14134144414,4134144414, (413) 414-4414); it is normalized to E.164 before the lookup.
Whitespace around the Access Token is trimmed. The token travels asAuthorization: Bearer <token> (the nodes always send it that way); a raw
token without the Bearer scheme is rejected with 401.
The Access Token field supports expressions. The responder looks up the auth
key per phone number, not per enterprise, so if one workflow sends on behalf
of several DIDs, set the Access Token to an expression (e.g.={{ $json.token }}) — it's resolved against each input item, same as any
other per-item node field.
Compatibility
- Built and tested against n8n 2.x (
n8n-workflow2.12, n8n nodes API
version 1). Older n8n versions aren't tested. - Requires an n8n instance that supports community nodes.
- Self-hosted only. This package has not gone through n8n's community
node verification program, so n8n Cloud will not allow installing it —
Cloud only permits verified community nodes.
Usage
Send messages from a data source
- Add a source node (e.g. Google Sheets → Get Rows).
- Add ConnecttoTeams → Send an SMS and connect it.
- Map Source, Destination, and Message from the incoming
items (the send endpoint is fixed — nothing to configure there). - Select (or create) a ConnecttoTeams Enterprise API credential with the
responder's Access Token.
Receive messages
- Add the trigger: in the node panel open ConnecttoTeams and choose
On outbound SMS from ConnecttoTeams. - Select (or create) a ConnecttoTeams Gateway API credential whose Auth
Key matches the generic carrier'sapi_secret. - Set a Webhook Path and activate the workflow.
- Point the generic carrier's Callback URL at the node's production
webhook URL. It is acknowledged with{ "carrier_msg_id": "<uuid>" }on
arrival. - Map
$json.source/$json.destination/$json.text/$json.media_urlin the nodes that follow — the shape is fixed, so this works
before the trigger has ever fired.
New to n8n? See the Try it out guide.
Support
Found a bug, or something not working as documented? Email
support@connecttoteams.com with:
- The package version (
n8n-nodes-connecttoteams-connectorversion shown in
Settings → Community Nodes). - Which node (ConnecttoTeams Trigger / Relay Inbound SMS / ConnecttoTeams → Send SMS / ConnecttoTeams → Send Group SMS / ConnecttoTeams → Update Delivery Status).
- What you expected vs. what happened, and any relevant error output.
Found a security vulnerability instead? Report it privately to
support@connecttoteams.com rather than opening a public issue.
Resources
Version history
- 0.1.1 (2026-11-04) — first version published to npm. Same features
as 0.1.0, with the package marked public so npm accepts it. - 0.1.0 (2026-11-03) — first public release (tagged, never published to
npm). See CHANGELOG.md for details.