Magic 8 Ball

1. Home
2. Magic 8 Ball /

---

Returns a Magic 8 Ball Response

GET /api/tools/magic-8-ball

https://api.cookie-api.com/api/tools/magic-8-ball

Authentication Learn how to get your API Key and use it in your requests!

URL Parameters
question	The question you want to get an answer for

cURL

curl --location 'http://api.cookie-api.com/api/tools/magic-8-ball?question=Is%20the%20earth%20round%3F' \
--header 'Authorization: API_Key'

Python

import requests

url = 'http://api.cookie-api.com/api/tools/magic-8-ball'
params = {'question': 'Is the earth round?'}
headers = {'Authorization': 'API_Key'}

response = requests.get(url, params=params, headers=headers)
print(response.json())

JavaScript

const fetch = require('node-fetch');

const url = 'http://api.cookie-api.com/api/tools/magic-8-ball';
const params = new URLSearchParams({
    question: 'Is the earth round?'
});

fetch(`${url}?${params}`, {
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

Go

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "net/url"
)

func main() {
    baseUrl := "http://api.cookie-api.com/api/tools/magic-8-ball"
    params := url.Values{}
    params.Add("question", "Is the earth round?")

    req, err := http.NewRequest("GET", baseUrl+"?"+params.Encode(), nil)
    if err != nil {
        log.Fatal(err)
    }
    req.Header.Add("Authorization", "API_Key")

    resp, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(string(body))
}

Node.js

const https = require('https');

const options = {
    hostname: 'api.cookie-api.com',
    path: '/api/tools/magic-8-ball?question=Is%20the%20earth%20round%3F',
    method: 'GET',
    headers: {
        'Authorization': 'API_Key'
    }
};

const req = https.request(options, (res) => {
    let data = '';

    res.on('data', (chunk) => {
        data += chunk;
    });

    res.on('end', () => {
        console.log(JSON.parse(data));
    });
});

req.on('error', (e) => {
    console.error(e);
});

req.end();

Ruby

require 'net/http'
require 'json'
require 'uri'

uri = URI.parse("http://api.cookie-api.com/api/tools/magic-8-ball?question=Is%20the%20earth%20round%3F")
request = Net::HTTP::Get.new(uri)
request["Authorization"] = "API_Key"

response = Net::HTTP.start(uri.hostname, uri.port) { |http|
  http.request(request)
}

puts JSON.parse(response.body)

Rust

use reqwest::header::HeaderMap;
use reqwest::blocking::get;
use std::collections::HashMap;

fn main() {
    let url = "http://api.cookie-api.com/api/tools/magic-8-ball?question=Is%20the%20earth%20round%3F";
    let mut headers = HeaderMap::new();
    headers.insert("Authorization", "API_Key".parse().unwrap());

    let client = reqwest::blocking::Client::new();
    let res = client.get(url).headers(headers).send().unwrap();

    println!("{}", res.text().unwrap());
}

Responses

200

{
    "answer": "Not at all",
    "question": "Is the earth round?",
    "success": true
}

---

Magic 8 Ball Responses

Below you will find all possible responses from the Magic 8 Ball Endpoint

Yes
No
Maybe
Ask again later
Definitely
Absolutely not
I don't think so
Yes, but not likely
No, definitely
It is certain
Don't count on it
Without a doubt
Yes, definitely
Very doubtful
Yes, in due time
No way
The outlook is good
The outlook is not so good
Most likely
Not at all
Yes, but be cautious
I'm not sure, try again
Definitely yes
Definitely no
Probably
Probably not
The answer is hazy, try again
My sources say no
My sources say yes
It's unclear, try again later
You may rely on it
Yes, but with some effort
No, but there's still hope
It’s uncertain
Concentrate and ask again
Yes, but it will take time
No, and there's no hope
Perhaps
Yes, if you really want it
No, and you should reconsider
Absolutely
Maybe not
I'm not sure, but it's possible
Yes, but only if conditions are right
No, but things could change
The future is unclear
It seems likely
The stars are aligned
The stars are not aligned
Yes, but it will require effort
No, and you should avoid it
Ask someone else
The signs point to yes
The signs point to no
It’s a possibility
Highly unlikely
Definitely not
Yes, but be prepared
No, and it's best to avoid it
Maybe, but it's uncertain
The answer lies within
Trust your intuition
The universe says yes
The universe says no
Yes, but with some reservations
No, and it's not worth it
Everything points to yes
Everything points to no
The outcome is positive
The outcome is negative
Proceed with caution
Go ahead and try
The time is not right
The time is right
Yes, but expect some obstacles
No, and it's unlikely
The future is bright
The future is dim
It’s a good idea
It’s not a good idea
The answer will surprise you
You’re on the right track
You’re not on the right track
Yes, but consider alternatives
No, and it’s a bad idea
Maybe, but proceed carefully
Yes, if you take the right steps
No, and it's not advisable
The decision is up to you
Look for signs around you
Yes, if the conditions are met
No, but it's worth a try
Everything indicates yes
Everything indicates no
Yes, but with a few challenges
No, and it's best to avoid
Yes, but be prepared for changes
No, and it's unlikely to change
It’s not clear right now
The response is unclear
Yes, with a strong possibility
No, with a high certainty
Yes, but it will take effort
No, and the chances are slim
Yes, but things might change
No, and it's better to wait
The outlook is uncertain
The situation is fluid
Yes, if you act soon
No, and it’s not worth pursuing
Yes, but with considerable effort
No, and it's unlikely to succeed
The situation looks promising
The situation looks dire
Yes, but consider all factors
No, and it’s not advisable
Yes, if you take it slow
No, and it’s best to avoid
Yes, but be cautious
No, and it’s better to reconsider