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

# Send Transactional SMS Message

> This endpoint sends a Transactional SMS Message. Transactional SMS Messages are limited to 160 characters. Messages sent with more than 160 characters will be rejected with a 422 response and an error message stating that the content is too long.

## Request URL

```http theme={null}
POST https://app.tatango.com/api/v2/transactional_messages
```


## OpenAPI

````yaml POST /api/v2/transactional_messages
openapi: 3.1.0
info:
  title: Tatango Legacy v2 API
  description: Tatango legacy v2 API endpoints for existing integrations.
  version: 2.0.0
servers:
  - url: https://app.tatango.com
security:
  - basicAuth: []
paths:
  /api/v2/transactional_messages:
    post:
      tags:
        - Transactional Messages
      summary: Send Transactional SMS/MMS Message
      description: >-
        This endpoint sends a Transactional SMS or MMS Message. Transactional
        SMS Messages are limited to 160 characters. Transactional MMS Messages
        are limited to 5000 characters.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              properties:
                transactional_message:
                  type: object
                  properties:
                    number:
                      type: string
                      description: >-
                        Phone number (numbers only - no spaces, dashes or other
                        characters).
                    content:
                      type: string
                      description: Message content
                      maxLength: 5000
                    is_mms:
                      type: boolean
                      description: >-
                        Accepts true or false. If true message will be sent as
                        MMS. If false, message will be sent as SMS.
                    subject:
                      type: string
                      description: >-
                        The subject line of your message. The subject is bold
                        and sent above the content included in your request.
                        This is required if `is_mms` is true.
                    fallback_content:
                      type: string
                      description: >-
                        Fallback content is text only, and is sent in the case
                        that the handset is unable to receive MMS messages,
                        limited to 160 characters. This is required if `is_mms`
                        is true.
                      maxLength: 160
                    attachment_id:
                      type: integer
                      description: >-
                        The attachment_id is the id that references the media
                        attachment to include in an MMS message. This is
                        required if `is_mms` is true.
                    webhook_callback_url:
                      type: string
                      description: Webhook url (will send result of send to).
                  required:
                    - number
                    - content
                    - is_mms
      responses:
        '200':
          description: Message successfully sent
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SendTransactionalSMSResponse'
              example:
                status: Message successfully sent.
                transactional_message:
                  id: 1
                  number: '2835550430'
                  content: Message content required. Max-size 5000 if is_mms
                  status: pending
        '422':
          description: Unprocessable Entity - Content too long
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
              example:
                error: >-
                  Content is too long. Transactional SMS messages are limited to
                  160 characters, MMS messages are limited to 5000 characters.
      x-codeSamples:
        - lang: cURL
          label: cURL
          source: >-
            curl "https://app.tatango.com/api/v2/transactional_messages" -d
            '{"phone_number":"2141234567","content":"Hello from Tatango!"}' -X
            POST \
              -H "Accept: application/json" \
              -H "Content-Type: application/json" \
              -u emailaddress@mydomain.com:my_api_key \
              -H "Host: example.org" \
              -H "Cookie: "
        - lang: Ruby
          label: Ruby
          source: >-
            require 'net/http'

            require 'uri'

            require 'json'


            uri =
            URI.parse('https://app.tatango.com/api/v2/transactional_messages')

            http = Net::HTTP.new(uri.host, uri.port)

            http.use_ssl = true

            request = Net::HTTP::Post.new(uri.request_uri)

            request.basic_auth("emailaddress@mydomain.com", "my_api_key")

            request['Accept'] = 'application/json'

            request['Content-Type'] = 'application/json'

            request.body = {"phone_number" => "2141234567", "content" => "Hello
            from Tatango!"}.to_json

            response = http.request(request)
components:
  schemas:
    SendTransactionalSMSResponse:
      type: object
      properties:
        status:
          type: string
          example: Message successfully sent.
        transactional_message:
          type: object
          properties:
            id:
              type: integer
              example: 1
            number:
              type: string
              example: '2835550430'
            content:
              type: string
              example: Message content required. Max-size 5000 if is_mms
            status:
              type: string
              example: pending
  securitySchemes:
    basicAuth:
      type: http
      scheme: basic
      description: >-
        Tatango authenticates API requests by validating an API key passed via
        HTTP Basic Authentication. Use your login email as the username and your
        API key as the password.

````