Sistemi Personali - SuperEnalotto

I tuoi algoritmi vengono eseguiti nel tuo browser; i dati vengono recuperati dal server. Nessun codice viene inviato o salvato sui nostri server. Tutti i dati restano sul tuo dispositivo.
Nessun sistema registrato
Tempo rimanente:
100%
Nessun output

API disponibili

Il tuo algoritmo riceve un oggetto api con questi metodi:

Dati

const info = await api.GetInfo();           // Info lotteria
const ultima = await api.GetLastDraw();     // Last draw
const estrazione = await api.GetDrawByDate('2026-03-10'); // Estrazione per data
const archivio = await api.GetDraws({ offset: 0, limit: 10 }); // Archivio paginato

Statistiche

const ritardi = await api.GetDelays('draws');       // Ritardi attuali
const frequenze = await api.GetFrequencies('draws'); // Frequenze
const max_rit = await api.GetMaxDelays('draws', { combination: 2 }); // Massimi ritardi
const max_freq = await api.GetMaxFreqs('draws', { combination: 2 }); // Massime Frequenze

Output

api.Log('messaggio');           // Riga di log normale
api.LogInfo('informazione');    // Info (blu)
api.LogError('errore');         // Errore (rosso)
api.SetTable(
    ['Numero', 'Ritardo'],
    [[1, 45], [2, 12], [3, 78]]
);                              // Tabella formattata
api.SetResult({ chiave: 'valore' }); // Risultato finale

Proprietà

api.section   // 'superenalotto' - Sezione corrente
api.lottery   // 'superenalotto' - Nome API della lotteria

Note

  • Tutti i metodi API sono asincroni - usa await
  • L'algoritmo viene eseguito in un Web Worker senza accesso al DOM
  • Tempo massimo di esecuzione: 30 secondi
  • Le chiamate API hanno un piccolo ritardo per prevenire sovraccarichi
  • Sono disponibili solo endpoint in sola lettura

Cosa sono i Sistemi Personali?

I Sistemi Personali ti permettono di scrivere piccoli programmi JavaScript che analizzano i dati della lotteria utilizzando le nostre API REST. Puoi creare le tue strategie di analisi, cercare pattern o costruire report statistici personalizzati.

Come funziona

  1. Scrivi codice JavaScript nella scheda Editor
  2. Usa l'oggetto api per recuperare i dati della lotteria
  3. Visualizza i risultati con api.Log(), api.SetTable() o api.SetResult()
  4. Clicca Esegui per eseguire - i risultati appaiono nell'area output sotto l'editor
  5. Salva il tuo algoritmo per riutilizzarlo in seguito

Privacy e sicurezza

  • Il tuo codice viene eseguito interamente nel tuo browser (Web Worker)
  • Nessun codice viene caricato su alcun server
  • Gli algoritmi sono memorizzati nel localStorage del tuo browser
  • La sandbox di esecuzione non ha accesso alla pagina, ai cookie o ad altri dati
  • Un budget di calcolo limita l'esecuzione a un massimo di 30 secondi

Limitazioni

  • Sono accessibili solo i dati della lotteria corrente
  • Sono disponibili solo endpoint API in sola lettura (nessuna scrittura)
  • Nessun accesso a URL esterni, DOM o API del browser
  • Ogni chiamata API ha un piccolo ritardo (~200ms) per prevenire sovraccarichi
  • Massimo 30 secondi di tempo di esecuzione per esecuzione

Riferimento API

api.GetInfo()

Restituisce informazioni generali sulla lotteria corrente (nome, tipi di estrazione, calendario, ecc.).

const info = await api.GetInfo();
api.Log('Lotteria: ' + info.name);
api.Log('Numero massimo estraibile: ' + info.max_number);

api.GetLastDraw()

Restituisce l'ultima estrazione con tutti i numeri estratti.

const ultima = await api.GetLastDraw();
const numeri = ultima.draw.numbers[0].values;
api.Log('Ultima estrazione: ' + numeri.join('.'));
api.Log('Data: ' + ultima.draw.date.day + '/' + ultima.draw.date.month + '/' + ultima.draw.date.year);

api.GetDrawByDate(data)

Restituisce tutte le estrazioni di una data specifica. La data deve essere in formato AAAA-MM-GG. Per le lotterie infragiornaliere, restituisce tutte le estrazioni del giorno.

const risultato = await api.GetDrawByDate('2026-03-10');
const estrazioni = risultato.draws || [];
api.Log('Estrazioni trovate: ' + estrazioni.length);
for (const e of estrazioni)
    api.Log(e.numbers[0].values.join('.'));

api.GetDraws({ offset, limit })

Restituisce una lista paginata di estrazioni dall'archivio. offset: 0 = la piu recente, offset: 1 = la penultima, ecc.

const archivio = await api.GetDraws({ offset: 0, limit: 5 });
const estrazioni = archivio.draws || [];
api.Log('Ultime 5 estrazioni:');
for (const e of estrazioni)
{
    const dt = e.date;
    const data = dt.day + '/' + dt.month + '/' + dt.year;
    api.Log(data + ': ' + e.numbers[0].values.join('.'));
}

const penultima = await api.GetDraws({ offset: 1, limit: 1 });
api.Log('Penultima: ' + penultima.draws[0].numbers[0].values.join('.'));

api.GetDelays(tipo_estrazione)

Restituisce il ritardo attuale (numero di estrazioni dall'ultima apparizione) per ogni numero. Il risultato contiene items: un array di { number, value }.

const ritardi = await api.GetDelays('draws');
const ordinati = ritardi.items.slice().sort((a, b) => b.value - a.value);
const top3 = ordinati.slice(0, 3);
api.Log('I 3 numeri piu in ritardo:');
for (const r of top3)
    api.Log('Numero ' + r.number + ' -> ritardo ' + r.value);

api.GetFrequencies(tipo_estrazione)

Restituisce la frequenza totale (numero di volte in cui e stato estratto) per ogni numero. Il risultato contiene items: un array di { number, value }.

const frequenze = await api.GetFrequencies('draws');
const ordinati = frequenze.items.slice().sort((a, b) => b.value - a.value);
const top3 = ordinati.slice(0, 3);
api.Log('I 3 numeri piu frequenti:');
for (const f of top3)
    api.Log('Numero ' + f.number + ' -> uscito ' + f.value + ' volte');

api.GetMaxDelays(tipo_estrazione, { combination, group })

Restituisce i ritardi massimi storici. Usa combination per specificare quanti numeri per gruppo (1=singoli, 2=coppie, 3=terzine). Usa group per limitare i risultati.

const max_singoli = await api.GetMaxDelays('draws', { combination: 1, group: 1 });
api.Log('Ritardi massimi storici (singoli):');
api.SetTable(
    ['Numero', 'Ritardo max storico'],
    max_singoli.items.slice(0, 10).map(r => [r.number, r.value])
);

const max_coppie = await api.GetMaxDelays('draws', { combination: 2, group: 5 });
api.Log('Ritardi massimi storici (coppie, top 5):');
api.SetTable(
    ['Coppia', 'Ritardo max'],
    max_coppie.items.slice(0, 5).map(r => [r.number, r.value])
);

api.GetMaxFreqs(tipo_estrazione, { combination, group })

Restituisce le frequenze massime storiche. Stessi parametri di GetMaxDelays.

const max_freq = await api.GetMaxFreqs('draws', { combination: 1, group: 1 });
api.Log('Frequenze massime storiche (singoli):');
api.SetTable(
    ['Numero', 'Frequenza max storica'],
    max_freq.items.slice(0, 10).map(f => [f.number, f.value])
);

Metodi di Output

api.Log(messaggio)

Scrive una riga di testo normale nell'area di output.

api.Log('Questo e un messaggio normale');
api.Log('Risultato: ' + 42);

api.LogInfo(messaggio)

Scrive una riga informativa evidenziata (blu).

api.LogInfo('Analisi completata con successo');

api.LogError(messaggio)

Scrive una riga di errore (rossa).

api.LogError('Dati non disponibili');

api.SetTable(intestazioni, righe)

Visualizza i dati come tabella formattata. intestazioni e un array di nomi di colonne, righe e un array di array (uno per riga).

api.SetTable(
    ['Posizione', 'Numero', 'Ritardo'],
    [
        [1, 45, 120],
        [2, 12, 98],
        [3, 78, 85]
    ]
);

api.SetResult(dati)

Imposta un oggetto risultato finale, visualizzato come JSON formattato nell'area di output.

api.SetResult({
    numeri_consigliati: [12, 45, 78],
    strategia: 'ritardatari',
    affidabilita: 'bassa'
});

Proprietà

api.section

Il nome della sezione della lotteria corrente. Valore: 'superenalotto'

api.lottery

L'identificatore interno della lotteria nelle API. Valore: 'superenalotto'

Esempio completo

This algorithm compares current delays with historical frequencies to find numbers that are both delayed and historically frequent (potentially \"due\" numbers).

const ritardi = await api.GetDelays('draws');
const frequenze = await api.GetFrequencies('draws');

if (!ritardi || !ritardi.items || !frequenze || !frequenze.items)
{
    api.LogError('Dati non disponibili');
    return;
}

const mappa_freq = {};
frequenze.items.forEach(f => mappa_freq[f.number] = f.value);

const mediana_freq = frequenze.items
    .map(f => f.value)
    .sort((a, b) => a - b)[Math.floor(frequenze.items.length / 2)];

const candidati = ritardi.items
    .filter(r => (mappa_freq[r.number] || 0) > mediana_freq)
    .sort((a, b) => b.value - a.value)
    .slice(0, 10);

api.LogInfo('Numeri in ritardo con alta frequenza storica:');
api.SetTable(
    ['Numero', 'Ritardo attuale', 'Frequenza storica'],
    candidati.map(c => [c.number, c.value, mappa_freq[c.number] || 0])
);

api.Log('Trovati ' + candidati.length + ' candidati');

Sistemi Personali

I Sistemi Personali ti permettono di scrivere piccoli programmi JavaScript che analizzano i dati del SuperEnalotto utilizzando le nostre API REST. Puoi creare le tue strategie di analisi, cercare pattern o costruire report statistici personalizzati.