Lead-Warnmeldungen in Echtzeit

Wenn ein Lead eintrifft, ist es wichtig, schnell zu reagieren. Mit Twilio können Sie über SMS, E-Mail, WhatsApp oder Voice Lead-Benachrichtigungen ganz einfach in Echtzeit erstellen. So verpassen Sie keine Verkaufschance mehr.

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.

So funktionieren Lead-Warnmeldungen bei Twilio

Integrieren Sie Twilio APIs in Ihren Webserver-Stack, Ihre Apps und Kundendatenplattform, um das Lead Management zu vereinfachen.

Schritt 1
Erstellen Sie Ihre Landing Page für die Lead-Generierung

Erstellen Sie eine Landing Page mit einem funktionalen Formular, das die automatisierte Generierung von Website Leads auslöst und Benachrichtigungen in Echtzeit per E-Mail, SMS oder WhatsApp versendet.


Schritt 2
Integrieren Sie sie in Ihr CRM

Verknüpfen Sie die Lead-Daten mit Ihrer Customer-Relationship-Management-Plattform (CRM) für die Lead-Erfassung, Speicherung und den Zugriff auf wichtige Kontaktinformationen.


Schritt 3
Einrichtung von Twilio-APIs

Richten Sie Twilio-APIs ein zur Verbindung von Leads aus Ihrer Kontaktseite mit der richtigen Telefonnummer oder E-Mail-Adresse. Übertragen Sie Lead-Daten wie zum Beispiel Name, Telefonnummer und Informationen zur Anfrage.


Schritt 4
Empfangen Sie Warnmeldungen, wenn neue Leads hereinkommen

Senden Sie neue Verkaufs-Leads per SMS, WhatsApp oder E-Mail-Benachrichtigung mit allen Informationen an Ihr Team, die es für eine Bearbeitung des Leads benötigt.


Schritt 5
Bearbeitung der Leads

Beschäftigte können ihre neuen Leads auf dem besten Kommunikationskanal bearbeiten.

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.

Twilio-Produkte zum Erstellen von Lead-Warnmeldungen

Bauen Sie Lead-Warnmeldungen in einen beliebigen Kanal ein. Implementieren Sie Ihre Lösung innerhalb weniger Stunden.

  • Twilio Programmable Messaging logo
    SMS

    Senden Sie Lead-Warnmeldungen per Text- und MMS-Nachrichten, die kundenspezifische Daten über den Lead enthalten.

  • Twilio WhatsApp Business API logo
    WhatsApp

    Empfangen und reagieren Sie auf neue Leads bequem per WhatsApp-Nachrichten.

  • Envelope
    E-Mail

    Senden Sie Lead-Warnmeldungen in Echtzeit an einen oder mehrere Empfänger mit detaillierten Informationen zu der Anfrage.

  • Twilio Programmable Voice logo
    Voice

    Übermitteln Sie Lead-Warnmeldungen über einen automatisierten ausgehenden Anruf, wenn Telefonanrufe gewünscht werden.

  • Twilio Task Router logo
    TaskRouter

    Leiten Sie Leads abhängig von den Fähigkeiten, dem Standort und der Verfügbarkeit an die richtigen Vertriebsmitarbeiter:innen auf intelligente Weise weiter.

Legen Sie mit Twilio Lead-Warnmeldungen in nur wenigen Minuten los

Registrieren Sie sich noch heute für ein kostenloses Konto bei Twilio. Nutzen Sie unsere umfangreichen Entwicklertools zur Erstellung einer kundenspezifischen Lösung, die von den besten Kommunikations-APIs von Twilio unterstützt wird. So verpassen Sie keinen Website Lead mehr.

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;
};

Sofortige Lead-Warnmeldungen mit Python und Flask

Nutzen Sie die Programmable SMS von Twilio zum Versenden einer Nachricht, wenn ein neuer Lead für eine Python- und Flask-Anwendung gefunden wird.

Erstellen Sie eine Landing Page App für die Lead-Benachrichtigung mit Twilio SMS, API und PHP

Entwickeln Sie eine Landing Page mit einem komplett funktionalen PHP-Formular, das Ihnen der Einfachheit halber per E-Mail und SMS eine Benachrichtigung mit dem Wortlaut „Sie haben einen neuen Lead“ sendet.

Leitfaden für Programmable Messaging Onboarding

Richten Sie die Programmable Messaging API ein, damit Sie automatisierte Textnachrichten übermitteln können, wenn Sie einen neuen Lead erhalten.

Keine Lust auf Programmieren? Kein Problem.

Arbeiten Sie mit einem unserer vertrauenswürdigen Partner zusammen, um Unterstützung beim Programmieren zu erhalten oder eine bereits fertige Lösung zu testen.

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

Warum Sie sich bei Lead-Warnmeldungen für Twilio entscheiden sollten

Die APIs von Twilio unterstützen eine schnelle und zuverlässige Zustellung von Lead-Benachrichtigungen und lassen sich nahtlos in Ihren Technologie-Stack integrieren.

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.

Passende Anwendungsfälle


Weitere Anwendungsfälle, die Sie mit Twilio verwirklichen können

Marketing und Werbeaktionen

Integrieren Sie E-Mail, SMS, MMS, WhatsApp und Voice in Ihren bestehenden Marketing-Technologie-Stack, um Ihre Konversionsraten und den Customer Lifetime Value zu steigern.

Nutzerüberprüfung und Identität

Fügen Sie Ihrem Onboarding und den Anmeldeprozessen eine Zwei-Faktor-Authentisierung hinzu, um die Sicherheit der Kundenkonten zu gewährleisten und Betrug zu verhindern.

Warnmeldungen und Benachrichtigungen

Nutzen Sie Multichannel-Warnmeldungen und -Benachrichtigungen, um Kund:innen zu informieren, einzubinden und zum Handeln zu bewegen.