Skaffa lokala, nationella och internationella nummer direkt på nätet.
+46 208 814 02 Kundvagn: 0 Sweden flagSweden
🤖 AI-redo IVR

IVR toolkit

Bygg helt anpassade samtalsflöden och automatisera varje steg i dina kundinteraktioner med vår kraftfulla IVR-verktygslåda.

Använd enkla kommandon för att spela upp ljud, samla in siffror, koppla uppringare, utlösa logik, strömma ljud till AI-system och mer - allt inuti din befintliga telefoniuppsättning.

  • Integrera AI, automation eller anpassad back-end-logik
  • Bygg kompletta IVR-flöden utan extra hårdvara
  • Kontrollera samtalsbeteende med precisa kommandon

Fördelar med funktionen IVR toolkit

Upptäck hur våra funktioner hjälper dig att arbeta smartare, spara tid och förbättra hur ditt företag kommunicerar.

🧩

Flexibel samtalsautomatisering

Definiera exakt hur varje samtal ska bete sig. Spela upp meddelanden, samla in input, dirigera uppringare eller kör villkorlig logik - allt från en tydlig, utvecklarvänlig verktygslåda.

⚙️

Designad för utvecklingsteam

Använd strukturerade åtgärder som passar naturligt in i din backend-logik. Varje åtgärd har förutsägbara resultat, felhantering och exempel för att hjälpa dig att bygga med förtroende.

🔧

Fungerar med din befintliga uppsättning

Ingen ny infrastruktur behövs. Använd ditt Callfactory-nummer och utöka helt enkelt din samtalslogik via API:et, dina skript eller interna automatiseringsverktyg.

IVR Åtgärdsverktygslåda

Klicka på en åtgärd för att se dess beskrivning, signatur och exempel.

Besvarar ett inkommande samtal. Måste anropas innan ljud spelas upp eller input samlas in på ett inkommande samtal.

Description

  • Markerar samtalet som besvarat på telefonisidan.
  • Krävs innan användning av åtgärder som Play, PromptDigit, GatherDigits, Dial, Record, etc., på inkommande samtal.

Throws

  • InvalidOperationException - om samtalet redan har besvarats.

Signature

void Answer();

Example

protected override async Task 
HandleCallAsync(CancellationToken ct)
{
    // Svara alltid först på inkommande samtal
    Answer();

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

Spelar upp en ljudfil för uppringaren eller en utgående kanal.

Description

  • Spelar upp en ljudfil (t.ex. .wav) som finns i serverns ljudkatalog.
  • Kan riktas till den inkommande uppringaren eller en specifik OutboundChannel.

Parameters

  • audioFile - Filnamn/sökväg relativ till IVR-ljudkatalogen.
  • channel - (valfritt) Utgående kanal att spela upp ljud till.
  • ct - Avbrytningstoken; avbryts när uppringaren eller kanalen kopplar ner.

Returns

  • PlayResult.Success - Ljud uppspelat helt.
  • PlayResult.Fail - Uppspelning misslyckades (t.ex. ogiltig fil).
  • PlayResult.Cancel - Operation avbruten (t.ex. uppringaren lade på).
  • PlayResult.Error - Oväntat fel under uppspelning.

Throws

  • OperationCanceledException - Om ct avbryts under uppspelning.
  • Andra transport/IO-undantag beroende på implementation.

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("Misslyckades att spela upp välkomstmeddelande (Resultat:
        {Result})", result); return;
    }

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

Spelar upp ett ljudmeddelande och samlar in en enda DTMF-siffra.

Description

  • Spelar upp ett menymeddelande (t.ex. ‘Tryck 1 för försäljning, 2 för support, 3 för att lämna ett meddelande’).
  • Väntar på en enda DTMF-siffra: 0-9, *, eller #.
  • Avsett för huvudmenyval.

Parameters

  • audioFile - Meddelandefil att spela upp.
  • timeoutSeconds - Hur länge man ska vänta på en siffra (standard 10).
  • ct - Avbrytningstoken; avbryts när uppringaren kopplar ner.

Returns

  • MenuResult.Success med Digit satt när en siffra tas emot.
  • MenuResult.Timeout när ingen siffra tas emot inom timeoutSeconds.
  • MenuResult.Cancel när operationen avbryts.

Throws

  • OperationCanceledException - Om ct avbryts (t.ex. uppringaren lägger på).

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

Spelar upp ett meddelande och samlar in flera DTMF-siffror (t.ex. kontonummer, PIN).

Description

  • Spelar upp ett meddelande som ber uppringaren att ange flera siffror.
  • Stannar när antingen:
    • maxDigits uppnås
    • En avslutsiffra (t.ex. #) trycks ner
    • Tidsgränsen löper ut

Parameters

  • audioFile – Meddelande att spela upp (t.ex. “Ange ditt kontonummer följt av #”).
  • maxDigits – Maximalt antal siffror att samla in innan stopp.
  • terminationDigits – Sträng av siffror som avslutar insamlingen när de anges.
  • timeoutSeconds – Maximal tid att vänta på inmatning.
  • ct – Avbrytningstoken.

Returns

  • Tuple (GatherResult Result, string? Digits):
  • GatherResult.Success och Digits satt när inmatning är insamlad.
  • GatherResult.Timeout när ingen inmatning tas emot.
  • GatherResult.Cancel när operationen avbryts.
  • GatherResult.Error vid oväntat fel.

Throws

  • OperationCanceledException - Om ct avbryts (uppringaren lägger på).

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

Ringer upp ett eller flera utgående telefonnummer och returnerar en OutboundChannel när det besvaras.

Description

  • Initierar ett utgående samtal till en enda destination eller till flera destinationer parallellt.
  • För flera destinationer vinner den första som svarar; alla andra avbryts.

Parameters

  • destination / destinations – Telefonnummer att ringa.
  • callerId – Nummer att visa som uppringar-ID.
  • ringTimeoutSeconds – Maximal tid att ringa innan man ger upp.
  • ct – Avbrytningstoken.

Returns

  • Enskild destination:
  • (DialerResult Result, OutboundChannel? Channel)
  • Flera destinationer:
  • (DialerResult Result, string? AnsweredDestination, OutboundChannel? Channel)
  • DialerResult kan vara: Init, Ringing, Answered, Busy, Rejected, NoAnswer, Failed, Cancel.

Throws

  • OperationCanceledException – Om operationen avbryts under uppringning.

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

Exempel (enskild destination)

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

Exempel (flera destinationer)

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("Ansluten till säljagent {Number}", answeredNumber);
        await Connect(channel, ct);
    }
    else
    {
        await Play("sales_unavailable.wav", ct);
        await HandleVoicemail(ct);
    }
}

Kopplar samman ljud mellan två kanaler.

Description

  • För inkommande flöden: kopplar den inkommande uppringaren till en utgående kanal.
  • För endast utgående scenarier: kopplar samman två utgående kanaler.
  • Blockerar tills en sida lägger på eller anslutningen avbryts på annat sätt.

Parameters

  • channel – Utgående kanal att ansluta till det inkommande samtalet.
  • primary, secondary – Två utgående kanaler att koppla samman.
  • ct – Avbrytningstoken.

Returns

  • ConnectResult.Success – Anslutning avslutad normalt (samtal avslutat).
  • ConnectResult.Error – Anslutning kunde inte upprättas eller misslyckades.

Throws

  • OperationCanceledException – Om ct avbryts medan ansluten.

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("Anslutning avslutad med resultat: {Result}", connectResult);
    }
    else
    {
        await Play("agent_unavailable.wav", ct);
    }

    await Hangup(ct);
}

Spelar in ljud från uppringaren eller en utgående kanal.

Description

  • Startar inspelning från antingen den inkommande uppringaren eller en specifik utgående kanal.
  • Slutar när:
    • timeLimitSeconds uppnås
    • En avslutsiffra trycks ner (om konfigurerat)
    • Uppringaren eller kanalen lägger på

Parameters

  • timeLimitSeconds – Maximal inspelningslängd.
  • fileName – Valfritt anpassat filnamn (automatiskt genererat om null).
  • terminationDigits – DTMF-siffror som stoppar inspelningen.
  • playBeep – Om ett pip ska spelas före inspelning.
  • channel – Valfri utgående kanal.
  • ct – Avbrytningstoken.

Returns

  • Tuple (RecordResult Result, string? FilePath):
  • RecordResult.Success med FilePath sparad.
  • RecordResult.Timeout, MaxDurationReached, TerminationDigit, Cancel, Error.

Throws

  • OperationCanceledException om avbruten.

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("Röstbrevlåda sparad på {Path}", filePath);
        await Play("thank_you_message_received.wav", ct);
    }
    else
    {
        Logger.LogWarning("Inspelning misslyckades: {Result}", recordResult);
        await Play("recording_failed.wav", ct);
    }

    await Hangup(ct);
}

Avvisar ett inkommande samtal med en SIP-orsakskod och avslutar samtalet.

Description

  • Används för samtalsfiltrering, blockering och beteende utanför kontorstid.
  • Returnerar en SIP-felkod till uppströmsoperatören.

Parameters

  • reason – RejectReason.Busy, .TemporarilyUnavailable, .Declined.
  • ct – Avbrytningstoken.

Returns

  • RejectResult.Success – Samtal avvisat.
  • RejectResult.AlreadyAnswered – Samtal redan besvarat.
  • RejectResult.Error – Misslyckades att avvisa.

Throws

  • OperationCanceledException om avbruten.

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

    // Normalt flöde
    Answer();
    await Play("welcome.wav", ct);
}

Avslutar det aktiva samtalet snyggt.

Description

  • Avslutar samtalet från IVR-sidan.

Returns

  • HangupResult.Success – Samtal avslutat framgångsrikt.
  • HangupResult.NotAnswered – Aldrig besvarat.
  • HangupResult.AlreadyDisconnected – Uppringaren lade på.
  • HangupResult.Error – Påläggning misslyckades.

Throws

  • OperationCanceledException om avbruten.

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("Påläggningsresultat: {Result}", result);
}

Pausar exekvering i ett givet antal sekunder.

Description

  • Väntar i durationSeconds medan samtalet hålls öppet.
  • Kan avbrytas av DTMF-inmatning beroende på implementation.

Parameters

  • durationSeconds – Varaktighet i sekunder.
  • ct – Avbrytningstoken.

Returns

  • PauseResult.Success – Paus slutförd normalt.
  • PauseResult.Interrupted – Uppringaren tryckte på en tangent under paus (om stöds).
  • PauseResult.Cancel – Operation avbruten.
  • PauseResult.Error – Paus misslyckades.

Throws

  • OperationCanceledException – Om ct avbryts.

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

Skickar en upptaget-signal till uppringaren och avslutar samtalet.

Description

  • Presenterar en standard upptaget-ton.
  • Används vanligtvis när alla agenter/linjer är upptagna.

Returns

  • BusyResult.Success – Upptaget-signal skickad och samtal avslutat.
  • BusyResult.Cancel – Operation avbruten.
  • BusyResult.Error – Misslyckades att skicka upptaget-signal eller avsluta samtalet.

Throws

  • OperationCanceledException – Om ct avbryts.

Signature

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

Example

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

    // Annars, fortsätt med normalt flöde
    Answer();
    await Play("welcome.wav", ct);
}

Startar strömning av samtalets liveljud till en extern slutpunkt (t.ex. AI eller STT-motor).

Description

  • Öppnar en mediaström i realtid från samtalet till angiven url (t.ex. WebSocket-slutpunkt).
  • Används vanligtvis för att skicka ljud till:
    • en AI-assistent,
    • en tal-till-text-motor,
    • en anpassad analys/övervakningstjänst.
  • Endast en aktiv ström per samtal rekommenderas.

Parameters

  • url – Mål-strömningsslutpunkt (t.ex. wss://ai.callfactory.nl/voice-stream).
  • options – Valfri strömningskonfiguration (riktning, metadata, namn).
  • ct – Avbrytningstoken. Om avbruten, rivs strömmen ner.

Throws

  • OperationCanceledException – Om ct avbryts under installation.
  • Anslutnings/transport-undantag beroende på implementation.

Signaturer

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

Parametrar

public class StreamOptions
{
    public string? Name { get; set; }                           //
Valfritt strömnamn
    public StreamDirection Direction { get; set; } =
        StreamDirection.Both;
    public Dictionary<string, string>? Metadata { get; set; }
}

public enum StreamDirection
{
    Inbound,   // Från uppringare till AI
    Outbound,  // Från agent/system till AI
    Both       // Båda
}

Returnerar

public enum StreamResult
{
    Started,        // Ström startad framgångsrikt
    Stopped,        // Ström stoppad framgångsrikt (för
StopStream)
    AlreadyStarted, // En ström är redan aktiv
    NotActive,      // Ingen aktiv ström (för StopStream)
    Error           // Misslyckades att starta/stoppa
}

Example

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

    // Starta strömning av uppringarens ljud till AI
    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("Misslyckades att starta AI-ström:
{Result}", streamResult);
        await Play("ai_unavailable.wav", ct);
        await Hangup(ct);
        return;
    }

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

    // Fortsätt IVR-logik medan strömning är aktiv...
    var (menuResult, digit) = await
PromptDigit("ai_menu.wav", 30, ct);

    if (menuResult == MenuResult.Success && digit == '0')
    {
        // Uppringaren vill ha en mänsklig agent
        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);
    }
}

Stoppar en aktiv ljudström som tidigare startades med StartStream.

Description

  • Stänger snyggt ner den aktiva mediaströmmen.
  • Lägger inte på samtalet - slutar bara skicka ljud.
  • Säkert att anropa även om ingen ström är aktiv (returnerar NotActive).

Parameters

  • ct – Avbrytningstoken.

Returns

  • StreamResult.Stopped – Ström stoppad framgångsrikt.
  • StreamResult.NotActive – Ingen aktiv ström hittad.
  • StreamResult.Error – Misslyckades att stoppa ström.

Throws

  • OperationCanceledException – Om ct avbryts.

Signatures

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

Example

private async Task TransferToHuman(CancellationToken ct)
{
    // Stoppa AI-strömning innan överföring till människa
    var stopResult = await StopStream(ct);
    Logger.LogInformation("StopStream resultat: {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);
    }
}

Varför det är viktigt

IVR-verktygslådan ger ditt team fullständig kontroll över samtalsflöden. Från enkla menyer till komplexa AI-drivna interaktioner - allt är möjligt med vårt åtgärdsbibliotek.

Dessa verktyg är särskilt användbara för team som bygger anpassade telefonilösningar, implementerar AI-integrationer eller utökar befintliga system med avancerad samtalslogik.

Denna funktion ingår kostnadsfritt med varje företagsnummer eller internationellt nummer.

Läs mer om andra funktioner

Hitta mer information om våra funktioner som kan förbättra ditt företags kommunikation.

DenyList routing

Blockera oönskade uppringare automatiskt genom att lägga till nummer i din DenyList. Håll linjerna öppna för de samtal som betyder mest.

Vanliga frågor om IVR toolkit

Få tydliga svar om IVR toolkit och hur det fungerar för ditt företag.

Du kan bygga flöden med hjälp av våra IVR-åtgärder i din instrumentpanel. Varje åtgärd inkluderar exempel, signaturer och förutsägbart beteende, så att du kan implementera logik utan att behöva ny telefonihårdvara.

Du kan skapa enkla flöden utan kodning, men verktygslådan är byggd för team som vill automatisera eller integrera logik. Utvecklare kan använda strukturerade åtgärder för att utlösa meddelanden, fånga siffror eller koppla uppringare programmeringsmässigt.

Ja. Du kan utlösa API-anrop, skicka data till din backend eller strömma ljud till AI- eller STT-tjänster. Verktygslådan passar naturligt in i din befintliga infrastruktur.

Absolut. Du behöver inte ändra din uppsättning. Alla IVR-åtgärder fungerar med dina befintliga Callfactory-nummer, routing och samtalsinställningar.

Ja. Du kan bygga och förhandsgranska dina flöden säkert. Verktygslådan låter dig simulera meddelanden, inmatningsinsamling och routingbeteende innan du aktiverar ändringar för riktiga uppringare.

Du bestämmer beteendet. Du kan spela upp ett meddelande igen, dirigera till röstbrevlåda, koppla till support eller avsluta samtalet. Varje IVR-åtgärd stöder anpassad felhantering.

Ja. Varje åtgärd inkluderar hantering av tidsgränser och valfri reservlogik. Du kan definiera vad som händer när ingen inmatning tas emot eller när en uppringare lagger på.

Ja. Verktygslådan designades för att kedja samman åtgärder. Du kan spela upp ljud, samla in siffror, köra logik, anropa ett API och överföra uppringare - allt i ett enda flöde.

Ja. Systemet är designat för tillförlitlighet och skalbarhet. Oavsett om du driver ett litet företag eller ett callcenter med hög volym, levererar alla åtgärder förutsägbar prestanda.

Om ditt team behöver vägledning kan vi hjälpa till att granska din flödesdesign, testa din konfiguration eller stödja mer avancerad routinglogik.

Nöjda Callfactory-kunder:

SignDirect logo
Bosch logo
Trigion logo
ANWB logo
UWV logo
Sogeti logo
Dille & Kamille logo
Nationale Ombudsman logo
KRO-NCRV logo
Swiss Sense logo