technology software

cryptocurrency blockchain

documentation technical

English

__cf_bm

Domain 'testing-cloudflare-turnstile.pages.dev' uses the developer-focused generic top-level domain (.dev) and includes subdomain 'testing-cloudflare-turnstile'. Count 5 characters in 'pages' with 2 vowels and 3 consonants. Tokenizing the label suggests one word: pages. No strong language cues emerged from the frequency lists.

name

email

message

cf-turnstile-response

html/a5/cb/a5cbb0df-b0dc-4ae8-9336-b128eb7687b4.html.gz

46a2126ccb16841040f55934627c444b0eb965e51f2a7ea90e24e504a56eb56c

76f74cf8cbe686197a7d645ef726a987f02a1253716eb250b8f20b0ea3f1e51c

4f6c414c231d763b9843dfabb48edc462ccbe8680c5283019ce5c365a19222ae

viewport

html/a5/cb/a5cbb0df-b0dc-4ae8-9336-b128eb7687b4_nodriver.html.gz

Cloudflare Turnstile Test Page

Abuse Team

CloudFlare, Inc.

pages.dev

Abuse

Admin

Cloudflare-NOC

Cloudflare, Inc.

CLOUDFLARENET


        // State management
        const state = {
            currentSiteKey: '1x00000000000000000000AA',
            turnstileToken: null,
            widgetId: null,
            isWidgetLoaded: false
        };

        // DOM elements
        const elements = {
            siteKeyRadios: document.querySelectorAll('input[name="sitekey"]'),
            customSiteKeyInput: document.getElementById('customSiteKeyInput'),
            customSiteKey: document.getElementById('customSiteKey'),
            applySiteKeyBtn: document.getElementById('applySiteKeyBtn'),
            turnstileContainer: document.getElementById('turnstileContainer'),
            widgetLoader: document.getElementById('widgetLoader'),
            widgetPlaceholder: document.getElementById('widgetPlaceholder'),
            testForm: document.getElementById('testForm'),
            submitBtn: document.getElementById('submitBtn'),
            bypassCheckbox: document.getElementById('bypassTurnstile'),

            // Status elements
            widgetStatus: document.getElementById('widgetStatus'),
            activeSiteKey: document.getElementById('activeSiteKey'),
            tokenStatus: document.getElementById('tokenStatus'),
            bypassStatus: document.getElementById('bypassStatus'),
            tokenDisplay: document.getElementById('tokenDisplay'),
            tokenValue: document.getElementById('tokenValue'),

            // Configuration elements
            themeSelect: document.getElementById('themeSelect'),
            sizeSelect: document.getElementById('sizeSelect'),
            languageSelect: document.getElementById('languageSelect'),

            // Response elements
            responseSection: document.getElementById('responseSection'),
            responseLoader: document.getElementById('responseLoader'),
            responseContent: document.getElementById('responseContent'),
            detailsSection: document.getElementById('detailsSection')
        };

        // Event listeners
        function setupEventListeners() {
            // Site key radio change
            elements.siteKeyRadios.forEach(radio => {
                radio.addEventListener('change', handleSiteKeyChange);
            });

            // Apply site key button
            elements.applySiteKeyBtn.addEventListener('click', applySiteKey);

            // Configuration changes
            elements.themeSelect.addEventListener('change', renderWidget);
            elements.sizeSelect.addEventListener('change', renderWidget);
            elements.languageSelect.addEventListener('change', renderWidget);

            // Bypass checkbox
            elements.bypassCheckbox.addEventListener('change', handleBypassChange);

            // Form submission
            elements.testForm.addEventListener('submit', handleFormSubmit);
        }

        // Handle site key radio change
        function handleSiteKeyChange(event) {
            const isCustom = event.target.value === 'custom';
            elements.customSiteKeyInput.classList.toggle('hidden', !isCustom);

            if (!isCustom) {
                state.currentSiteKey = event.target.value;
            }
        }

        // Apply site key and reload widget
        function applySiteKey() {
            const selectedRadio = document.querySelector('input[name="sitekey"]:checked');

            if (selectedRadio.value === 'custom') {
                const customKey = elements.customSiteKey.value.trim();
                if (!customKey) {
                    alert('Please enter a custom site key');
                    return;
                }
                state.currentSiteKey = customKey;
            } else {
                state.currentSiteKey = selectedRadio.value;
            }

            console.log('🔑 Applying site key:', state.currentSiteKey);
            elements.activeSiteKey.textContent = state.currentSiteKey;

            renderWidget();
        }

        // Handle bypass checkbox change
        function handleBypassChange(event) {
            const isEnabled = event.target.checked;
            elements.bypassStatus.textContent = isEnabled ? 'Enabled' : 'Disabled';
            elements.bypassStatus.className = `status-badge ${isEnabled ? 'bypassed' : 'pending'}`;

            updateSubmitButton();
        }

        // Update submit button state
        function updateSubmitButton() {
            const hasToken = !!state.turnstileToken;
            const isBypassed = elements.bypassCheckbox.checked;
            const canSubmit = hasToken || isBypassed;

            elements.submitBtn.disabled = !canSubmit;
        }

        // Render Turnstile widget
        function renderWidget() {
            if (!window.turnstile) {
                console.log('⏳ Turnstile not yet loaded, retrying...');
                setTimeout(renderWidget, 100);
                return;
            }

            console.log('🔄 Rendering widget with site key:', state.currentSiteKey);

            // Show loading state
            elements.widgetLoader.style.display = 'block';
            elements.widgetPlaceholder.textContent = 'Loading widget...';
            elements.widgetStatus.textContent = 'Loading';
            elements.widgetStatus.className = 'status-badge pending';

            // Clear existing widget
            if (state.widgetId) {
                try {
                    window.turnstile.remove(state.widgetId);
                } catch (error) {
                    console.warn('Failed to remove existing widget:', error);
                }
            }

            // Clear container
            elements.turnstileContainer.innerHTML = '';

            // Create new widget element
            const widgetDiv = document.createElement('div');
            elements.turnstileContainer.appendChild(widgetDiv);

            try {
                // Render new widget
                state.widgetId = window.turnstile.render(widgetDiv, {
                    sitekey: state.currentSiteKey,
                    callback: onTurnstileSuccess,
                    'error-callback': onTurnstileError,
                    'expired-callback': onTurnstileExpired,
                    'timeout-callback': onTurnstileTimeout,
                    theme: elements.themeSelect.value,
                    size: elements.sizeSelect.value,
                    language: elements.languageSelect.value
                });

                console.log('✅ Widget rendered successfully with ID:', state.widgetId);
                state.isWidgetLoaded = true;

                // Reset state
                resetTurnstileState();

            } catch (error) {
                console.error('❌ Failed to render widget:', error);
                elements.widgetStatus.textContent = 'Error';
                elements.widgetStatus.className = 'status-badge error';
                elements.turnstileContainer.innerHTML = `<p>Failed to load widget: ${error.message}</p>`;
            }
        }

        // Reset Turnstile state
        function resetTurnstileState() {
            state.turnstileToken = null;
            elements.widgetStatus.textContent = 'Ready';
            elements.widgetStatus.className = 'status-badge pending';
            elements.tokenStatus.textContent = 'Waiting for verification...';
            elements.tokenDisplay.classList.add('hidden');

            updateSubmitButton();
        }

        // Turnstile callback functions
        function onTurnstileSuccess(token) {
            console.log('✅ Turnstile success:', token);
            state.turnstileToken = token;

            elements.widgetStatus.textContent = 'Verified';
            elements.widgetStatus.className = 'status-badge success';
            elements.tokenStatus.textContent = 'Token generated successfully';
            elements.tokenValue.textContent = token;
            elements.tokenDisplay.classList.remove('hidden');

            updateSubmitButton();
        }

        function onTurnstileError(errorCode) {
            console.error('❌ Turnstile error:', errorCode);

            elements.widgetStatus.textContent = 'Error';
            elements.widgetStatus.className = 'status-badge error';
            elements.tokenStatus.textContent = `Error: ${errorCode}`;
            elements.tokenDisplay.classList.add('hidden');

            updateSubmitButton();
        }

        function onTurnstileExpired() {
            console.warn('⏰ Turnstile expired');
            state.turnstileToken = null;

            elements.widgetStatus.textContent = 'Expired';
            elements.widgetStatus.className = 'status-badge pending';
            elements.tokenStatus.textContent = 'Token expired - please refresh';
            elements.tokenDisplay.classList.add('hidden');

            updateSubmitButton();
        }

        function onTurnstileTimeout() {
            console.warn('⏱️ Turnstile timeout');

            elements.widgetStatus.textContent = 'Timeout';
            elements.widgetStatus.className = 'status-badge pending';
            elements.tokenStatus.textContent = 'Challenge timed out';
        }

        // Handle form submission
        async function handleFormSubmit(event) {
            event.preventDefault();

            const isBypassed = elements.bypassCheckbox.checked;
            if (!state.turnstileToken && !isBypassed) {
                alert('Please complete Turnstile verification or enable bypass mode');
                return;
            }

            // Show loading state
            elements.responseSection.classList.add('show');
            elements.responseLoader.style.display = 'block';
            elements.responseContent.textContent = '';
            elements.submitBtn.disabled = true;
            elements.submitBtn.textContent = 'Sending Request...';

            try {
                const result = await sendApiRequest();
                displayResponse(result);
            } catch (error) {
                displayError(error);
            } finally {
                elements.responseLoader.style.display = 'none';
                elements.submitBtn.disabled = false;
                elements.submitBtn.textContent = 'Send Test Request to API';

                // Reset widget if not bypassed
                if (!isBypassed && state.widgetId) {
                    window.turnstile.reset(state.widgetId);
                    resetTurnstileState();
                }
            }
        }

        // Send API request
        async function sendApiRequest() {
            const formData = new FormData(elements.testForm);
            const data = Object.fromEntries(formData.entries());

            // Add Turnstile token
            const token = state.turnstileToken || 'BYPASSED_FOR_TESTING';
            data.turnstile_token = token;

            const baseUrl = 'https://api.ingka.cte.ikeadt.com/apim/upstream/v1/terminated/no-auth';
            const url = new URL(baseUrl);
            url.searchParams.set('bucket_host', 'dev-gcp-eu-cp-1-apim-kong-gw.gke.ingka.com');
            url.searchParams.set('cf-turnstile', 'true');
            url.searchParams.set('turnstile_token', token);

            const requestHeaders = {
                'Content-Type': 'application/json',
                'Accept': 'application/json',
                'Origin': window.location.origin,
                'Referer': window.location.href
            };

            const requestBody = JSON.stringify(data);
            const startTime = performance.now();

            console.group('📤 API Request');
            console.log('URL:', url.toString());
            console.log('Headers:', requestHeaders);
            console.log('Body:', data);
            console.groupEnd();

            const response = await fetch(url.toString(), {
                method: 'POST',
                headers: requestHeaders,
                body: requestBody
            });

            const endTime = performance.now();
            const duration = Math.round(endTime - startTime);

            const responseText = await response.text();
            let responseData;

            try {
                responseData = JSON.parse(responseText);
            } catch {
                responseData = responseText;
            }

            const responseHeaders = {};
            response.headers.forEach((value, key) => {
                responseHeaders[key] = value;
            });

            return {
                request: {
                    url: url.toString(),
                    headers: requestHeaders,
                    body: data
                },
                response: {
                    status: response.status,
                    statusText: response.statusText,
                    headers: responseHeaders,
                    body: responseData,
                    duration
                },
                success: response.ok
            };
        }

        // Display API response
        function displayResponse(result) {
            elements.detailsSection.classList.add('show');

            // Request details
            document.getElementById('requestUrl').textContent = result.request.url;
            document.getElementById('requestHeaders').textContent = JSON.stringify(result.request.headers, null, 2);
            document.getElementById('requestBody').textContent = JSON.stringify(result.request.body, null, 2);

            // Response details
            document.getElementById('responseStatus').textContent = `${result.response.status} ${result.response.statusText}`;
            document.getElementById('responseDuration').textContent = `${result.response.duration}ms`;
            document.getElementById('responseHeaders').textContent = JSON.stringify(result.response.headers, null, 2);
            document.getElementById('responseBody').textContent = typeof result.response.body === 'object'
                ? JSON.stringify(result.response.body, null, 2)
                : result.response.body;

            // Main response display
            if (result.success) {
                elements.responseContent.style.borderLeft = '4px solid var(--pico-primary-background)';
                elements.responseContent.textContent = typeof result.response.body === 'object'
                    ? JSON.stringify(result.response.body, null, 2)
                    : result.response.body;
            } else {
                elements.responseContent.style.borderLeft = '4px solid var(--pico-del-color)';
                elements.responseContent.textContent = `Status: ${result.response.status} ${result.response.statusText}\n\n${
                    typeof result.response.body === 'object'
                        ? JSON.stringify(result.response.body, null, 2)
                        : result.response.body
                }`;
            }

            console.group('📥 API Response');
            console.log('Status:', result.response.status);
            console.log('Duration:', result.response.duration + 'ms');
            console.log('Body:', result.response.body);
            console.groupEnd();
        }

        // Display error
        function displayError(error) {
            elements.responseContent.style.borderLeft = '4px solid var(--pico-del-color)';
            elements.responseContent.textContent = `Error: ${error.message}\n\nThis might be a CORS issue if the API doesn't allow requests from this domain.`;

            console.error('❌ Request failed:', error);
        }

        // Initialize application
        function init() {
            console.log('📄 Turnstile Test Page Initialized');
            setupEventListeners();

            // Wait for Turnstile to load, then render widget
            if (window.turnstile) {
                renderWidget();
            } else {
                const checkTurnstile = () => {
                    if (window.turnstile) {
                        renderWidget();
                    } else {
                        setTimeout(checkTurnstile, 100);
                    }
                };
                checkTurnstile();
            }
        }

        // Start when DOM is ready
        if (document.readyState === 'loading') {
            document.addEventListener('DOMContentLoaded', init);
        } else {
            init();
        }
    

Cloudflare

Cloudflare Turnstile

✅ Low Risk - http://testing-cloudflare-turnstile.pages.dev/

Requests	IP Address	Location	AS Autonomous System
3	104.18.94.41	United States	AS54113
1	172.66.47.88	United States	AS13335
1	104.18.95.41	United States	AS13335CLOUDFLARENET
1	172.66.44.168	United States	AS13335CLOUDFLARENET
1	104.16.175.226	United States	Unknown
7	5	-	-

Security Scan Report: testing-cloudflare-turnstile.pages.dev

Summary

AI Security Verdict

High Risk

Risk Factors

Details

Screenshot

Page Load Overview

Language Analysis

Primary Language

Detection Details

Website Classification

Primary Category

All Detected Categories

Detected Features

Domain & IP Information

Detected Technologies2

Content Similarity HashesFor malware variant detection

TLSH (Trend Micro Locality Sensitive Hash)

ssdeep (Context Triggered Piecewise Hashing)

sdhash (Similarity Digest Hashing)

Image Hashes

Perceptual Hashes

Other Hashes

Scan History