---
title: "Twilio પરથી કનેક્ટ કરો"
description: "CallSid સાથે SIP મારફતે Twilio કૉલ્સને ThunderPhone એજન્ટ સુધી મોકલો અને ટ્રાન્સફર સરનામામાં હેન્ડ-ઓફ સાથે તમારા referUrl દ્વારા તેમને પાછા લો."
---

તમારું TwiML કૉલના `CallSid` ને હેડરમાં રાખીને એજન્ટના SIP સરનામા પર ડાયલ કરે છે.
જ્યારે કૉલરને કોઈ વ્યક્તિની જરૂર હોય, ત્યારે એજન્ટ SIP `REFER` મોકલે છે, Twilio હેન્ડ-ઓફ સાથેનું ટ્રાન્સફર સરનામું તમારા `referUrl` હેન્ડલર સુધી પહોંચાડે છે, અને તમારું હેન્ડલર જે TwiML પરત કરે છે તે નક્કી કરે છે કે કૉલર ક્યાં જશે, જેમ કે Flex કતારમાં.

## શરૂ કરતા પહેલાં

- એક ThunderPhone એજન્ટ અને સંસ્થાની [API કી](/gu/guides/api-keys).
- Twilio Programmable Voice, અને TwiML તથા `referUrl` હેન્ડલર સર્વ કરવા માટેનું કોઈ સ્થાન: તમારું પોતાનું સર્વર, અથવા TwiML Bin અને Twilio Function. Flex વૈકલ્પિક છે.

## 1. SIP એન્ડપૉઇન્ટ બનાવો

Twilioનું `<Sip>` વપરાશકર્તાનામ અને પાસવર્ડ લે છે, તેથી માનક એન્ડપૉઇન્ટ વાપરો:

```bash
curl -X POST https://api.thunderphone.com/v1/sip-endpoints \
  -H "Authorization: Bearer sk_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"agent_id": 12, "name": "Twilio"}'
```

પ્રતિસાદમાંથી `password` તરત જ સંગ્રહિત કરો; તે એક જ વાર બતાવવામાં આવે છે. માત્ર Twilio તરફથી આવતા કૉલ સ્વીકારવા માટે, [સ્રોત IP સરનામાં પ્રતિબંધિત કરો](/gu/guides/sip-addresses) જુઓ.

## 2. સંદર્ભ સાથે કૉલ મોકલો

જે કૉલ એજન્ટને સોંપવો હોય તેના માટે આ TwiML પરત કરો:

```xml
<Response>
  <Dial answerOnBridge="true" referUrl="https://YOUR_SERVER/thunderphone-refer">
    <Sip username="tp409667538f83" password="YOUR_ENDPOINT_PASSWORD">sip:agent-12-jhxmginwjx@sip.thunderphone.com;transport=tls?X-Call-ID={{CallSid}}</Sip>
  </Dial>
</Response>
```

- `;transport=tls` મહત્વનું છે: અન્યથા જણાવવામાં ન આવે તો Twilio UDP વાપરે છે.
- `X-Call-ID` `CallSid` વહન કરે છે. Twilio પોતાનું કૉલ-ID હેડર દસ્તાવેજિત કરતું નથી, તેથી આ ઉમેરો: ThunderPhone તેને કૉલના `external_call_id` તરીકે સંગ્રહિત કરે છે. `{{CallSid}}` TwiML Binમાં કામ કરે છે; તમારા પોતાના સર્વરથી, આવતી વિનંતીનું `CallSid` લખો.
- આ જ રીતે વધુ સંદર્ભ ઉમેરો, જેમ કે `&amp;X-Account-Id=12345`. TwiMLમાં, `&` ને `&amp;` તરીકે લખો, કારણ કે સાદું `&` અમાન્ય XML છે. દરેક prompt સુધી ચલ તરીકે પહોંચે છે, અહીં `{{sip_x_account_id}}`. Twilio `x-` હેડર્સ અને `User-to-User` ને, ટકા-એન્કોડ કરેલા સ્વરૂપમાં, મંજૂરી આપે છે, જેમાં આખું URI 255 અક્ષરો કરતાં ઓછું અને હેડર્સ 1,024 કરતાં ઓછા હોય.
- `referUrl` Twilioને એજન્ટનું `REFER` સ્વીકારવા દે છે; તેના વિના ટ્રાન્સફર [ભૂલ 13802](https://www.twilio.com/docs/api/errors/13802) સાથે નિષ્ફળ જાય છે. `answerOnBridge="true"` નવા ગંતવ્યનો જવાબ ન આવે ત્યાં સુધી કૉલરને જોડાયેલ રાખે છે, જેથી નિષ્ફળ ટ્રાન્સફર માટે ફૉલબૅક થઈ શકે.

Studioનું **કૉલને જોડો** વિજેટ કસ્ટમ હેડર્સ અથવા `referUrl` દસ્તાવેજિત કરતું નથી, તેથી Studioમાંથી કૉલને આ TwiML પર સોંપો, ઉદાહરણ તરીકે **TwiML રીડાયરેક્ટ** વિજેટ વડે.

## 3. કૉલ પાછો મેળવો

એજન્ટ `REFER` દ્વારા ટ્રાન્સફર કરે છે, જેના ટ્રાન્સફર સરનામામાં હેન્ડ-ઓફ
ID અને ઇન્ટેન્ટ હોય છે. આ ટ્રાન્સફર નંબર ઉમેરો (જુઓ
[ટ્રાન્સફર નંબર ઉમેરો](/gu/guides/contact-centers/overview)
અને [ટ્રાન્સફર સરનામાની અંદરના હેડર્સ](/gu/guides/call-transfers)):

```json
{
  "name": "Twilio support",
  "number": "sip:support@acme.sip.twilio.com",
  "headers": {"X-Handoff-Id": "{{handoff_id}}", "X-Handoff-Intent": "{{handoff_intent}}"},
  "headers_in_uri": true
}
```

Twilio સમગ્ર સરનામું તમારા `referUrl` પર `ReferTransferTarget` તરીકે મોકલે છે, ઉદાહરણ તરીકે
`<sip:support@acme.sip.twilio.com?X-Handoff-Id=Zr3mY0b1Q9xWw2kPq4s7Tg&X-Handoff-Intent=billing_dispute>`.
તમારો હેન્ડલર તેમાંથી હેડર્સ વાંચે છે અને કૉલર આગળ ક્યાં જાય છે તે માટે TwiML
પરત કરે છે. સરનામાનો યુઝર ભાગ (`support`) તમે પસંદ કરી શકો છો, તેથી તમે દરેક
ગંતવ્ય માટે એક ટ્રાન્સફર નંબર ઉમેરી શકો છો અને તેના આધારે રૂટ કરી શકો છો.

આ Twilio ફંક્શન હેન્ડ-ઓફને ટાસ્ક એટ્રિબ્યુટ્સ તરીકે રાખીને કૉલરને Flexમાં કતારમાં
મૂકે છે અને હેન્ડ-ઓફ ID દ્વારા સારાંશ શોધે છે. લુકઅપ ફંક્શનમાં ચાલે છે કારણ કે
Studioનું HTTP રિક્વેસ્ટ વિજેટ `Authorization` હેડર મોકલી શકતું નથી:

```js
exports.handler = async (context, event, callback) => {
  const target = (event.ReferTransferTarget || "").replace(/^<|>$/g, "");
  const params = new URLSearchParams(target.split("?")[1] || "");
  const handoffId = params.get("X-Handoff-Id") || "";
  const attributes = { handoff_id: handoffId, intent: params.get("X-Handoff-Intent") || "" };

  if (handoffId) {
    const response = await fetch(
      "https://api.thunderphone.com/v1/calls/handoff?handoff_id=" + encodeURIComponent(handoffId),
      { headers: { Authorization: "Bearer " + context.THUNDERPHONE_API_KEY } }
    );
    if (response.ok) {
      const call = await response.json();
      attributes.summary = (call.handoff && call.handoff.summary) || "";
    }
  }

  const twiml = new Twilio.twiml.VoiceResponse();
  twiml.enqueue({ workflowSid: context.FLEX_WORKFLOW_SID }).task({}, JSON.stringify(attributes));
  callback(null, twiml);
};
```

API કીને ફંક્શનના એન્વાયરમેન્ટ વેરિએબલ્સમાં રાખો. અન્ય ફીલ્ડ્સ માટે
[હેન્ડ-ઓફ કરાયેલ કૉલ શોધો](/api-reference/calls#look-up-a-handed-off-call)
જુઓ.

## તેનું પરીક્ષણ કરો

ઉપરનું TwiML પરત કરતા Twilio નંબર પર કૉલ કરો, એજન્ટને કોઈ વ્યક્તિ સાથે વાત
કરાવવા કહો અને તપાસો કે તમારો `referUrl` હેન્ડલર બંને હેડર્સ સાથે
`ReferTransferTarget` મેળવે છે અને કૉલર કતાર સુધી પહોંચે છે. પછી
`GET /v1/calls/{call_id}` સાથે કૉલ ખોલો: `external_call_id` એ `CallSid` હોવું જોઈએ.

## મર્યાદાઓ

- Twilio `Refer-To` ને 256 અક્ષરો સુધી મર્યાદિત કરે છે. ThunderPhone સરનામું
  254 અક્ષરો સુધી રાખે છે અને જે હેડર બંધબેસતું નથી તેને છોડી દે છે, તેથી હેડર
  નામો અને મૂલ્યો ટૂંકા રાખો.
- Twilio `BYE` પર હેડર્સ વાંચવાનું દસ્તાવેજીકરણ કરતું નથી, તેથી પરત કૉલ હેન્ડ-ઓફને
  Twilio પર પાછો લઈ જઈ શકતો નથી. ઉપર મુજબ `REFER` નો ઉપયોગ કરો.
- Twilio `<Conference>` અથવા `<Queue>` દ્વારા કનેક્ટ કરેલા કૉલ પર `REFER` સ્વીકારતું
  નથી, તેથી ઉપર મુજબ એજન્ટને `<Dial><Sip>` વડે ડાયલ કરો.
