R2F0ZS5pbyBBTUEgY29uIFRyYXZhbGEtQ3J5cHRvY3VycmVuY3kgRnJpZW5kbHkgVHJhdmVsIEJvb2tpbmc=

<p><img src="https://gimg2.gateimg.com/image/article/16782582971.png" alt=""><br><strong>Ora: 5 settembre 2022, 13:00 UTC</strong><br><strong><a href="https://www.gate.io" target="_blank">Gate.io</a> ha ospitato una sessione AMA (Ask-Me-Anything) con Shane Sibley, Head of Business Development e Jacob Pang, Community Lead di Travala nel <a href="https://t.me/gateio" rel="nofollow noopener noreferrer" target="_blank">Comunità di scambio Gate.io</a>.</strong><br><strong>Sito Ufficiale: <a href="https://www.travala.com/" rel="nofollow noopener noreferrer" target="_blank">https://www.travala.com/</a></strong><br><strong>Twitter: <a href="https://twitter.com/travalacom" rel="nofollow noopener noreferrer" target="_blank">https://twitter.com/travalacom</a></strong><br><strong>Segui Travala su <a href="https://twitter.com/travalacom" rel="nofollow noopener noreferrer" target="_blank">Twitter</a> e <a href="https://t.me/travala" rel="nofollow noopener noreferrer" target="_blank">Telegram</a></strong><br><strong>Ospiti</strong><img src="https://gimg2.gateimg.com/image/article/16782585332.jpg" alt=""><br><strong>Shane Sibley — Responsabile dello sviluppo aziendale</strong><img src="https://gimg2.gateimg.com/image/article/16782585443.png" alt=""><br><strong>Jacob Pang - Responsabile Sviluppo Aziendale</strong></p>
<h2 id="h2-QampA20da20Gateio953204"><a name="Q&amp;A da Gate.io" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q&amp;A da Gate.io</h2><h3 id="h3-Q120Cos20Travala20e20perch20le20persone20dovrebbero20usarlo373560"><a name="Q1: Cos’è Travala e perché le persone dovrebbero usarlo?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q1: Cos’è Travala e perché le persone dovrebbero usarlo?</h3><p><strong>Jacob</strong>: Questa è una grande domanda.</p>
<p>Travala.com è un campione nel settore dei viaggi e delle criptovalute, operando come la più grande agenzia di viaggi online con oltre 3 milioni di prodotti di viaggio e 90 partner di criptovalute.</p>
<p>Il nostro token, AVA, è disponibile per il trading su Gate e il token GT è disponibile per il processo di checkout sulla nostra piattaforma da quasi un anno.<br><img src="https://gimg2.gateimg.com/image/article/16782585624.png" alt=""><br>Con l’anniversario di Gate, abbiamo stretto una partnership in modo più integrato e ora puoi accedere direttamente agli alloggi dal tuo account con la loro piattaforma.</p>
<h3 id="h3-Q220Una20volta20che20le20persone20entrano20nella20piattaforma20e20scelgono20i20loro20biglietti20o20soggiorni20quali20opzioni20di20pagamento20possono20utilizzare26693"><a name="Q2: Una volta che le persone entrano nella piattaforma e scelgono i loro biglietti o soggiorni, quali opzioni di pagamento possono utilizzare?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q2: Una volta che le persone entrano nella piattaforma e scelgono i loro biglietti o soggiorni, quali opzioni di pagamento possono utilizzare?</h3><p><strong>Shane</strong> Attraverso la mini app stessa, un utente è in grado di utilizzare le criptovalute che sono detenute direttamente sulla piattaforma Gate nel proprio portafoglio di scambio.</p>
<p>Ci siamo associati per creare un’esperienza di check-out senza soluzione di continuità in modo che il viaggio sia stato automaticamente dedotto dal saldo all’interno del portafoglio e completamente senza gas.</p>
<p>Non è necessario creare un nuovo account, quando si viene indirizzati tramite l’app mini, l’account viene applicato automaticamente.</p>
<h3 id="h3-Q320Perch20il20settore20dei20viaggi20deve20passare20alla20decentralizzazione622014"><a name="Q3: Perché il settore dei viaggi deve passare alla decentralizzazione?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q3: Perché il settore dei viaggi deve passare alla decentralizzazione?</h3><p><strong>Shane</strong> Il modello di prenotazione di viaggi online è stato rivoluzionario oltre 20 anni fa, ma è obsoleto nella sua forma attuale. Il successo dei disruptor come Airbnb mostra che i consumatori sono pronti a migrare verso piattaforme che permettono agli utenti ma consentono anche un mercato bidirezionale.</p>
<p>C’è stata una spinta in quella direzione, ma quella è una conversazione per un altro momento.</p>
<h3 id="h3-Q420C20qualche20beneficio20per20gli20utenti20di20Gate20che20si20iscrivono20a20Travala930532"><a name="Q4: C’è qualche beneficio per gli utenti di Gate che si iscrivono a Travala?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q4: C’è qualche beneficio per gli utenti di Gate che si iscrivono a Travala?</h3><p><strong>Shane</strong>: Bene, per il nono anniversario di Gate e la partnership che abbiamo creato, volevamo dare agli utenti qualcosa per i loro viaggi. Quando attivi l’account Travala, ti vengono accreditati 25 dollari per un acquisto a tua scelta.</p>
<p>Sei riuscito ad usarlo alla tua prima prenotazione!?</p>
<h3 id="h3-Q520Quanto20credi20nel20futuro20delle20criptovalute20nellindustria20dei20viaggi499059"><a name="Q5: Quanto credi nel futuro delle criptovalute nell’industria dei viaggi?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Q5: Quanto credi nel futuro delle criptovalute nell’industria dei viaggi?</h3><p><strong>Jacob</strong> Crediamo che pagare per viaggi e altri servizi importanti con criptovalute diventerà la norma in futuro.</p>
<p>Ci stiamo posizionando come la destinazione principale per qualsiasi prenotazione legata ai viaggi con criptovalute.<br><img src="https://gimg2.gateimg.com/image/article/16782584425.png" alt=""><br>Continueremo anche a innovare con criptovalute e NFT per creare un futuro più luminoso per l’industria dei viaggi.</p>
<div class="blog-details-info"><br><div>Autore: <strong>Rio Fu.</strong>, Comunità Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. Sarà consentito il repostaggio dell'articolo a condizione che venga fatto riferimento a Gate.io. In tutti i casi, sarà intrapresa un'azione legale<p></p><br></div></div></div></div>