Alertes de leads en temps réel

Lorsqu'un lead se présente, il est important de pouvoir réagir rapidement. Avec Twilio, vous pouvez facilement configurer des notifications de leads en temps réel par SMS, par e-mail, par WhatsApp ou par message vocal pour ne jamais passer à côté d'une opportunité de vente.

Real estate agent receiving a lead alert SMS of a business opportunity for a new house bid.
Real estate agent receiving a lead alert SMS of a business opportunity for a new house bid.

Comment fonctionnent les alertes de leads avec Twilio

Pour simplifier la gestion des leads, il vous suffit d'intégrer les API Twilio à vos serveurs Web, à vos applications et à votre plateforme de données clients.

Étape 1
Configurer votre page d'accueil de génération de leads

Créez une page d'accueil avec un formulaire fonctionnel qui déclenche la génération automatique de leads sur le site Web et envoie des notifications en temps réel par e-mail, SMS ou WhatsApp.


Étape 2
Intégrer les données à votre CRM

Connectez les données des leads à votre plateforme de gestion de la relation client (CRM) pour capturer les leads, stocker les données et accéder aux informations de contact importantes.


Étape 3
Configurer les API Twilio

Configurez les API Twilio pour acheminer les leads de votre page de contact vers le numéro de téléphone ou l'adresse e-mail appropriés. Transmettez toutes sortes de données sur les leads : nom, numéro de téléphone, informations relatives à leurs demandes, etc.


Étape 4
Recevoir des alertes à l'arrivée de nouveaux leads

Envoyez à votre équipe un SMS, un message WhatsApp ou une notification par e-mail pour l'informer de l'arrivée de nouveaux leads, en y ajoutant toutes les informations dont ils ont besoin pour en assurer le suivi.


Étape 5
Assurer le suivi des leads

Les agents peuvent utiliser le meilleur canal de communication pour suivre leurs nouveaux leads.

Diagram of how lead alerts work with Twilio, integrating Twilio API with your CRM and setting it up with a functional form to send the lead alerts via email, SMS or WhatsApp.
Diagram of how lead alerts work with Twilio, integrating Twilio API with your CRM and setting it up with a functional form to send the lead alerts via email, SMS or WhatsApp.

Produits Twilio dédiés à la création d'alertes de leads

Créez des alertes de leads sur n'importe quel canal. Déployez votre solution en quelques heures.

  • Twilio Programmable Messaging logo
    SMS

    Envoyez des alertes de leads par SMS et MMS en y ajoutant des données personnalisées sur le lead.

  • Twilio WhatsApp Business API logo
    WhatsApp

    Facilitez l'engagement avec vos nouveaux leads par un échange de messages WhatsApp.

  • Envelope
    E-mail

    Envoyez des alertes de leads en temps réel à un ou plusieurs destinataires avec des informations détaillées sur la demande.

  • Twilio Programmable Voice logo
    Voice

    Envoyez des alertes de leads en automatisant les appels sortants si les appels téléphoniques sont retenus comme mode de communication préférentiels.

  • Twilio Task Router logo
    TaskRouter

    Acheminez intelligemment les leads vers l'agent ou le représentant commercial qui convient le mieux, en fonction de ses compétences, de sa localisation géographique et de sa disponibilité.

Maîtrisez les alertes de leads avec Twilio en quelques minutes

Créez dès maintenant un compte Twilio gratuit. Ne manquez plus jamais un lead sur le site Web : utilisez nos outils de développement complets pour créer une solution personnalisée prise en charge par les API de communication les plus performantes de Twilio.

from lead_alerts import app
from flask import flash, redirect, render_template, request
from twilio.base.exceptions import TwilioRestException


from .services.twilio_service import TwilioService

@app.route('/')
def index():
    house = {
                'title': '555 Sunnybrook Lane',
                'price': '$349,999',
                'description':
                    'You and your family will love this charming home. ' +
                    'Featuring granite appliances, stainless steel windows, and ' +
                    'high efficiency dual mud rooms, this joint is loaded to the max. ' +
                    'Motivated sellers have priced for a quick sale, act now!'
            }
    return render_template('index.html', house=house)

@app.route('/notifications', methods=['POST'])
def create():
    house_title = request.form["house_title"]
    name = request.form["name"]
    phone = request.form["phone"]
    message = request.form["message"]

    twilio_service = TwilioService()

    formatted_message = build_message(house_title, name, phone, message)
    try:
        twilio_service.send_message(formatted_message)
        flash('Thanks! An agent will be contacting you shortly', 'success')
    except TwilioRestException as e:
        print(e)
        flash('Oops! There was an error. Please try again.', 'danger')

    return redirect('/')

def build_message(house_title, name, phone, message):
    template = 'New lead received for {}. Call {} at {}. Message {}'
    return template.format(house_title, name, phone, message)
using System.Web.Mvc;
using LeadAlerts.Web.Domain;
using LeadAlerts.Web.ViewModels;
using Vereyon.Web;
using System.Threading.Tasks;

namespace LeadAlerts.Web.Controllers
{
    public class NotificationsController : Controller
    {
        private readonly INotificationService _notificationService;

        public NotificationsController() : this(new NotificationService()) { }

        public NotificationsController(INotificationService notificationService)
        {
            _notificationService = notificationService;
        }

        // POST: Notifications/Create
        [HttpPost]
        public async Task<ActionResult> Create(Lead lead)
        {
            var message = await _notificationService.SendAsync(FormatMessage(lead));

            if (message.ErrorCode.HasValue)
            {
                FlashMessage.Danger("Oops! There was an error. Please try again.");
            }
            else
            {
                FlashMessage.Confirmation("Thanks! An agent will be contacting you shortly.");
            }

            return RedirectToAction("Index", "Home");
        }

        private static string FormatMessage(Lead lead)
        {
            return $"New lead received for {lead.HouseTitle}. Call {lead.Name} at {lead.Phone}. Message: {lead.Message}";
        }
    }
}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use App\Http\Requests;
use App\Http\Controllers\Controller;

use Twilio\Rest\Client;

class NotificationsController extends Controller
{
    protected $client;

    public function __construct(Client $client)
    {
        $this->client = $client;
    }

    public function create(Request $request)
    {
        $houseTitle = $request->input('houseTitle');
        $name       = $request->input('name');
        $phone      = $request->input('phone');
        $message    = $request->input('message');

        $formattedMessage = $this->formatMessage($houseTitle, $name, $phone, $message);

        try {
            $this->sendMessage($formattedMessage);
            $request
                ->session()
                ->flash('success', 'Thanks! An agent will be contacting you shortly.');
        } catch (Exception $e) {
            echo $e->getMessage();
            $request
                ->session()
                ->flash('error', 'Oops! There was an error. Please try again.');
        }

        return redirect()->route('home');
    }

    private function sendMessage($message)
    {
        $twilioPhoneNumber = config('services.twilio')['twilioPhoneNumber'];
        $agentPhoneNumber = config('services.twilio')['agentPhoneNumber'];
        $this->client->messages->create(
            $agentPhoneNumber,
            array(
                'from' => $twilioPhoneNumber,
                'body' => $message
            )
        );
    }

    private function formatMessage($houseTitle, $name, $phone, $message)
    {
        return
            "New lead received for $houseTitle. " .
            "Call $name at $phone. " .
            "Message: $message";
    }
}
# frozen_string_literal: true

require 'message_sender'
class NotificationsController < ApplicationController
  def create
    MessageSender.send_message(message)
    redirect_to root_url,
      success: 'Thanks! An agent will be contacting you shortly.'
  rescue Twilio::REST::TwilioError => error
    p error.message
    redirect_to root_url,
      error: 'Oops! There was an error. Please try again.'
  end

  private

  def message
    "New lead received for #{params[:house_title]}. " \
    "Call #{params[:name]} at #{params[:phone]}. " \
    "Message: #{params[:message]}"
  end
end
package com.twilio.leadalerts;

import com.twilio.leadalerts.lib.MessageSender;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class NotificationsServlet extends HttpServlet {

    private final MessageSender messageSender;

    @SuppressWarnings("unused")
    public NotificationsServlet() {
        this(new MessageSender());
    }

    public NotificationsServlet(MessageSender messageSender) {
        this.messageSender = messageSender;
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
        String houseTitle = request.getParameter("houseTitle");
        String name = request.getParameter("name");
        String phone = request.getParameter("phone");
        String message = request.getParameter("message");

        String formattedMessage = formatMessage(houseTitle, name, phone, message);
        try {
            messageSender.send(formattedMessage);
            request.setAttribute("success", "Thanks! An agent will be contacting you shortly.");
        } catch (Exception e) {
            e.printStackTrace();
            request.setAttribute("error", "Oops! There was an error. Please try again.");
        }

        request.getRequestDispatcher("home.jsp").forward(request, response);
    }


    private String formatMessage(String houseTitle, String name, String phone, String message) {
        return String.format("New lead received for %s. Call %s at %s. Message: %s",
                houseTitle, name, phone, message);
    }
}
const Twilio = require('twilio');
const config = require('../config');
const Express = require('express');


// Some hard-coded information about a house
var house = {
    title: '555 Sunnybrook Lane',
    price: '$349,999',
    description: 'You and your family will love this charming home. '
        + 'Featuring granite appliances, stainless steel windows, and '
        + 'high efficiency dual mud rooms, this joint is loaded to the max. '
        + 'Motivated sellers have priced for a quick sale, act now!'
};

// Map routes to controller functions
module.exports = function () {
    // Create an authenticated Twilio API client
    var client = new Twilio(config.accountSid, config.authToken);
    const router = Express.Router();

    // Render landing page
    router.get('/', function(request, response) {
        response.render('index', house);
    });

    // Send lead notification
    router.post('/leads', function(request, response) {
        // Assemble a text message body
        var message = 'New lead received for ' + house.title + '. Call '
            + request.body.name + ' at ' + request.body.phone + '. Message: "'
            + request.body.message + '"';

        // Send lead notification to agent
        client.messages.create({
            to: config.agentNumber,
            from: config.twilioNumber,
            body: message
        })
        .then(() => {
          // Otherwise, respond with 200 OK
          response.status(200).send('Lead notification was successfully sent.');
        })
        .catch((err) => {
          console.error(err);
          response.status(500).send();
        })
    });

    return router;
};

Alertes de leads instantanées avec Python et Flask

Utilisez Twilio Programmable SMS pour envoyer un message chaque fois qu'un nouveau lead est détecté pour une application Python et Flask.

Créez une application de notification des leads sur la page d'accueil avec l'API Twilio SMS et PHP

Créez une page d'accueil contenant un formulaire PHP entièrement fonctionnel qui vous informe de l'arrivée d'un nouveau lead en vous envoyant une notification par e-mail et SMS pour plus de commodité.

Guide d'intégration de Programmable Messaging

Configurez Programmable Messaging API pour pouvoir envoyer des messages texte automatisés lorsque vous recevez un nouveau lead.

Vous préférez une expérience sans code ? Aucun problème.

Collaborez avec l'un de nos partenaires de confiance pour vous assister en matière de codage ou découvrir une solution préconstruite.

Work with Twilio Professional Services to set up global call tracking for your company
Work with Twilio Professional Services to set up global call tracking for your company

Pourquoi choisir Twilio pour les alertes de leads

Les API Twilio assurent une diffusion rapide et fiable des notifications de leads et s'intègrent de manière fluide à votre pile technologique.

Build lead alerts with Twilio to handle multichannel notifications, increase conversion rates, respond to leads from anywhere and intelligently escalate hot leads.
Build lead alerts with Twilio to handle multichannel notifications, increase conversion rates, respond to leads from anywhere and intelligently escalate hot leads.

Cas d'usage connexes


Explorez d'autres cas d'utilisation que vous pouvez construire avec Twilio

Marketing et promotions

Intégrez les e-mails, les SMS, les MMS, WhatsApp ou Voice à votre technologie marketing existante pour augmenter les conversions et la valeur vie des clients.

Vérification et identité utilisateur

Ajoutez une authentification à double facteur à vos flux d'intégration et de connexion pour sécuriser les comptes clients et empêcher la fraude.

Alertes et notifications

Informez, motivez et encouragez vos clients à agir grâce à des alertes et des notifications multicanaux.