test

visa_availability_scraper_playwright.py

@@ -2,6 +2,8 @@ import asyncio
 import json
 from typing import Dict, Optional, List
 from playwright.async_api import async_playwright
+from playwright_stealth import Stealth
+import random
 
 class PassportIndexVisaScraper:
     def __init__(self, debug: bool = True):
@@ -17,57 +19,102 @@ class PassportIndexVisaScraper:
         self.browser = None
         self.context = None
         self.page = None
+        self.playwright = None
+        self.stealth_manager = None
         
     async def __aenter__(self):
         """Initialize browser with stealth mode"""
-        self.playwright = await async_playwright().start()
+        # Initialize Playwright with Stealth using context manager pattern
+        self.stealth_manager = Stealth().use_async(async_playwright())
+        self.playwright = await self.stealth_manager.__aenter__()
+
+        # Random viewport for more natural appearance
+        viewport_width = random.randint(1366, 1920)
+        viewport_height = random.randint(768, 1080)
         
-        # Launch browser with stealth settings
+        # Launch browser in headless mode with stealth settings
         self.browser = await self.playwright.chromium.launch(
-            headless=True,  # Using headless mode
+            headless=True,  # Using headless mode as requested
             args=[
                 '--disable-blink-features=AutomationControlled',
                 '--disable-dev-shm-usage',
                 '--no-sandbox',
                 '--disable-setuid-sandbox',
+                f'--window-size={viewport_width},{viewport_height}',
+                '--disable-features=IsolateOrigins,site-per-process',
+                '--enable-features=NetworkService,NetworkServiceInProcess',
+                '--disable-infobars',
+                '--hide-scrollbars',
+                '--mute-audio',
+                '--disable-background-timer-throttling',
+                '--disable-renderer-backgrounding',
+                '--disable-features=TranslateUI',
+                '--disable-ipc-flooding-protection',
+                '--force-color-profile=srgb',
+                '--metrics-recording-only',
+                '--disable-hang-monitor',
+                '--disable-popup-blocking',
+                '--disable-prompt-on-repost',
+                '--disable-background-networking',
+                '--disable-breakpad',
+                '--disable-client-side-phishing-detection',
+                '--disable-component-extensions-with-background-pages',
+                '--disable-default-apps',
+                '--disable-extensions',
+                '--disable-features=TranslateUI,BlinkGenPropertyTrees',
+                '--disable-sync',
                 '--disable-web-security',
-                '--disable-features=IsolateOrigins,site-per-process'
+                '--disable-site-isolation-trials',
+                '--no-first-run',
+                '--no-default-browser-check',
+                '--no-pings'
             ]
         )
+
+        # Rotate user agents
+        user_agents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
+        ]
         
         # Create context with realistic settings
         self.context = await self.browser.new_context(
-            viewport={'width': 1920, 'height': 1080},
-            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36',
+            viewport={'width': viewport_width, 'height': viewport_height},
+            user_agent=random.choice(user_agents),
             locale='en-US',
-            timezone_id='America/New_York'
+            timezone_id='America/New_York',
+            accept_downloads=False,
+            has_touch=False,
+            is_mobile=False,
+            device_scale_factor=1,
+            bypass_csp=True,
+            ignore_https_errors=True,
+            java_script_enabled=True
         )
         
         self.page = await self.context.new_page()
 
-        # Add stealth JavaScript to avoid detection
+        # Add additional stealth measures
         await self.page.add_init_script("""
-            // Override the navigator.webdriver property
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined
-            });
-
-            // Override chrome property
-            window.chrome = {
-                runtime: {}
-            };
-
-            // Override permissions
-            const originalQuery = window.navigator.permissions.query;
-            window.navigator.permissions.query = (parameters) => (
-                parameters.name === 'notifications' ?
-                    Promise.resolve({ state: Notification.permission }) :
-                    originalQuery(parameters)
-            );
+            // Additional evasion beyond what stealth plugin provides
+            delete Object.getPrototypeOf(navigator).webdriver;
+            
+            // Add some randomness to make fingerprint unique
+            const battery = navigator.getBattery;
+            if (battery) {
+                navigator.getBattery = async () => ({
+                    charging: Math.random() > 0.5,
+                    chargingTime: Math.floor(Math.random() * 10000),
+                    dischargingTime: Math.floor(Math.random() * 10000),
+                    level: Math.random()
+                });
+            }
         """)
         
         if self.debug:
-            print("🚀 Browser initialized with stealth mode")
+            print("🚀 Browser initialized with stealth mode (headless)")
         
         return self
     
@@ -79,8 +126,8 @@ class PassportIndexVisaScraper:
             await self.context.close()
         if self.browser:
             await self.browser.close()
-        if self.playwright:
-            await self.playwright.stop()
+        if hasattr(self, 'stealth_manager') and self.stealth_manager:
+            await self.stealth_manager.__aexit__(exc_type, exc_val, exc_tb)
         
         if self.debug:
             print("🔒 Browser closed")
@@ -89,44 +136,147 @@ class PassportIndexVisaScraper:
         """
         Navigate to the website and wait for it to load properly
         """
-        try:
-            if self.debug:
-                print("📱 Initializing session...")
-            
-            # Navigate to the page
+        max_retries = 3
+        for attempt in range(max_retries):
             try:
+                if self.debug:
+                    print(f"📱 Initializing session... (Attempt {attempt + 1}/{max_retries})")
+
+                # Add random delay to appear more human
+                if attempt > 0:
+                    await self.page.wait_for_timeout(random.randint(2000, 5000))
+                
+                # Navigate to the page with proper wait
                 response = await self.page.goto(
                     self.base_url,
-                    wait_until='domcontentloaded',
+                    wait_until='networkidle',
                     timeout=30000
                 )
-                await self.page.wait_for_timeout(3000)
+
+                # Check for Cloudflare challenge
+                page_content = await self.page.content()
+                if "Just a moment" in page_content or "cf-challenge" in page_content:
+                    if self.debug:
+                        print("⏳ Cloudflare challenge detected, waiting...")
+
+                    # Wait for Cloudflare to complete
+                    await self.page.wait_for_timeout(15000)
+
+                    # Try to wait for actual content
+                    try:
+                        await self.page.wait_for_selector('.vch-table', state='visible', timeout=20000)
+                    except:
+                        if attempt < max_retries - 1:
+                            continue
+                        else:
+                            if self.debug:
+                                print("⚠️ Cloudflare challenge persists")
+                        # Try to reload the page
+                        await self.page.reload(wait_until='networkidle', timeout=30000)
+                        await self.page.wait_for_timeout(5000)
+                
+                
+                # Wait for page to be ready - try multiple selectors
+                try:
+                    # Try to wait for any of these elements that indicate page is loaded
+                    await self.page.wait_for_selector('.vch-table', state='visible', timeout=15000)
+                except:
+                    # If wait fails, just continue after a delay
+                    if self.debug:
+                        print("⚠️ Could not find expected elements, continuing anyway...")
+                    await self.page.wait_for_timeout(3000)
                 
-                # Get the cl value from the page
+                # Close/hide the virtual keyboard if it exists
+                await self.close_virtual_keyboard()
+                
+                # Get the session value from the page
                 cl_value = await self.page.evaluate("""
                     () => {
                         const clInput = document.querySelector('#cl');
-                        return clInput ? clInput.value : 'bc2140a2d83928ce1112d01e610bad89';
+                        // Also check if the page has the visa checker elements
+                        const hasVchTable = document.querySelector('.vch-table') !== null;
+                        const hasPassSelect = document.querySelector('.vch-select-pass') !== null;
+
+                        return {
+                            cl: clInput ? clInput.value : null,
+                            hasTable: hasVchTable,
+                            hasSelectors: hasPassSelect,
+                            url: window.location.href
+                        };
                     }
                 """)
                 
                 if self.debug:
-                    print(f"✅ Page loaded, session ID: {cl_value}")
-                    
+                    if cl_value and cl_value.get('cl'):
+                        print(f"✅ Page loaded, session ID: {cl_value['cl']}")
+                        print(f"   Table present: {cl_value['hasTable']}, Selectors present: {cl_value['hasSelectors']}")
+                        print(f"   URL: {cl_value['url']}")
+                    else:
+                        print(f"⚠️ Page loaded but missing elements: {cl_value}")
+                        # If elements are missing, try one more time with a longer wait
+                        if not cl_value.get('hasTable'):
+                            await self.page.wait_for_timeout(10000)
+                            cl_value = await self.page.evaluate("""
+                                () => {
+                                    const clInput = document.querySelector('#cl');
+                                    const hasVchTable = document.querySelector('.vch-table') !== null;
+                                    const hasPassSelect = document.querySelector('.vch-select-pass') !== null;
+                                    return {
+                                        cl: clInput ? clInput.value : null,
+                                        hasTable: hasVchTable,
+                                        hasSelectors: hasPassSelect,
+                                        url: window.location.href
+                                    };
+                                }
+                            """)
+                            if cl_value.get('hasTable'):
+                                print(f"✅ Elements loaded after additional wait")
+                            else:
+                                # Continue anyway, might still work
+                                pass
+                        
                 return True
-                
+                    
             except Exception as e:
-                if self.debug:
-                    print(f"⚠️ Page load issue: {e}, continuing anyway...")
-                return True
+                if attempt == max_retries - 1:
+                    print(f"❌ Error initializing session after {max_retries} attempts: {e}")
+                    return False
+                else:
+                    if self.debug:
+                        print(f"⚠️ Attempt {attempt + 1} failed: {e}")
+                    continue
+        return False
+    
+    async def close_virtual_keyboard(self):
+        """Close the virtual keyboard if it's open"""
+        try:
+            # Check if virtual keyboard exists and is visible
+            keyboard_visible = await self.page.evaluate("""
+                () => {
+                    const keyboard = document.querySelector('#PI-VirtualKeyboard');
+                    if (keyboard) {
+                        // Hide the keyboard
+                        keyboard.style.display = 'none';
+                        keyboard.classList.remove('kioskboard-opened');
+                        // Also hide any overlay elements
+                        const overlays = document.querySelectorAll('.kioskboard-wrapper, .kioskboard-overlay');
+                        overlays.forEach(el => el.style.display = 'none');
+                        return true;
+                    }
+                    return false;
+                }
+            """)
+            
+            if keyboard_visible and self.debug:
+                print("⌨️ Virtual keyboard hidden")
                 
         except Exception as e:
-            print(f"❌ Error initializing session: {e}")
-            return False
+            if self.debug:
+                print(f"⚠️ Could not hide virtual keyboard: {e}")
     
-    async def check_visa_requirement_browser(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+    async def check_visa_requirement_api(self, passport_country: str, destination_country: str) -> Optional[Dict]:
         """
-        Check visa requirements using browser automation
+        Check visa requirements using direct API call with cookies
         
         Args:
             passport_country: Two-letter country code for passport
@@ -137,9 +287,12 @@ class PassportIndexVisaScraper:
         """
         try:
             if self.debug:
-                print(f"🌐 Checking {passport_country.upper()} → {destination_country.upper()}")
+                print(f"🌐 Checking {passport_country.upper()} → {destination_country.upper()} via API")
+            
+            # Get cookies from the page
+            cookies = await self.context.cookies()
             
-            # Get the current session ID from the page
+            # Get the session ID
             cl_value = await self.page.evaluate("""
                 () => {
                     const clInput = document.querySelector('#cl');
@@ -147,13 +300,15 @@ class PassportIndexVisaScraper:
                 }
             """)
             
-            # Make the API request through the browser with proper argument passing
+            # Make the API request with proper cookies and headers
             result = await self.page.evaluate("""
                 async (args) => {
                     const [passport, destination, sessionId] = args;
+                    
+                    // Create form data
                     const formData = new URLSearchParams();
-                    formData.append('d', destination);
-                    formData.append('s', passport);
+                    formData.append('d', destination.toLowerCase());
+                    formData.append('s', passport.toLowerCase());
                     formData.append('cl', sessionId);
                     
                     try {
@@ -162,91 +317,254 @@ class PassportIndexVisaScraper:
                             headers: {
                                 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
                                 'X-Requested-With': 'XMLHttpRequest',
-                                'Accept': 'application/json, text/javascript, */*; q=0.01'
+                                'Accept': 'application/json, text/javascript, */*; q=0.01',
+                                'Origin': 'https://www.passportindex.org',
+                                'Referer': 'https://www.passportindex.org/travel-visa-checker/'
                             },
                             body: formData.toString(),
-                            credentials: 'include'
+                            credentials: 'include',
+                            mode: 'cors'
                         });
                         
-                        if (!response.ok) {
-                            throw new Error(`HTTP ${response.status}`);
-                        }
+                        const responseText = await response.text();
                         
-                        const data = await response.json();
-                        return data;
+                        // Try to parse as JSON
+                        try {
+                            return JSON.parse(responseText);
+                        } catch {
+                            // Check if it's a Cloudflare challenge
+                            if (responseText.includes("Just a moment") || 
+                                responseText.includes("cf-challenge") || 
+                                response.status === 403) {
+                                return { error: 'Cloudflare block', status: response.status };
+                            }
+                            // Otherwise it might be a different error
+                            return { error: 'Invalid response', status: response.status };
+                        }
                     } catch (error) {
                         return { error: error.message };
                     }
                 }
-            """, [passport_country.lower(), destination_country.lower(), cl_value])
+            """, [passport_country, destination_country, cl_value])
             
-            if result and 'error' not in result:
+            if result and 'error' not in result and 'text' in result:
                 if self.debug:
-                    print(f"✅ Got result: {result}")
+                    print(f"✅ Got API result: {json.dumps(result)}")
                 return result
             elif result and 'error' in result:
-                print(f"❌ API Error: {result['error']}")
+                if self.debug:
+                    print(f"⚠️ API Error: {result['error']}")
                 return None
             else:
                 return None
                 
         except Exception as e:
-            print(f"❌ Error checking visa requirement: {e}")
+            if self.debug:
+                print(f"❌ Error checking visa requirement via API: {e}")
             return None
     
-    async def check_visa_interactive(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+    async def check_visa_interactive_v2(self, passport_country: str, destination_country: str) -> Optional[Dict]:
         """
-        Alternative method: Use the interactive UI to check visa requirements
+        Alternative interactive method with better element handling
         """
         try:
             if self.debug:
-                print(f"🖱️ Using interactive method for {passport_country.upper()} → {destination_country.upper()}")
+                print(f"🖱️ Using interactive method v2 for {passport_country.upper()} → {destination_country.upper()}")
             
-            # Click on the passport selector
-            await self.page.click('.vch-select-pass')
-            await self.page.wait_for_timeout(500)
+            # First, ensure virtual keyboard is hidden
+            await self.close_virtual_keyboard()
             
-            # Find and click the country in the list
-            passport_selector = f'.vch-passports .s-div[data-ccode="{passport_country.lower()}"]'
-            await self.page.wait_for_selector(passport_selector, timeout=5000)
-            await self.page.click(passport_selector)
-            await self.page.wait_for_timeout(500)
+            # Clear any previous selections via JavaScript
+            await self.page.evaluate("""
+                () => {
+                    // Reset the form
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    const destSelect = document.querySelector('.vch-select-des');
+                    if (passSelect) passSelect.textContent = 'Select Passport';
+                    if (destSelect) destSelect.textContent = 'Select Destination';
+                    
+                    // Hide any open dropdowns
+                    const passports = document.querySelector('.vch-passports');
+                    const destinations = document.querySelector('.vch-destinations');
+                    if (passports) passports.classList.remove('opener');
+                    if (destinations) destinations.classList.remove('opener');
+                }
+            """)
             
-            # Click on the destination selector
-            await self.page.click('.vch-select-des')
             await self.page.wait_for_timeout(500)
             
-            # Find and click the destination country
-            dest_selector = f'.vch-destinations .s-div[data-ccode="{destination_country.lower()}"]'
-            await self.page.wait_for_selector(dest_selector, timeout=5000)
-            await self.page.click(dest_selector)
+            # Select passport using JavaScript
+            passport_selected = await self.page.evaluate("""
+                (countryCode) => {
+                    // Click the passport selector
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    if (!passSelect) return false;
+                    passSelect.click();
+                    
+                    // Wait a bit for dropdown to open
+                    setTimeout(() => {
+                        // Find and click the country
+                        const countryElement = document.querySelector(`.vch-passports .s-div[data-ccode="${countryCode.toLowerCase()}"]`);
+                        if (countryElement) {
+                            countryElement.click();
+                            return true;
+                        }
+                    }, 300);
+                    
+                    return false;
+                }
+            """, passport_country)
+            
             await self.page.wait_for_timeout(1000)
             
-            # Get the result from the page
+            # Select destination using JavaScript
+            destination_selected = await self.page.evaluate("""
+                (countryCode) => {
+                    // Click the destination selector
+                    const destSelect = document.querySelector('.vch-select-des');
+                    if (!destSelect) return false;
+                    destSelect.click();
+                    
+                    // Wait a bit for dropdown to open
+                    setTimeout(() => {
+                        // Find and click the country
+                        const countryElement = document.querySelector(`.vch-destinations .s-div[data-ccode="${countryCode.toLowerCase()}"]`);
+                        if (countryElement) {
+                            countryElement.click();
+                            return true;
+                        }
+                    }, 300);
+                    
+                    return false;
+                }
+            """, destination_country)
+            
+            await self.page.wait_for_timeout(2000)
+            
+            # Get the result
             result = await self.page.evaluate("""
                 () => {
                     const resultElement = document.querySelector('.vch-result');
                     if (resultElement) {
                         const text = resultElement.querySelector('.text');
                         const days = resultElement.querySelector('.days');
+                        const passSelect = document.querySelector('.vch-select-pass');
+                        const destSelect = document.querySelector('.vch-select-des');
+                        
                         return {
-                            text: text ? text.textContent : '',
-                            days: days ? days.textContent : '',
-                            pass: '""" + passport_country.lower() + """',
-                            dest: '""" + destination_country.upper() + """'
+                            text: text ? text.textContent.trim() : '',
+                            days: days ? days.textContent.trim() : '',
+                            pass: passSelect ? passSelect.textContent.trim() : '',
+                            dest: destSelect ? destSelect.textContent.trim() : ''
                         };
                     }
                     return null;
                 }
             """)
             
+            if result and result['text']:
+                return result
+            
+            return None
+            
+        except Exception as e:
+            if self.debug:
+                print(f"❌ Interactive method v2 failed: {e}")
+            return None
+    
+    async def check_visa_direct_manipulation(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+        """
+        Direct manipulation method - directly trigger the visa check
+        """
+        try:
+            if self.debug:
+                print(f"🔧 Using direct manipulation for {passport_country.upper()} → {destination_country.upper()}")
+            
+            # Directly call the visa checker function if it exists
+            result = await self.page.evaluate("""
+                async (args) => {
+                    const [passport, destination] = args;
+                    // Try to find and call the visa checker function directly
+                    if (typeof visaChecker !== 'undefined' && typeof visaChecker.check === 'function') {
+                        return await visaChecker.check(passport, destination);
+                    }
+                    
+                    // Alternative: manually trigger the check
+                    const cl = document.querySelector('#cl')?.value || 'bc2140a2d83928ce1112d01e610bad89';
+                    
+                    // Set the selections visually
+                    const passSelect = document.querySelector('.vch-select-pass');
+                    const destSelect = document.querySelector('.vch-select-des');
+                    
+                    if (passSelect && destSelect) {
+                        // Find country names
+                        const passportElement = document.querySelector(`.vch-passports .s-div[data-ccode="${passport}"] .cname`);
+                        const destElement = document.querySelector(`.vch-destinations .s-div[data-ccode="${destination}"] .cname`);
+                        
+                        if (passportElement) passSelect.textContent = passportElement.textContent;
+                        if (destElement) destSelect.textContent = destElement.textContent;
+                        
+                        // Make the AJAX call
+                        return new Promise((resolve) => {
+                            $.ajax({
+                                url: 'https://www.passportindex.org/core/visachecker.php',
+                                type: 'POST',
+                                data: {
+                                    d: destination,
+                                    s: passport,
+                                    cl: cl
+                                },
+                                success: function(response) {
+                                    // Update the UI
+                                    if (response.text) {
+                                        const resultElement = document.querySelector('.vch-result');
+                                        if (resultElement) {
+                                            resultElement.className = 'vch-result tv-grey ' + (response.vr ? 'tvvr' : 'tvvf');
+                                            const textElement = resultElement.querySelector('.text');
+                                            if (textElement) textElement.textContent = response.text;
+                                        }
+                                    }
+                                    resolve(response);
+                                },
+                                error: function(xhr) {
+                                    resolve({ error: 'Request failed', status: xhr.status });
+                                }
+                            });
+                        });
+                    }
+                    
+                    return null;
+                }
+            """, [passport_country.lower(), destination_country.lower()])
+            
             return result
             
         except Exception as e:
             if self.debug:
-                print(f"❌ Interactive method failed: {e}")
+                print(f"❌ Direct manipulation failed: {e}")
             return None
     
+    async def check_visa_requirement(self, passport_country: str, destination_country: str) -> Optional[Dict]:
+        """
+        Main method to check visa requirements - tries multiple approaches
+        """
+        # Try API method first
+        result = await self.check_visa_requirement_api(passport_country, destination_country)
+        if result:
+            return result
+        
+        # Try direct manipulation
+        result = await self.check_visa_direct_manipulation(passport_country, destination_country)
+        if result:
+            return result
+        
+        # Try interactive method v2
+        result = await self.check_visa_interactive_v2(passport_country, destination_country)
+        if result:
+            return result
+        
+        return None
+    
     async def check_multiple_destinations(self, passport_country: str, destinations: List[str], delay: float = 2.0) -> Dict:
         """
         Check visa requirements for multiple destinations
@@ -264,12 +582,7 @@ class PassportIndexVisaScraper:
         for i, dest in enumerate(destinations, 1):
             print(f"\n[{i}/{len(destinations)}] Checking {passport_country.upper()} → {dest.upper()}...")
             
-            # Try API method first
-            result = await self.check_visa_requirement_browser(passport_country, dest)
-            
-            # If API fails, try interactive method
-            if not result:
-                result = await self.check_visa_interactive(passport_country, dest)
+            result = await self.check_visa_requirement(passport_country, dest)
             
             if result:
                 results[dest] = result
@@ -291,17 +604,20 @@ class PassportIndexVisaScraper:
         if not result:
             return "No information available"
         
-        text = result.get('text', 'N/A')
-        dest = result.get('dest', 'N/A')
-        passport = result.get('pass', 'N/A')
-        
-        return f"{passport.upper()} → {dest.upper()}: {text}"
+        # Return clean JSON format
+        return json.dumps({
+            'text': result.get('text', 'N/A'),
+            'col': result.get('col', ''),
+            'link': result.get('link', 0),
+            'dest': result.get('dest', '').upper(),
+            'pass': result.get('pass', '').upper()
+        })
 
 
 async def main():
     """Main function to demonstrate usage"""
     print("="*60)
-    print(" Passport Index Visa Checker (Playwright)")
+    print(" Passport Index Visa Checker (Playwright - Fixed)")
     print("="*60)
     
     async with PassportIndexVisaScraper(debug=True) as scraper:
@@ -317,14 +633,11 @@ async def main():
         # Test single visa requirement
         print("\n📍 Single visa check: US → GB")
         print("-" * 40)
-        result = await scraper.check_visa_requirement_browser('us', 'gb')
+        result = await scraper.check_visa_requirement('us', 'gb')
         if result:
-            print(f"Result: {scraper.format_result(result)}")
+            print(f"Result: {json.dumps(result)}")
         else:
-            print("Trying interactive method...")
-            result = await scraper.check_visa_interactive('us', 'gb')
-            if result:
-                print(f"Result: {scraper.format_result(result)}")
+            print("❌ Failed to get result")
         
         # Test multiple destinations
         print("\n📍 Multiple destinations for US passport:")
@@ -335,9 +648,9 @@ async def main():
         print("\n📊 Summary:")
         for dest, result in results.items():
             if result:
-                print(f"  ✅ {scraper.format_result(result)}")
+                print(f"  ✅ {dest.upper()}: {json.dumps(result)}")
             else:
                 print(f"  ❌ US → {dest.upper()}: Failed")
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())