diff --git a/src/app/Http/Controllers/API/V4/OpenViduController.php b/src/app/Http/Controllers/API/V4/OpenViduController.php
index 96cc9e84..94aaa45c 100644
--- a/src/app/Http/Controllers/API/V4/OpenViduController.php
+++ b/src/app/Http/Controllers/API/V4/OpenViduController.php
@@ -1,120 +1,121 @@
 <?php
 
 namespace App\Http\Controllers\API\V4;
 
 use App\Http\Controllers\Controller;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\Validator;
 
 class OpenViduController extends Controller
 {
     /**
      * Join or create the room. Each room as one owner, and the room isn't open until the owner
      * joins (and effectively creates the session.
      */
     public function joinOrCreate($id)
     {
         $user = Auth::guard()->user();
 
-        $room = \App\OpenVidu\Room::where('session_id', $id);
+        $room = \App\OpenVidu\Room::where('session_id', $id)->first();
 
         // see if room exists, return session and token
         $client = new \GuzzleHttp\Client(
             [
+                'http_errors' => false, // No exceptions from Guzzle
                 'base_uri' => \config('openvidu.api_url'),
                 'verify' => \config('openvidu.api_verify_tls')
             ]
         );
 
         $response = $client->request(
             'GET',
             "sessions/{$id}",
             ['auth' => [\config('openvidu.api_username'), \config('openvidu.api_password')]]
         );
 
         $sessionExists = $response->getStatusCode() == 200;
 
         if (!$sessionExists) {
-            if ($room->user_id == $user) {
+            if ($room->user_id == $user->id) {
                 $json = [
                     'mediaMode' => 'ROUTED',
                     'recordingMode' => 'MANUAL',
                     'customSessionId' => $room->session_id
                 ];
 
                 $response = $client->request(
                     'POST',
                     'sessions',
                     [
                         'auth' => [
                             \config('openvidu.api_username'),
                             \config('openvidu.api_password')
                         ],
                         'json' => [
                             'mediaMode' => 'ROUTED',
                             'recordingMode' => 'MANUAL',
                             'customSessionId' => $room->session_id
                         ]
                     ]
                 );
 
-                if ($response->getResponseCode() !== 200) {
+                if ($response->getStatusCode() !== 200) {
                     return response()->json(['status' => 'error'], 422);
                 }
 
                 $response = $client->request(
                     'POST',
                     'tokens',
                     [
                         'auth' => [
                             \config('openvidu.api_username'),
                             \config('openvidu.api_password')
                         ],
                         'json' => [
                             'session' => $room->session_id,
                             'role' => 'MODERATOR'
                         ]
                     ]
                 );
 
                 $json = json_decode($response->getBody(), true);
 
                 return response()->json($json, 200);
             } else {
                 return response()->json(['status' => 'waiting'], 422);
             }
         }
 
         $response = $client->request(
             'POST',
             'tokens',
             [
                 'auth' => [
                     \config('openvidu.api_username'),
                     \config('openvidu.api_password')
                 ],
                 'json' => [
                     'session' => $room->session_id,
                     'role' => 'MODERATOR'
                 ]
             ]
         );
 
         $json = json_decode($response->getBody(), true);
 
         return response()->json($json, 200);
     }
 
     /**
      * Webhook as triggered from OpenVidu server
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\Response The response
      */
     public function webhook(Request $request)
     {
         return response('Success', 200);
     }
 }
diff --git a/src/config/openvidu.php b/src/config/openvidu.php
index 49f8afbd..3aef03a0 100644
--- a/src/config/openvidu.php
+++ b/src/config/openvidu.php
@@ -1,7 +1,7 @@
 <?php
     return [
         'api_password' => env('OPENVIDU_API_PASSWORD', 'MY_SECRET'),
         'api_url' => env('OPENVIDU_API_URL', 'https://localhost:4443/api/'),
         'api_username' => env('OPENVIDU_API_USERNAME', 'OPENVIDUAPP'),
-        'api_verify_tls' => (bool)env('OPENVIDU_API_VERIFY_TLS', 'true')
+        'api_verify_tls' => (bool) env('OPENVIDU_API_VERIFY_TLS', true)
     ];
diff --git a/src/resources/js/routes-user.js b/src/resources/js/routes-user.js
index b3d3347d..1165f19e 100644
--- a/src/resources/js/routes-user.js
+++ b/src/resources/js/routes-user.js
@@ -1,103 +1,103 @@
 import DashboardComponent from '../vue/Dashboard'
 import DomainInfoComponent from '../vue/Domain/Info'
 import DomainListComponent from '../vue/Domain/List'
 import Error404Component from '../vue/404'
 import LoginComponent from '../vue/Login'
 import LogoutComponent from '../vue/Logout'
 import MeetComponent from '../vue/Meet'
 import PasswordResetComponent from '../vue/PasswordReset'
 import SignupComponent from '../vue/Signup'
 import UserInfoComponent from '../vue/User/Info'
 import UserListComponent from '../vue/User/List'
 import UserProfileComponent from '../vue/User/Profile'
 import UserProfileDeleteComponent from '../vue/User/ProfileDelete'
 import WalletComponent from '../vue/Wallet'
 
 const routes = [
     {
         path: '/',
         redirect: { name: 'dashboard' }
     },
     {
         path: '/dashboard',
         name: 'dashboard',
         component: DashboardComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/domain/:domain',
         name: 'domain',
         component: DomainInfoComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/domains',
         name: 'domains',
         component: DomainListComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/login',
         name: 'login',
         component: LoginComponent
     },
     {
         path: '/logout',
         name: 'logout',
         component: LogoutComponent
     },
     {
-        path: '/meet/:room',
+        path: '/meet/:room?',
         name: 'meet',
         component: MeetComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/password-reset/:code?',
         name: 'password-reset',
         component: PasswordResetComponent
     },
     {
         path: '/profile',
         name: 'profile',
         component: UserProfileComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/profile/delete',
         name: 'profile-delete',
         component: UserProfileDeleteComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/signup/:param?',
         alias: '/signup/voucher/:param',
         name: 'signup',
         component: SignupComponent
     },
     {
         path: '/user/:user',
         name: 'user',
         component: UserInfoComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/users',
         name: 'users',
         component: UserListComponent,
         meta: { requiresAuth: true }
     },
     {
         path: '/wallet',
         name: 'wallet',
         component: WalletComponent,
         meta: { requiresAuth: true }
     },
     {
         name: '404',
         path: '*',
         component: Error404Component
     }
 ]
 
 export default routes
diff --git a/src/resources/vue/Dashboard.vue b/src/resources/vue/Dashboard.vue
index e7dbc723..2aedc7a6 100644
--- a/src/resources/vue/Dashboard.vue
+++ b/src/resources/vue/Dashboard.vue
@@ -1,71 +1,71 @@
 <template>
     <div class="container" dusk="dashboard-component">
         <status-component :status="status" @status-update="statusUpdate"></status-component>
 
         <div id="dashboard-nav">
             <router-link class="card link-profile" :to="{ name: 'profile' }">
                 <svg-icon icon="user-cog"></svg-icon><span class="name">Your profile</span>
             </router-link>
             <router-link class="card link-domains" :to="{ name: 'domains' }">
                 <svg-icon icon="globe"></svg-icon><span class="name">Domains</span>
             </router-link>
             <router-link class="card link-users" :to="{ name: 'users' }">
                 <svg-icon icon="users"></svg-icon><span class="name">User accounts</span>
             </router-link>
             <router-link class="card link-wallet" :to="{ name: 'wallet' }">
                 <svg-icon icon="wallet"></svg-icon><span class="name">Wallet</span>
                 <span v-if="balance < 0" class="badge badge-danger">{{ $root.price(balance) }}</span>
             </router-link>
-            <router-link class="card link-meet" v-if="$store.state.authInfo" :to="{ name: 'meet', params: { room: $store.state.authInfo.email} }">
+            <router-link class="card link-meet" :to="{ name: 'meet' }">
                 <svg-icon icon="comments"></svg-icon><span class="name">Video Chat</span>
             </router-link>
         </div>
     </div>
 </template>
 
 <script>
     import StatusComponent from './Widgets/Status'
 
     export default {
         components: {
             StatusComponent
         },
         data() {
             return {
                 status: {},
                 balance: 0
             }
         },
         mounted() {
             const authInfo = this.$store.state.isLoggedIn ? this.$store.state.authInfo : null
 
             if (authInfo) {
                 this.status = authInfo.statusInfo
                 this.getBalance(authInfo)
             } else {
                 this.$root.startLoading()
                 axios.get('/api/auth/info')
                     .then(response => {
                         this.$store.state.authInfo = response.data
                         this.status = response.data.statusInfo
                         this.getBalance(response.data)
                         this.$root.stopLoading()
                     })
                     .catch(this.$root.errorHandler)
             }
         },
         methods: {
             getBalance(authInfo) {
                 this.balance = 0;
                 // TODO: currencies, multi-wallets, accounts
                 authInfo.wallets.forEach(wallet => {
                     this.balance += wallet.balance
                 })
             },
             statusUpdate(user) {
                 this.status = Object.assign({}, this.status, user)
                 this.$store.state.authInfo.statusInfo = this.status
             }
         }
     }
 </script>
diff --git a/src/resources/vue/Meet.vue b/src/resources/vue/Meet.vue
index 9c1b9a30..65edb591 100644
--- a/src/resources/vue/Meet.vue
+++ b/src/resources/vue/Meet.vue
@@ -1,78 +1,97 @@
 <template>
     <div class="container" dusk="meet-component" v-html="html">
     </div>
 </template>
 
 <script>
     export default {
         data() {
             return {
                 html: '<openvidu-webcomponent theme="light"></openvidu-webcomponent>'
             }
         },
         mounted() {
+            this.room = this.$route.params.room
+
+            if (!this.room) {
+                this.room = this.$store.state.authInfo.email.split('@')[0]
+            }
+
             this.webComponent = this.$el.querySelector('openvidu-webcomponent')
+
+            this.$root.startLoading()
+
             this.loadUI(() => {
                 this.loadOpenvidu()
                 this.joinSession()
+                this.$root.stopLoading()
             })
         },
+        destroyed() {
+            this.webComponent.sessionConfig = {}
+        },
         methods: {
             loadUI(callback) {
                 let script = $('#openvidu-script')
 
                 if (!script.length) {
                     script = document.createElement('script')
                     script.onload = callback
 
                     script.id = 'openvidu-script'
                     script.src = '/js/openvidu-webcomponent-2.12.0.js'
 
                     let link = document.createElement('link')
                     link.rel = 'stylesheet'
                     link.href = '/css/openvidu-webcomponent-2.12.0.css'
 
                     let head = document.getElementsByTagName('head')[0]
 
                     head.appendChild(script)
                     head.appendChild(link)
                 } else {
                     callback()
                 }
             },
             loadOpenvidu() {
-                this.webComponent.setAttribute('openvidu-server-url', 'todo')
+                this.webComponent.setAttribute('openvidu-server-url', 'https://localhost:4443')
+
                 this.webComponent.addEventListener('sessionCreated', event => {
                     var session = event.detail
 
                     session.on('connectionCreated', e => {
                         console.log("connectionCreated", e)
                     })
 
                     session.on('streamDestroyed', e => {
                         console.log("streamDestroyed", e)
                     })
 
                     session.on('streamCreated', e => {
                         console.log("streamCreated", e)
                     })
                 })
 
                 this.webComponent.addEventListener('publisherCreated', event => {
                     console.log("publisherCreated event", event)
                 })
 
                 this.webComponent.addEventListener('error', event => {
                     console.log('Error event', event)
                 })
             },
             joinSession() {
-                axios.get('/api/v4/meet/openvidu', {room: this.$route.params.room})
+                axios.get('/api/v4/meet/openvidu/' + this.room)
                     .then(response => {
                         // Response data contains: sessionName, user, tokens
-                        this.webComponent.sessionConfig = response.data
+                        this.webComponent.sessionConfig = {
+                            sessionName: response.data.session,
+                            user: this.$store.state.authInfo.email,
+                            tokens: [response.data.token]
+                        }
                     })
+                    .catch(this.$root.errorHandler)
             }
         }
     }
 </script>
diff --git a/src/routes/api.php b/src/routes/api.php
index ff3448ec..cc94aae2 100644
--- a/src/routes/api.php
+++ b/src/routes/api.php
@@ -1,115 +1,115 @@
 <?php
 
 use Illuminate\Http\Request;
 
 /*
 |--------------------------------------------------------------------------
 | API Routes
 |--------------------------------------------------------------------------
 |
 | Here is where you can register API routes for your application. These
 | routes are loaded by the RouteServiceProvider within a group which
 | is assigned the "api" middleware group. Enjoy building your API!
 |
 */
 
 Route::group(
     [
         'middleware' => 'api',
         'prefix' => 'auth'
     ],
     function ($router) {
         Route::post('login', 'API\AuthController@login');
 
         Route::group(
             ['middleware' => 'auth:api'],
             function ($router) {
                 Route::get('info', 'API\AuthController@info');
                 Route::post('logout', 'API\AuthController@logout');
                 Route::post('refresh', 'API\AuthController@refresh');
             }
         );
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'api',
         'prefix' => 'auth'
     ],
     function ($router) {
         Route::post('password-reset/init', 'API\PasswordResetController@init');
         Route::post('password-reset/verify', 'API\PasswordResetController@verify');
         Route::post('password-reset', 'API\PasswordResetController@reset');
 
         Route::get('signup/plans', 'API\SignupController@plans');
         Route::post('signup/init', 'API\SignupController@init');
         Route::post('signup/verify', 'API\SignupController@verify');
         Route::post('signup', 'API\SignupController@signup');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
         'middleware' => 'auth:api',
         'prefix' => 'v4'
     ],
     function () {
         Route::apiResource('domains', API\V4\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\DomainsController@confirm');
         Route::get('domains/{id}/status', 'API\V4\DomainsController@status');
 
         Route::apiResource('entitlements', API\V4\EntitlementsController::class);
-        Route::get('meet/openvidu/{:id}', 'API\V4\OpenViduController@joinOrCreate');
+        Route::get('meet/openvidu/{id}', 'API\V4\OpenViduController@joinOrCreate');
         Route::apiResource('packages', API\V4\PackagesController::class);
         Route::apiResource('skus', API\V4\SkusController::class);
         Route::apiResource('users', API\V4\UsersController::class);
         Route::get('users/{id}/status', 'API\V4\UsersController@status');
 
         Route::apiResource('wallets', API\V4\WalletsController::class);
         Route::get('wallets/{id}/transactions', 'API\V4\WalletsController@transactions');
         Route::get('wallets/{id}/receipts', 'API\V4\WalletsController@receipts');
         Route::get('wallets/{id}/receipts/{receipt}', 'API\V4\WalletsController@receiptDownload');
 
         Route::post('payments', 'API\V4\PaymentsController@store');
         Route::get('payments/mandate', 'API\V4\PaymentsController@mandate');
         Route::post('payments/mandate', 'API\V4\PaymentsController@mandateCreate');
         Route::put('payments/mandate', 'API\V4\PaymentsController@mandateUpdate');
         Route::delete('payments/mandate', 'API\V4\PaymentsController@mandateDelete');
     }
 );
 
 Route::group(
     [
         'domain' => \config('app.domain'),
     ],
     function () {
         Route::post('webhooks/payment/{provider}', 'API\V4\PaymentsController@webhook');
         Route::post('webhooks/meet/openvidu', 'API\V4\OpenViduController@webhook');
     }
 );
 
 Route::group(
     [
         'domain' => 'admin.' . \config('app.domain'),
         'middleware' => ['auth:api', 'admin'],
         'prefix' => 'v4',
     ],
     function () {
         Route::apiResource('domains', API\V4\Admin\DomainsController::class);
         Route::get('domains/{id}/confirm', 'API\V4\Admin\DomainsController@confirm');
 
         Route::apiResource('entitlements', API\V4\Admin\EntitlementsController::class);
         Route::apiResource('packages', API\V4\Admin\PackagesController::class);
         Route::apiResource('skus', API\V4\Admin\SkusController::class);
         Route::apiResource('users', API\V4\Admin\UsersController::class);
         Route::post('users/{id}/suspend', 'API\V4\Admin\UsersController@suspend');
         Route::post('users/{id}/unsuspend', 'API\V4\Admin\UsersController@unsuspend');
         Route::apiResource('wallets', API\V4\Admin\WalletsController::class);
         Route::post('wallets/{id}/one-off', 'API\V4\Admin\WalletsController@oneOff');
         Route::get('wallets/{id}/transactions', 'API\V4\Admin\WalletsController@transactions');
         Route::apiResource('discounts', API\V4\Admin\DiscountsController::class);
     }
 );