🤖 KI-bereites IVR

IVR-Toolkit

Erstellen Sie vollständig angepasste Anrufabläufe und automatisieren Sie jeden Schritt Ihrer Kundeninteraktionen mit unserem leistungsstarken IVR-Aktions-Toolkit.

Verwenden Sie einfache Befehle, um Audio abzuspielen, Ziffern zu erfassen, Anrufer zu verbinden, Logik auszulösen, Audio an KI-Systeme zu streamen und vieles mehr - alles innerhalb Ihres bestehenden Telefonie-Setups.

Integrieren Sie KI, Automatisierung oder benutzerdefinierte Backend-Logik
Erstellen Sie komplette IVR-Abläufe ohne zusätzliche Hardware
Steuern Sie das Anrufverhalten mit präzisen Befehlen

Vorteile der IVR-Toolkit-Funktion

Entdecken Sie, wie unsere Funktionen Ihnen helfen, intelligenter zu arbeiten, Zeit zu sparen und die Kommunikation Ihres Unternehmens zu verbessern.

🧩

Flexible Anrufautomatisierung

Definieren Sie genau, wie sich jeder Anruf verhalten soll. Spielen Sie Ansagen ab, erfassen Sie Eingaben, leiten Sie Anrufer weiter oder führen Sie bedingte Logik aus - alles aus einem klaren, entwicklerfreundlichen Toolkit.

⚙️

Entwickelt für Entwicklungsteams

Verwenden Sie strukturierte Aktionen, die sich natürlich in Ihre Backend-Logik einfügen. Jede Aktion hat vorhersehbare Ergebnisse, Fehlerbehandlung und Beispiele, die Ihnen helfen, mit Vertrauen zu bauen.

🔧

Funktioniert mit Ihrem bestehenden Setup

Keine neue Infrastruktur erforderlich. Verwenden Sie Ihre Callfactory-Nummer und erweitern Sie einfach Ihre Anruflogik über die API, Ihre Skripte oder interne Automatisierungstools.

Beantwortet einen eingehenden Anruf. Muss aufgerufen werden, bevor Audio abgespielt oder Eingaben bei einem eingehenden Anruf erfasst werden.

Description

Markiert den Anruf als beantwortet auf der Telefonieseite.
Erforderlich vor der Verwendung von Aktionen wie Play, PromptDigit, GatherDigits, Dial, Record usw. bei eingehenden Anrufen.

Throws

InvalidOperationException - wenn der Anruf bereits beantwortet wurde.

Signature

void Answer();

Example

protected override async Task 
HandleCallAsync(CancellationToken ct)
{
    // Immer zuerst bei eingehenden Anrufen antworten
    Answer();

    await Play("welcome.wav", ct);
}

Spielt eine Audiodatei für den Anrufer oder einen ausgehenden Kanal ab.

Description

Spielt eine Audiodatei (z. B. .wav) ab, die sich im Audioverzeichnis des Servers befindet.
Kann auf den eingehenden Anrufer oder einen bestimmten OutboundChannel abzielen.

Parameters

audioFile - Dateiname/-pfad relativ zum IVR-Audioverzeichnis.
channel - (optional) Ausgehender Kanal, auf dem Audio abgespielt werden soll.
ct - Cancellation Token; wird abgebrochen, wenn der Anrufer oder Kanal die Verbindung trennt.

Returns

PlayResult.Success - Audio vollständig abgespielt.
PlayResult.Fail - Wiedergabe fehlgeschlagen (z. B. ungültige Datei).
PlayResult.Cancel - Vorgang abgebrochen (z. B. Anrufer hat aufgelegt).
PlayResult.Error - Unerwarteter Fehler während der Wiedergabe.

Throws

OperationCanceledException - Wenn ct während der Wiedergabe abgebrochen wird.
Andere Transport-/IO-Ausnahmen abhängig von der Implementierung.

Signatures

Task<PlayResult> Play(
    string audioFile,
    CancellationToken ct = default);

Task<PlayResult> Play(
    string audioFile,
    OutboundChannel channel,
    CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    Answer();
    var result = await Play("welcome.wav", ct);

    if (result != PlayResult.Success)
    {
        Logger.LogWarning("Begrüßungsnachricht konnte nicht abgespielt werden (Ergebnis:
        {Result})", result); return;
    }

    await Play("next_prompt.wav", ct);
}

Spielt eine Audioansage ab und erfasst eine einzelne DTMF-Ziffer.

Description

Spielt eine Menüansage ab (z. B. ‘Drücken Sie 1 für Vertrieb, 2 für Support, 3 um eine Nachricht zu hinterlassen’).
Wartet auf eine einzelne DTMF-Ziffer: 0-9, * oder #.
Gedacht für Hauptmenü-Auswahlen.

Parameters

audioFile - Ansagedatei zum Abspielen.
timeoutSeconds - Wie lange auf eine Ziffer gewartet werden soll (Standard 10).
ct - Cancellation Token; abgebrochen, wenn der Anrufer die Verbindung trennt.

Returns

MenuResult.Success mit gesetzter Ziffer, wenn eine Ziffer empfangen wird.
MenuResult.Timeout, wenn innerhalb von timeoutSeconds keine Ziffer empfangen wird.
MenuResult.Cancel, wenn der Vorgang abgebrochen wird.

Throws

OperationCanceledException - Wenn ct abgebrochen wird (z. B. Anrufer legt auf).

Signatures

Task<(MenuResult Result, char? Digit)> PromptDigit(
    string audioFile,
    int timeoutSeconds = 10,
    CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    Answer();
    await Play("welcome.wav", ct);

    var (menuResult, digit) = await PromptDigit(
        "main_menu.wav",
        timeoutSeconds: 10,
        ct);

    if (menuResult == MenuResult.Success && digit.HasValue)
    {
        switch (digit.Value)
        {
            case '1':
                await HandleSales(ct);
                break;
            case '2':
                await HandleSupport(ct);
                break;
            default:
                await Play("invalid_option.wav", ct);
                await Hangup(ct);
                break;
        }
    }
    else if (menuResult == MenuResult.Timeout)
    {
        await Play("no_input_goodbye.wav", ct);
        await Hangup(ct);
    }
    else
    {
        await Play("system_error.wav", ct);
        await Hangup(ct);
    }
}

Spielt eine Ansage ab und erfasst mehrere DTMF-Ziffern (z. B. Kontonummer, PIN).

Description

Spielt eine Ansage ab, in der der Anrufer aufgefordert wird, mehrere Ziffern einzugeben.
Stoppt, wenn entweder:
- maxDigits erreicht ist
- Eine Beendigungsziffer (z. B. #) gedrückt wird
- Timeout abläuft

Parameters

audioFile – Ansage zum Abspielen (z. B. “Bitte geben Sie Ihre Kontonummer gefolgt von # ein”).
maxDigits – Maximale Ziffern, die erfasst werden sollen, bevor gestoppt wird.
terminationDigits – Zeichenfolge von Ziffern, die die Erfassung beenden, wenn sie eingegeben werden.
timeoutSeconds – Maximale Zeit, um auf Eingabe zu warten.
ct – Cancellation Token.

Returns

Tuple (GatherResult Result, string? Digits):
GatherResult.Success und Digits gesetzt, wenn Eingabe erfasst wurde.
GatherResult.Timeout, wenn keine Eingabe empfangen wurde.
GatherResult.Cancel, wenn der Vorgang abgebrochen wurde.
GatherResult.Error bei unerwartetem Fehler.

Throws

OperationCanceledException - Wenn ct abgebrochen wird (Anrufer legt auf).

Signatures

Task<(GatherResult Result, string? Digits)> GatherDigits(
    string audioFile,
    int maxDigits = 20,
    string terminationDigits = "#",
    int timeoutSeconds = 30,
    CancellationToken ct = default);

Example

protected override async Task 
HandleCallAsync(CancellationToken ct)
{
    Answer();
    await Play("welcome.wav", ct);

    var (result, digits) = await GatherDigits(
        "enter_account.wav",
        maxDigits: 10,
        terminationDigits: "#",
        timeoutSeconds: 30,
        ct);

    if (result == GatherResult.Success && !string.IsNullOrEmpty(digits))
    {
        await ProcessAccountNumber(digits, ct);
    }
    else if (result == GatherResult.Timeout)
    {
        await Play("no_input_goodbye.wav", ct);
        await Hangup(ct);
    }
    else
    {
        await Play("system_error.wav", ct);
        await Hangup(ct);
    }
}

Wählt eine oder mehrere ausgehende Telefonnummern und gibt einen OutboundChannel zurück, wenn beantwortet.

Description

Initiiert einen ausgehenden Anruf zu einem einzelnen Ziel oder zu mehreren Zielen parallel.
Bei mehreren Zielen gewinnt das erste, das antwortet; alle anderen werden abgebrochen.

Parameters

destination / destinations – Telefonnummer(n) zum Wählen.
callerId – Nummer, die als Anrufer-ID angezeigt werden soll.
ringTimeoutSeconds – Maximale Zeit zum Klingeln, bevor aufgegeben wird.
ct – Cancellation Token.

Returns

Einzelnes Ziel:
(DialerResult Result, OutboundChannel? Channel)
Mehrere Ziele:
(DialerResult Result, string? AnsweredDestination, OutboundChannel? Channel)
DialerResult kann sein: Init, Ringing, Answered, Busy, Rejected, NoAnswer, Failed, Cancel.

Throws

OperationCanceledException – Wenn der Vorgang während des Wählens abgebrochen wird.

Signatures

Task<(DialerResult Result, OutboundChannel? Channel)> Dial(
    string destination,
    string callerId,
    int ringTimeoutSeconds = 60,
    CancellationToken ct = default);

Task<(DialerResult Result, string? AnsweredDestination,
OutboundChannel? Channel)> Dial(
    string[] destinations,
    string callerId,
    int ringTimeoutSeconds = 40,
    CancellationToken ct = default);

Beispiel (einzelnes Ziel)

private async Task TransferToSupport(CancellationToken ct)
{
    var (dialResult, channel) = await Dial(
        destination: "18885554444",
        callerId: Context.Ani,
        ringTimeoutSeconds: 30,
        ct);

    if (dialResult == DialerResult.Answered && channel != null)
    {
        await Play("connecting_to_support.wav", ct);
        await Connect(channel, ct);
    }
    else
    {
        await Play("support_unavailable.wav", ct);
        await HandleVoicemail(ct);
    }
}

Beispiel (mehrere Ziele)

private async Task TransferToSalesHuntGroup(CancellationToken ct)
{
    var salesTeam = new[]
    {
        "18885551111",
        "18885552222",
        "18885553333"
    };

    var (result, answeredNumber, channel) = await Dial(
        destinations: salesTeam,
        callerId: Context.Ani,
        ringTimeoutSeconds: 40,
        ct);

    if (result == DialerResult.Answered && channel != null)
    {
        Logger.LogInformation("Verbunden mit Vertriebsmitarbeiter {Number}", answeredNumber);
        await Connect(channel, ct);
    }
    else
    {
        await Play("sales_unavailable.wav", ct);
        await HandleVoicemail(ct);
    }
}

Verbindet Audio zwischen zwei Kanälen.

Description

Für eingehende Abläufe: verbindet den eingehenden Anrufer mit einem ausgehenden Kanal.
Für reine Outbound-Szenarien: verbindet zwei ausgehende Kanäle miteinander.
Blockiert, bis eine Seite auflegt oder die Verbindung anderweitig beendet wird.

Parameters

channel – Ausgehender Kanal, der mit dem eingehenden Anruf verbunden werden soll.
primary, secondary – Zwei ausgehende Kanäle zum Verbinden.
ct – Cancellation Token.

Returns

ConnectResult.Success – Verbindung normal beendet (Anruf beendet).
ConnectResult.Error – Verbindung konnte nicht hergestellt werden oder fehlgeschlagen.

Throws

OperationCanceledException – Wenn ct abgebrochen wird, während verbunden.

Signatures

Task<ConnectResult> Connect(
    OutboundChannel channel,
    CancellationToken ct = default);

Task<ConnectResult> Connect(
    OutboundChannel primary,
    OutboundChannel secondary,
    CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    Answer();

    await Play("connecting_you_now.wav", ct);

    var (dialResult, channel) = await Dial(
        destination: "18885550000",
        callerId: Context.Ani,
        ringTimeoutSeconds: 30,
        ct);

    if (dialResult == DialerResult.Answered && channel != null)
    {
        var connectResult = await Connect(channel, ct);
        Logger.LogInformation("Verbindung beendet mit Ergebnis: {Result}", connectResult);
    }
    else
    {
        await Play("agent_unavailable.wav", ct);
    }

    await Hangup(ct);
}

Nimmt Audio vom Anrufer oder einem ausgehenden Kanal auf.

Description

Startet die Aufnahme entweder vom eingehenden Anrufer oder einem bestimmten ausgehenden Kanal.
Endet wenn:
- timeLimitSeconds erreicht ist
- Eine Beendigungsziffer gedrückt wird (falls konfiguriert)
- Anrufer oder Kanal auflegt

Parameters

timeLimitSeconds – Maximale Aufnahmedauer.
fileName – Optionaler benutzerdefinierter Dateiname (automatisch generiert wenn null).
terminationDigits – DTMF-Ziffern, die die Aufnahme stoppen.
playBeep – Ob ein Piepton vor der Aufnahme abgespielt werden soll.
channel – Optionaler ausgehender Kanal.
ct – Cancellation Token.

Returns

Tuple (RecordResult Result, string? FilePath):
RecordResult.Success mit FilePath gespeichert.
RecordResult.Timeout, MaxDurationReached, TerminationDigit, Cancel, Error.

Throws

OperationCanceledException wenn abgebrochen.

Signatures

Task<(RecordResult Result, string? FilePath)> Record(
    int timeLimitSeconds = 120,
    string? fileName = null,
    string? terminationDigits = null,
    bool playBeep = true,
    CancellationToken ct = default);

Task<(RecordResult Result, string? FilePath)> Record(
    OutboundChannel channel,
    int timeLimitSeconds = 120,
    string? fileName = null,
    string? terminationDigits = null,
    bool playBeep = true,
    CancellationToken ct = default);

Example

private async Task HandleVoicemail(CancellationToken ct)
{
    await Play("leave_message_after_beep.wav", ct);

    var (recordResult, filePath) = await Record(
        timeLimitSeconds: 180,
        fileName: null,
        terminationDigits: "#",
        playBeep: true,
        ct: ct);

    if (recordResult == RecordResult.Success && !string.IsNullOrEmpty(filePath))
    {
        Logger.LogInformation("Voicemail gespeichert unter {Path}", filePath);
        await Play("thank_you_message_received.wav", ct);
    }
    else
    {
        Logger.LogWarning("Aufnahme fehlgeschlagen: {Result}", recordResult);
        await Play("recording_failed.wav", ct);
    }

    await Hangup(ct);
}

Lehnt einen eingehenden Anruf mit einem SIP-Grundcode ab und beendet den Anruf.

Description

Verwendet für Anruf-Screening, Blockierung und Verhalten außerhalb der Geschäftszeiten.
Gibt einen SIP-Fehlercode an den vorgelagerten Anbieter zurück.

Parameters

reason – RejectReason.Busy, .TemporarilyUnavailable, .Declined.
ct – Cancellation Token.

Returns

RejectResult.Success – Anruf abgelehnt.
RejectResult.AlreadyAnswered – Anruf bereits beantwortet.
RejectResult.Error – Fehler beim Ablehnen.

Throws

OperationCanceledException wenn abgebrochen.

Signatures

Task<RejectResult> Reject(
    RejectReason reason = RejectReason.Busy,
    CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    if (IsBlockedNumber(Context.Ani))
    {
        await Reject(RejectReason.Declined, ct);
        return;
    }

    if (!IsWithinBusinessHours(DateTime.UtcNow))
    {
        await Reject(RejectReason.TemporarilyUnavailable, ct);
        return;
    }

    // Normaler Ablauf
    Answer();
    await Play("welcome.wav", ct);
}

Beendet den aktiven Anruf sauber.

Description

Beendet den Anruf von der IVR-Seite.

Returns

HangupResult.Success – Anruf erfolgreich beendet.
HangupResult.NotAnswered – Niemals beantwortet.
HangupResult.AlreadyDisconnected – Anrufer hat aufgelegt.
HangupResult.Error – Auflegen fehlgeschlagen.

Throws

OperationCanceledException wenn abgebrochen.

Signature

Task<HangupResult> Hangup(CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    Answer();

    await Play("goodbye.wav", ct);

    var result = await Hangup(ct);
    Logger.LogInformation("Hangup-Ergebnis: {Result}", result);
}

Pausiert die Ausführung für eine angegebene Anzahl von Sekunden.

Description

Wartet für durationSeconds, während der Anruf offen gehalten wird.
Kann durch DTMF-Eingabe unterbrochen werden, abhängig von der Implementierung.

Parameters

durationSeconds – Dauer in Sekunden.
ct – Cancellation Token.

Returns

PauseResult.Success – Pause normal beendet.
PauseResult.Interrupted – Anrufer hat während der Pause eine Taste gedrückt (falls unterstützt).
PauseResult.Cancel – Vorgang abgebrochen.
PauseResult.Error – Pause fehlgeschlagen.

Throws

OperationCanceledException – Wenn ct abgebrochen wird.

Signatures

Task<PauseResult> Pause(
    int durationSeconds,
    CancellationToken ct = default
);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    Answer();

    await Play("please_wait.wav", ct);

    var result = await Pause(3, ct);

    if (result == PauseResult.Interrupted)
    {
        await Play("you_pressed_a_key.wav", ct);
    }
    else
    {
        await Play("thank_you_for_waiting.wav", ct);
    }

    await Hangup(ct);
}

Sendet ein Besetztzeichen an den Anrufer und beendet den Anruf.

Description

Präsentiert einen Standard-Besetzton.
Häufig verwendet, wenn alle Agenten/Leitungen belegt sind.

Returns

BusyResult.Success – Besetztsignal gesendet und Anruf beendet.
BusyResult.Cancel – Vorgang abgebrochen.
BusyResult.Error – Fehler beim Senden des Besetztsignals oder Beenden des Anrufs.

Throws

OperationCanceledException – Wenn ct abgebrochen wird.

Signature

Task<BusyResult> Busy(CancellationToken ct = default);

Example

protected override async Task HandleCallAsync(CancellationToken ct)
{
    if (AllAgentsBusy())
    {
        var result = await Busy(ct);
        Logger.LogInformation("Besetzt-Ergebnis: {Result}", result);
        return;
    }

    // Andernfalls mit normalem Ablauf fortfahren
    Answer();
    await Play("welcome.wav", ct);
}

Startet das Streaming des Live-Audios des Anrufs an einen externen Endpunkt (z. B. KI oder STT-Engine).

Description

Öffnet einen Echtzeit-Medienstrom vom Anruf zur angegebenen URL (z. B. WebSocket-Endpunkt).
Typischerweise verwendet, um Audio zu senden an:
- einen KI-Assistenten,
- eine Speech-to-Text-Engine,
- einen benutzerdefinierten Analyse-/Überwachungsdienst.
Nur ein aktiver Stream pro Anruf wird empfohlen.

Parameters

url – Ziel-Streaming-Endpunkt (z. B. wss://ai.callfactory.nl/voice-stream).
options – Optionale Streaming-Konfiguration (Richtung, Metadaten, Name).
ct – Cancellation Token. Wenn abgebrochen, wird der Stream abgebaut.

Throws

OperationCanceledException – Wenn ct während der Einrichtung abgebrochen wird.
Verbindungs-/Transportausnahmen abhängig von der Implementierung.

Signaturen

Task<StreamResult> StartStream(
    string url,
    StreamOptions? options = null,
    CancellationToken ct = default
);

Parameter

public class StreamOptions
{
    public string? Name { get; set; }                           //
Optionaler Stream-Name
    public StreamDirection Direction { get; set; } =
        StreamDirection.Both;
    public Dictionary<string, string>? Metadata { get; set; }
}

public enum StreamDirection
{
    Inbound,   // Vom Anrufer zur KI
    Outbound,  // Vom Agenten/System zur KI
    Both       // Beide
}

Rückgabewerte

public enum StreamResult
{
    Started,        // Stream erfolgreich gestartet
    Stopped,        // Stream erfolgreich gestoppt (für StopStream)
    AlreadyStarted, // Ein Stream ist bereits aktiv
    NotActive,      // Kein aktiver Stream (für StopStream)
    Error           // Fehler beim Starten/Stoppen
}

Example

protected override async Task
HandleCallAsync(CancellationToken ct)
{
    Answer();

    // Sende Anrufer-Audio an KI
    var streamResult = await StartStream(
        url: "wss://ai.callfactory.nl/voice-stream",
        options: new StreamOptions
        {
            Name = "support-ai",
            Direction = StreamDirection.Inbound,
            Metadata = new Dictionary<string, string>
            {
                ["caller"] = Context.Ani,
                ["dnis"] = Context.Dnis
            }
        },
        ct
    );

    if (streamResult != StreamResult.Started)
    {
        Logger.LogWarning("Starten des KI-Streams fehlgeschlagen:
{Result}", streamResult);
        await Play("ai_unavailable.wav", ct);
        await Hangup(ct);
        return;
    }

    await Play("connected_to_ai.wav", ct);

    // Fahre mit IVR-Logik fort, während Streaming aktiv ist...
    var (menuResult, digit) = await
PromptDigit("ai_menu.wav", 30, ct);

    if (menuResult == MenuResult.Success && digit == '0')
    {
        // Anrufer möchte einen menschlichen Agenten
        await StopStream(ct);
        await Play("transferring_to_human_agent.wav", ct);
        await TransferToHuman(ct);
    }
    else
    {
        await Play("thank_you_goodbye.wav", ct);
        await StopStream(ct);
        await Hangup(ct);
    }
}

Stoppt einen aktiven Audiostream, der zuvor mit StartStream gestartet wurde.

Description

Fährt den aktiven Medienstrom sauber herunter.
Legt den Anruf nicht auf - stoppt nur das Senden von Audio.
Sicher aufzurufen, auch wenn kein Stream aktiv ist (gibt NotActive zurück).

Parameters

ct – Cancellation Token.

Returns

StreamResult.Stopped – Stream erfolgreich gestoppt.
StreamResult.NotActive – Kein aktiver Stream gefunden.
StreamResult.Error – Fehler beim Stoppen des Streams.

Throws

OperationCanceledException – Wenn ct abgebrochen wird.

Signatures

Task<StreamResult> StopStream(
    CancellationToken ct = default);

Example

private async Task TransferToHuman(CancellationToken ct)
{
    // Stoppe KI-Streaming vor der Weiterleitung an Menschen
    var stopResult = await StopStream(ct);
    Logger.LogInformation("StopStream-Ergebnis: {Result}",
stopResult);

    await Play("transferring_to_agent.wav", ct);

    var (dialResult, channel) = await Dial(
        destination: "18005550000",
        callerId: Context.Ani,
        ringTimeoutSeconds: 30,
        ct
    );

    if (dialResult == DialerResult.Answered && channel !=
null)
    {
        await Connect(channel, ct);
    }
    else
    {
        await Play("agent_unavailable.wav", ct);
        await Hangup(ct);
    }
}

Warum es wichtig ist

Das IVR-Toolkit gibt Ihrem Team die volle Kontrolle über Anrufabläufe. Von einfachen Menüs bis hin zu komplexen KI-gesteuerten Interaktionen - alles ist möglich mit unserer Aktionsbibliothek.

Diese Tools sind besonders nützlich für Teams, die benutzerdefinierte Telefonielösungen entwickeln, KI-Integrationen implementieren oder bestehende Systeme um fortschrittliche Anruflogik erweitern möchten.

Diese Funktion ist in jeder deutschen Rufnummer oder internationalen Nummer kostenlos enthalten.

DenyList-Routing

Blockieren Sie unerwünschte Anrufer automatisch, indem Sie Nummern Ihrer DenyList hinzufügen. Halten Sie Ihre Leitungen für die wichtigen Anrufe frei.

Sie können Abläufe mit unseren IVR-Aktionen in Ihrem Dashboard erstellen. Jede Aktion enthält Beispiele, Signaturen und vorhersehbares Verhalten, sodass Sie Logik implementieren können, ohne neue Telefonie-Hardware zu benötigen.

Sie können einfache Abläufe ohne Programmierung erstellen, aber das Toolkit ist für Teams konzipiert, die Logik automatisieren oder integrieren möchten. Entwickler können strukturierte Aktionen verwenden, um Ansagen auszulösen, Ziffern zu erfassen oder Anrufer programmgesteuert zu verbinden.

Ja. Sie können API-Aufrufe auslösen, Daten an Ihr Backend senden oder Audio an KI- oder STT-Dienste streamen. Das Toolkit fügt sich natürlich in Ihre bestehende Infrastruktur ein.

Absolut. Sie müssen Ihr Setup nicht ändern. Alle IVR-Aktionen funktionieren mit Ihren bestehenden Callfactory-Nummern, Routing- und Anrufeinstellungen.

Ja. Sie können Ihre Abläufe sicher erstellen und in einer Vorschau anzeigen. Mit dem Toolkit können Sie Ansagen, Eingabeerfassung und Routing-Verhalten simulieren, bevor Sie Änderungen für echte Anrufer aktivieren.

Sie entscheiden über das Verhalten. Sie können eine Ansage wiederholen, an Voicemail weiterleiten, mit dem Support verbinden oder den Anruf beenden. Jede IVR-Aktion unterstützt benutzerdefinierte Fehlerbehandlung.

Ja. Jede Aktion beinhaltet Timeout-Behandlung und optionale Fallback-Logik. Sie können definieren, was passiert, wenn keine Eingabe empfangen wird oder wenn ein Anrufer auflegt.

Ja. Das Toolkit wurde für die Verkettung von Aktionen konzipiert. Sie können Audio abspielen, Ziffern erfassen, Logik ausführen, eine API aufrufen und Anrufer weiterleiten - alles in einem einzigen Ablauf.

Ja. Das System ist auf Zuverlässigkeit und Skalierbarkeit ausgelegt. Egal, ob Sie ein kleines Unternehmen oder ein Callcenter mit hohem Volumen betreiben, alle Aktionen liefern vorhersehbare Leistung.

Wenn Ihr Team Unterstützung benötigt, können wir Ihnen helfen, Ihren Ablaufentwurf zu überprüfen, Ihre Konfiguration zu testen oder komplexere Routing-Logik zu unterstützen.