¿Hay alguna forma de obtener la foto del día de Bing?

¿Hay alguna forma de obtener la imagen de fondo de Bing mediante programación?

La API de Bing no parece proporcionar tal funcionalidad, ¿quizás hay otra forma?

Creo que la mejor manera es imitar la forma en que lo hacen ellos mismos a través de sus llamadas AJAX.

Llaman a esta URL y extraen la información mediante deserialización XML.

XML: http://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=en-US

JSON: http://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-US

RSS: http://www.bing.com/HPImageArchive.aspx?format=rss&idx=0&n=1&mkt=en-US

El mktatributo obviamente, se puede cambiar a una región diferente a'En-US', pero también se puede optar por completo si no se preocupan por una región específica.

Tenga en cuenta que el _1366x768.jpgsufijo que se agrega a los nombres de las imágenes parece ser modificable en diferentes resoluciones (como _1920x1080.jpgpara Full HD y posiblemente otras).

Aquí hay un volcado de datos al 28/9/2013, en formato XML.

<?xml version="1.0" encoding="utf-8"?>
<images>
    <image>
        <startdate>20130928</startdate>
        <fullstartdate>201309280000</fullstartdate>
        <enddate>20130929</enddate>
        <url>/az/hprichbg/rb/LakeTurkana_EN-US15976511099_1366x768.jpg</url>
        <urlBase>/az/hprichbg/rb/LakeTurkana_EN-US15976511099</urlBase>
        <copyright>Lava rock pools at the southern end of Lake Turkana, in Kenya (© Nigel Pavitt/Corbis)</copyright>
        <copyrightlink>http://www.bing.com/search?q=Lake+Turkana%2C+Kenya&amp;form=hpcapt</copyrightlink>
        <drk>1</drk>
        <top>1</top>
        <bot>1</bot>
        <hotspots>
            <hotspot>
                <desc>These are the southern reaches of a lake...</desc>
                <link>http://www.bing.com/maps/?v=2&amp;cp=2.794725~37.335197&amp;lvl=7&amp;dir=0&amp;sty=b&amp;q=Lake%20Turkana%2C%20Kenya&amp;form=hphot1</link>
                <query>That stretches for 180 miles, up into another country</query>
                <LocX>15</LocX>
                <LocY>33</LocY>
            </hotspot>
            <hotspot>
                <desc>This body of water was once called the Jade Sea.</desc>
                <link>http://www.bing.com/search?q=green+algae&amp;form=hphot2</link>
                <query>What gives the water here its sometimes vibrant hue?</query>
                <LocX>37</LocX>
                <LocY>42</LocY>
            </hotspot>
            <hotspot>
                <desc>One of the world's most powerful predators lives here.</desc>
                <link>http://www.bing.com/videos/search?q=Underwater+Croc+Cams+National+Geographic&amp;FORM=hphot3#view=detail&amp;mid=D25E1909D3514A8732C5D25E1909D3514A8732C5</link>
                <query>See some rare underwater footage of the beast</query>
                <LocX>66</LocX>
                <LocY>33</LocY>
            </hotspot>
            <hotspot>
                <desc>Many fossils of ancient human ancestors have been uncovered in the surrounding area.</desc>
                <link>http://www.bing.com/search?q=Turkana+Boy&amp;form=hphot4</link>
                <query>One skeleton was so complete, paleoanthropologists gave him a name</query>
                <LocX>82</LocX>
                <LocY>41</LocY>
            </hotspot>
        </hotspots>
        <messages></messages>
    </image>
    <tooltips>
        <loadMessage>
            <message>Indlæser...</message>
        </loadMessage>
        <previousImage>
            <text>Forrige</text>
        </previousImage>
        <nextImage>
            <text>Næste</text>
        </nextImage>
        <play>
            <text>Afspil</text>
        </play>
        <pause>
            <text>Pause</text>
        </pause>
    </tooltips>
</images>

FORMATO JSON de BING IMAGE

Encontré una manera de obtener el formato JSON de la imagen de Bing del día

http://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1

Nota

      n=El número de imágenes que desea (puede usar números enteros ),
      mkt=su ubicación (ejemplo: en-US )

  {
  "images": [
    {
      "startdate": "20141214",
      "fullstartdate": "201412141830",
      "enddate": "20141215",
      "url": "\/az\/hprichbg\/rb\/BlackButte_EN-IN7038391888_1920x1080.jpg",
      "urlbase": "\/az\/hprichbg\/rb\/BlackButte_EN-IN7038391888",
      "copyright": "Black Butte, seen from the Mount Jefferson Wilderness, Oregon, USA (\u00a9 Marc Adamus\/Aurora Photos)",
      "copyrightlink": "http:\/\/www.bing.com\/search?q=Black+Butte&qs=n&form=hpcapt&mkt=en-in&pq=black+butte&sc=8-11&sp=-1&sk=&cvid=228ac7f125f94bbaafd4a4abd4f9a32d",
      "wp": true,
      "hsh": "94156ae1e2e1be49f9b739d2b7bff65c",
      "drk": 1,
      "top": 1,
      "bot": 1,
      "hs": [

      ],
      "msg": [
        {
          "title": "How does it feel\u2026",
          "link": "http:\/\/www.bing.com\/videos\/search?q=Climbing+Black+Butte&FORM=pgbar1&mkt=en-in#view=detail&mid=58BDB2F2B9FCB85D597558BDB2F2B9FCB85D5975",
          "text": "To climb 1961.7 m?"
        },
        {
          "title": "On top of the world",
          "link": "http:\/\/www.bing.com\/images\/search?q=Pictures+From+the+Top+of+Mount+Everest&FORM=pgbar2&mkt=en-in",
          "text": "It's mountaineer's dream view"
        }
      ]
    }
  ],
  "tooltips": {
    "loading": "Loading...",
    "previous": "Previous",
    "next": "Next",
    "walle": "This image is not available to download as wallpaper.",
    "walls": "Download this image. Use of this image is restricted to wallpaper only."
  }
}

utilizar el urlde laimages[]

y agregarlo a 'http://bing.com'

aquí la URL es "url": "\/az\/hprichbg\/rb\/DayGecko_EN-US8730336235_1366x768.jpg"

Microsoft ha publicado recientemente un tema dinámico de Bing para Windows 7, que contiene una fuente RSS con enlaces a fondos de pantalla de Bing .

También hay un script de Python que intenta cargar el sitio web de Bing y adivinar la URL de la imagen correcta, pero según mi experiencia, generalmente da como resultado una imagen de menor resolución que las ofrecidas por la fuente RSS.

Llego tarde a la fiesta, pero en caso de que alguien necesite una implementación de PHP: escribí una clase simple que maneja el procedimiento:

https://github.com/grubersjoe/bing-daily-photo

Un revestimiento PowerShell (3.0 o superior)

irm es un alias para Invoke-RestMethod

irm "bing.com$((irm "bing.com/HPImageArchive.aspx?format=js&mkt=en-IN&n=1").images[0].url)" -OutFile bing.jpg

También me gustan las imágenes de Bing, pero su aplicación está demasiado inflada para descargar imágenes. Después de analizar la conexión con Fiddler, escribí este código. El 1920x1200 viene con el logo de Bing incrustado, pero las resoluciones más bajas no lo tienen.

Puede hacer que Windows le muestre imágenes aleatorias de la carpeta de imágenes que configuró, de modo que a medida que las descargue a diario, le mostrará más imágenes aleatorias. Si mantiene el "imageDir", necesita cambiar los permisos en esa carpeta o se bloqueará, no me molesté en detectar errores. Por último, elimine los comentarios de las líneas si desea configurar su fondo de pantalla con la imagen de hoy o puede crear una tarea para ejecutar el programa, digamos un minuto después de iniciar sesión.

using System;
using System.IO;
using System.Net;
//using System.Runtime.InteropServices;

namespace Bing
{
    class Program
    {
      //  [DllImport("user32.dll", CharSet = CharSet.Auto)]
      //  private static extern Int32 SystemParametersInfo(UInt32 uiAction, UInt32 uiParam, String pvParam, UInt32 fWinIni);
        private static String imgDir = @"C:\Windows\Web\Wallpaper\Bing\";

        static void Main(string[] args)
        {
            String imageFileName;
            if (!Directory.Exists(imgDir))
                Directory.CreateDirectory(imgDir);

            for (byte i = 6; i >= 0; i--)
            {
                imageFileName = imgDir + DateTime.Today.AddDays(-i).ToString("yyy-MM-dd") + ".jpg";

                if (!File.Exists(imageFileName))
                {
                    string response = null;
                    Connect(ref response, i);
                    ProcessXml(ref response);
                    using (WebClient client = new WebClient())
                        client.DownloadFile("http://www.bing.com" + response + "_1920x1200.jpg", imageFileName);
                }                
            }
            //SystemParametersInfo(20, 0, imageFileName, 0x01 | 0x02);
        }

        private static void Connect(ref string res, byte i)
        {
            HttpWebRequest webrequest = (HttpWebRequest)WebRequest.Create("http://www.bing.com/hpimagearchive.aspx?format=xml&idx=" + i + "&n=1&mbl=1&mkt=en-ww");
            webrequest.KeepAlive = false;
            webrequest.Method = "GET";
            using (HttpWebResponse webresponse = (HttpWebResponse)webrequest.GetResponse())
                using (StreamReader loResponseStream = new StreamReader(webresponse.GetResponseStream()))
                    res = loResponseStream.ReadToEnd();                
        }

        private static void ProcessXml(ref string xmlString)
        {
            using (System.Xml.XmlReader reader = System.Xml.XmlReader.Create(new StringReader(xmlString)))
            {
                reader.ReadToFollowing("urlBase");
                xmlString = reader.ReadElementContentAsString();
            }
        }        
    }
}

Vi que muchas personas también están solicitando el nuevo enlace RSS, simplemente cambie el parámetro de formato en la URL a "rss".

RSS : http://www.bing.com/HPImageArchive.aspx?format=rss&idx=0&n=1&mkt=en-US

Este JavaScript responderá al 'qué hacer con la api' cambiando la imagen de fondo de un div al fondo de la imagen de bing del día actual.

function PullBackground() {
    var ajaxRequest = new XMLHttpRequest(), background = ''; 
    ajaxRequest.open('POST', "http://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=en-US", true);
    ajaxRequest.setRequestHeader("Connection", "close");
    ajaxRequest.send('');
    ajaxRequest.onreadystatechange = function () {
        if (ajaxRequest.readyState == 4) {
            background = ajaxRequest.responseText;
            var res = background.split("<url>"); 
            var res1 = res[1].split("</url>");
            background = res1[0];

            document.getElementById('NameOfTheDivToChange').style.backgroundImage = "url('http://bing.com" + background + "')"
            document.getElementById('NameOfTheDivToChange').style.backgroundSize = "100%";
        }
    }
}

En caso de que alguien esté buscando posibles implementaciones, escribí un pequeño programa de línea de comandos en C # para descargar, guardar y configurar mi fondo como la imagen de Bing del día. Siéntase libre de modificarlo según sus necesidades personales. https://github.com/josueespinosa/BingBackground

using Microsoft.Win32;
using Newtonsoft.Json;
using System;
using System.Drawing;
using System.IO;
using System.Net;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace BingBackground
{
    class BingBackground
    {
        private static void Main(string[] args)
        {
            string urlBase = GetBackgroundUrlBase();
            Image background = DownloadBackground(urlBase + GetResolutionExtension(urlBase));
            SaveBackground(background);
            SetBackground(background, PicturePosition.Fill);
        }

        private static dynamic DownloadJson()
        {
            using (WebClient webClient = new WebClient())
            {
                Console.WriteLine("Downloading JSON...");
                string jsonString = webClient.DownloadString("https://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-US");
                return JsonConvert.DeserializeObject<dynamic>(jsonString);
            }
        }

        private static string GetBackgroundUrlBase()
        {
            dynamic jsonObject = DownloadJson();
            return "https://www.bing.com" + jsonObject.images[0].urlbase;
        }

        private static string GetBackgroundTitle()
        {
            dynamic jsonObject = DownloadJson();
            string copyrightText = jsonObject.images[0].copyright;
            return copyrightText.Substring(0, copyrightText.IndexOf(" ("));
        }

        private static bool WebsiteExists(string url)
        {
            try
            {
                WebRequest request = WebRequest.Create(url);
                request.Method = "HEAD";
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                return response.StatusCode == HttpStatusCode.OK;
            }
            catch
            {
                return false;
            }
        }

        private static string GetResolutionExtension(string url)
        {
            Rectangle resolution = Screen.PrimaryScreen.Bounds;
            string widthByHeight = resolution.Width + "x" + resolution.Height;
            string potentialExtension = "_" + widthByHeight + ".jpg";
            if (WebsiteExists(url + potentialExtension))
            {
                Console.WriteLine("Background for " + widthByHeight + " found.");
                return potentialExtension;
            }
            else
            {
                Console.WriteLine("No background for " + widthByHeight + " was found.");
                Console.WriteLine("Using 1920x1080 instead.");
                return "_1920x1080.jpg";
            }
        }

        private static Image DownloadBackground(string url)
        {
            Console.WriteLine("Downloading background...");
            WebRequest request = WebRequest.Create(url);
            WebResponse reponse = request.GetResponse();
            Stream stream = reponse.GetResponseStream();
            return Image.FromStream(stream);
        }

        private static string GetBackgroundImagePath()
        {
            string directory = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures), "Bing Backgrounds", DateTime.Now.Year.ToString());
            Directory.CreateDirectory(directory);
            return Path.Combine(directory, DateTime.Now.ToString("M-d-yyyy") + ".bmp");
        }

        private static void SaveBackground(Image background)
        {
            Console.WriteLine("Saving background...");
            background.Save(GetBackgroundImagePath(), System.Drawing.Imaging.ImageFormat.Bmp);
        }

        private enum PicturePosition
        {
            Tile,
            Center,
            Stretch,
            Fit,
            Fill
        }

        internal sealed class NativeMethods
        {
            [DllImport("user32.dll", CharSet = CharSet.Auto)]
            internal static extern int SystemParametersInfo(int uAction, int uParam, string lpvParam, int fuWinIni);
        }

        private static void SetBackground(Image background, PicturePosition style)
        {
            Console.WriteLine("Setting background...");
            using (RegistryKey key = Registry.CurrentUser.OpenSubKey(Path.Combine("Control Panel", "Desktop"), true))
            {
                switch (style)
                {
                    case PicturePosition.Tile:
                        key.SetValue("PicturePosition", "0");
                        key.SetValue("TileWallpaper", "1");
                        break;
                    case PicturePosition.Center:
                        key.SetValue("PicturePosition", "0");
                        key.SetValue("TileWallpaper", "0");
                        break;
                    case PicturePosition.Stretch:
                        key.SetValue("PicturePosition", "2");
                        key.SetValue("TileWallpaper", "0");
                        break;
                    case PicturePosition.Fit:
                        key.SetValue("PicturePosition", "6");
                        key.SetValue("TileWallpaper", "0");
                        break;
                    case PicturePosition.Fill:
                        key.SetValue("PicturePosition", "10");
                        key.SetValue("TileWallpaper", "0");
                        break;
                }
            }
            const int SetDesktopBackground = 20;
            const int UpdateIniFile = 1;
            const int SendWindowsIniChange = 2;
            NativeMethods.SystemParametersInfo(SetDesktopBackground, 0, GetBackgroundImagePath(), UpdateIniFile | SendWindowsIniChange);
        }
    }
}

PowerShell simple, colóquelo en una carpeta, cree una tarea diaria en el Programador de tareas de Windows, el script guarda las imágenes en su carpeta de ejecución, luego, en la configuración de Fondo de escritorio, elija esa carpeta como fondo.

[xml]$doc = (New-Object System.Net.WebClient).DownloadString("https://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=ru-RU")
$url = $doc.images.image.url
$url = "https://www.bing.com/" + $url -replace "_1366x768","_1920x1200"

Write-Output $url

$fileName = Split-Path $url -leaf
$output = "$PSScriptRoot\$fileName"

$start_time = Get-Date
Invoke-WebRequest -Uri $url -OutFile $output
Write-Output "Saved to: $output Time taken: $((Get-Date).Subtract($start_time).Seconds) second(s)"

Aquí hay una secuencia de comandos de Python simple para obtener la foto de Bing del día usando solo requestsy json:

import requests
import json

BING_URI_BASE = "http://www.bing.com"
BING_WALLPAPER_PATH = "/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-US"

# open the Bing HPImageArchive URI and ask for a JSON response
resp = requests.get(BING_URI_BASE + BING_WALLPAPER_PATH)

if resp.status_code == 200:
    json_response = json.loads(resp.content)
    wallpaper_path = json_response['images'][0]['url']
    filename = wallpaper_path.split('/')[-1]
    wallpaper_uri = BING_URI_BASE + wallpaper_path

    # open the actual wallpaper uri, and write the response as an image on the filesystem
    response = requests.get(wallpaper_uri)
    if resp.status_code == 200:
        with open(filename, 'wb') as f:
            f.write(response.content)
    else:
        raise ValueError("[ERROR] non-200 response from Bing server for '{}'".format(wallpaper_uri))
else: 
    raise ValueError("[ERROR] non-200 response from Bing server for '{}'".format(BING_URI_BASE + BING_WALLPAPER_PATH))

Esto escribirá un archivo como TurtleTears_EN-US7942276596_1920x1080.jpgen el mismo directorio donde se ejecuta el script. Por supuesto, puede modificar un montón de cosas aquí, pero hace el trabajo con razonable facilidad.

Déjame decirte cómo obtener el fondo de pantalla diario de bing del día usando javascript y php,

Prueba este código js:

<script>
      fetch('https://techytricks97.000webhostapp.com/')
      .then(response => response.text())
      .then(text=>{document.body.style.background="url('"+text+"')";document.body.style.backgroundSize='cover';});
</script>

Este script establece la imagen diaria de bing del día como fondo de su documento html (puede modificarlo aún más según su uso).

Este enlace: https://techytricks97.000webhostapp.com devuelve el fondo de pantalla de Bing del día, todos los días.

fetch()obtiene la URL de la imagen de bing de hoy https://techytricks97.000webhostapp.comy la text=>{document.body.style.background="url('"+text+"')";document.body.style.backgroundSize='cover';}establece como fondo.

Nota: Microsoft no permite usar las imágenes de bing daily como fondo de su sitio, puede usarlas como fondo de pantalla del teléfono / escritorio, o en otras cosas con mención de derechos de autor.

Aquí está el código php que se utiliza en http://techytricks97.000webhostapp.com :

<?php
header('Access-Control-Allow-Origin: *');
ini_set('display_errors', 1);
$reg=file_get_contents('https://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-IN');
$reg=json_decode($reg);
$meka=$reg->images[0]->url;
echo('http://www.bing.com'.$meka);
?>

Puede usar http://techytricks97.000webhostapp.comsolo o puede configurar su propio archivo php en su servidor.

Otra nota: no utilicé solo javascript, porque la política del mismo origen del navegador lo restringe, pero la recuperación de mi archivo php está permitida, ya que puse header('Access-Control-Allow-Origin: *');mi código php. Podría haber usado otros proxies pero tienen mucho tráfico (mi sitio apenas recibe ningún clic en un día).

Si está utilizando cualquier otro idioma, solo tiene que leer este archivo ( http://techytricks97.000webhostapp.com )

Estaba teniendo problemas para obtener una fuente RSS adecuada que pudiera usar con el conmutador de fondo de John hasta que encontré esta fuente de feedburner que parece funcionar bastante bien: http://feeds.feedburner.com/bingimages

Eche un vistazo a bing-desktop-wallpaper-changer en Github . El script ha sido escrito en Python y espero que encuentres tu respuesta ahí.

#!/usr/bin/python
#-*- coding: utf-8 -*-

import os
import urllib
import urllib2
from bs4 import BeautifulSoup

# Get BingXML file which contains the URL of the Bing Photo of the day
# idx = Number days previous the present day. 0 means current day, 1 means       yesterday, etc
# n = Number of images predious the day given by idx
# mkt denotes your location. e.g. en-US means United States. Put in your  country code
BingXML_URL = "http://www.bing.com/HPImageArchive.aspx?     format=xml&idx=0&n=1&mkt=en-US"
page = urllib2.urlopen(BingXML_URL)
BingXML = BeautifulSoup(page, "lxml")

# For extracting complete URL of the image
Images = BingXML.find_all('image')
ImageURL = "https://www.bing.com" + Images[0].url.text
ImageName = Images[0].startdate.text+".jpg"

urllib.urlretrieve(ImageURL, ImageName)

Eche un vistazo al proyecto Github para obtener un código detallado

Finalmente decidí escribir un script en Python 3 para obtener la mayor cantidad de imágenes (16) del archivo xml.

Así que ahora puedo archivar las imágenes sin esfuerzo. Simplemente ejecute el script de Python.
Organizo las imágenes en carpetas Año / Mes como esta: 2018> 12 de diciembre> 2018-12-06.jpg

Este script va en mi carpeta Bing Wallpapers. (que está en mi carpeta Imágenes)

import urllib.request as urllib
import json
from datetime import date
from dateutil import parser
import sys,os

months = "January","Febuary","March","April","May","June","July","August","September","October","November","December"

def downloadBingImages(start):
    try: data = urllib.urlopen("https://www.bing.com/hpimagearchive.aspx?format=js&idx=%i&n=8&mkt=en-NZ"%start).read()
    except: sys.exit()
    e = json.loads(data.decode())
    images = e["images"]

    for image in images:
        d = parser.parse(image["startdate"]) # parse("20181206")

        filename = str(d.date())+".jpg"                         #                  2018-12-06.jpg
        folder = "%i/%i %s/"%(d.year,d.month,months[d.month-1]) # 2018/12 December/
        file = folder+filename                                  # 2018/12 December/2018-12-06.jpg

        if not os.path.exists(folder): os.makedirs(folder)
        exists = os.path.isfile(file)

        url = "https://www.bing.com"+image["urlbase"]+"_1920x1200.jpg"
        print(("downloading","exists")[exists],filename,url)
        if not exists:
            try: urllib.urlretrieve(url,file)
            except: sys.exit()

    print()

# downloads the 16 latest bing images
downloadBingImages(-1)
downloadBingImages(7)

Código adicional opcional para actualizar el fondo de pantalla: (poner debajo de downloadBingImages (7))

import ctypes,win32con

def getWallpaper():
    ubuf = ctypes.create_unicode_buffer(512)
    ctypes.windll.user32.SystemParametersInfoW(win32con.SPI_GETDESKWALLPAPER,len(ubuf),ubuf,0)
    return ubuf.value

def setWallpaper(path):
    changed = win32con.SPIF_UPDATEINIFILE | win32con.SPIF_SENDCHANGE
    ctypes.windll.user32.SystemParametersInfoW(win32con.SPI_SETDESKWALLPAPER,0,path,changed)

# update wallpaper after a week from current
wallpaper = getWallpaper()
if wallpaper.startswith(os.getcwd()): # has to be in script directory
    try: wallpaperDate = parser.parse(os.path.splitext(os.path.basename(wallpaper))[0])
    except: sys.exit() # not using an image with a parsable date

    t = date.today()
    if (t-wallpaperDate.date()).days>=7: # been a week or longer
        setWallpaper(os.path.abspath("%i/%i %s/"%(t.year,t.month,months[t.month-1])+str(t)+".jpg")) # .../2018/12 December/2018-12-14.jpg

ejemplo de salida:

exists 2018-12-15.jpg https://www.bing.com/az/hprichbg/rb/YosemiteBridge_ROW11493343707_1920x1200.jpg
exists 2018-12-14.jpg https://www.bing.com/az/hprichbg/rb/CardinalBerries_ROW13321753978_1920x1200.jpg
exists 2018-12-13.jpg https://www.bing.com/az/hprichbg/rb/ReykjavikYuleLads_ROW12406174277_1920x1200.jpg
exists 2018-12-12.jpg https://www.bing.com/az/hprichbg/rb/PoinsettiaBuds_ROW14015106672_1920x1200.jpg
exists 2018-12-11.jpg https://www.bing.com/az/hprichbg/rb/KilimanjaroMawenzi_ROW12001033920_1920x1200.jpg
exists 2018-12-10.jpg https://www.bing.com/az/hprichbg/rb/ChristmasIslandCrab_ROW12174154872_1920x1200.jpg
exists 2018-12-09.jpg https://www.bing.com/az/hprichbg/rb/JohnDaySnow_ROW10922424229_1920x1200.jpg
exists 2018-12-08.jpg https://www.bing.com/az/hprichbg/rb/BanffEvergreens_ROW13248925556_1920x1200.jpg

exists 2018-12-07.jpg https://www.bing.com/az/hprichbg/rb/TaisetsuShirakawago_ROW12053480529_1920x1200.jpg
exists 2018-12-06.jpg https://www.bing.com/az/hprichbg/rb/Huuhkajat_ROW11700922065_1920x1200.jpg
exists 2018-12-05.jpg https://www.bing.com/az/hprichbg/rb/SurfersBronteBeach_ROW9358782018_1920x1200.jpg
exists 2018-12-04.jpg https://www.bing.com/az/hprichbg/rb/SphinxObservatory_ROW9691446114_1920x1200.jpg
exists 2018-12-03.jpg https://www.bing.com/az/hprichbg/rb/HussarPoint_ROW8654856850_1920x1200.jpg
exists 2018-12-02.jpg https://www.bing.com/az/hprichbg/rb/Nuuk_ROW12381573676_1920x1200.jpg
exists 2018-12-01.jpg https://www.bing.com/az/hprichbg/rb/RedAntarctica_ROW12620598839_1920x1200.jpg
exists 2018-11-30.jpg https://www.bing.com/az/hprichbg/rb/KilchurnSky_ROW9474162800_1920x1200.jpg

PD: el script anterior se usa &mkt=en-NZpara las imágenes de Nueva Zelanda.
Puede consultar el código de mercado para otros países aquí .

También puede ver todas las imágenes archivadas desde 2009 para diferentes países aquí .
(aunque solo en 1366x768)

Mayor PS agrega el script al Programador de tareas para que se ejecute al iniciar sesión. (o diario / semanal)

Cree un
programa / script de tareas básicas : python (o C: \ Python34 \ python.exe si no está en su ruta de envio)
argumentos: "ruta / a / su / script.py"
comienza en: "ruta / a / su"

¡ACTUALIZAR! (Marzo de 2019)
La imagen para 2019-03-10 recibió una fecha de inicio incorrecta (20190309) en formato xml y rss.
Usando el formato Json en su lugar. (ya que da la fecha exacta)

https://peapix.com/bing/feedincluirá la última imagen de Bing sin el logotipo de Bing, mantenida por peapix.com . Compatible con los siguientes países / regiones: AU, CA, CN, DE, FR, JP, US, GB.

por ejemplo, https://peapix.com/bing/feed?country=jp para Japón y https://peapix.com/bing/feed?country=us para los Estados Unidos.

Bash one liner (necesita bash, curl y jq), útil para poner un cronjob:

BACKGROUND_META=$(curl 'https://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1&mkt=en-US'); curl -o $(echo $BACKGROUND_META | jq -r '.images[0].urlbase' | sed s/.*=//).jpg "https://bing.com$(echo $BACKGROUND_META| jq -r '.images[0].url')"

Puede considerar obtener el contenido de archivo de esa URL y buscar la imagen en el archivo. No estoy seguro de que sea la mejor forma, pero es una forma.

Usando la URL de @Siv, aquí hay un ejemplo de JavaScript que se actualiza <div class="bgimg" id="background">

function GetImageURL(ans) {
    var suffix = ans.images[0].url 
    document.getElementById("background").style.backgroundImage = 'url("' + 
    'http://bing.com/' + suffix + '"'
}

function GetJSON() {
    var xmlhttp = new XMLHttpRequest()
    var url = "https://www.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"

    xmlhttp.onreadystatechange = function () {
        if (this.readyState == 4 && this.status == 200) {
            var ans = JSON.parse(this.responseText);
            GetImageURL(ans);
        }
    };
    xmlhttp.open("GET", url, true);
    xmlhttp.send();
}


window.onload = function () {
    GetJSON()
}

El CSS de esta clase es:

.bgimg {
    height: 100%;
    position: relative;
    opacity: 0.95;
    background-position: center;
    background-repeat: no-repeat;
    background-size: cover;
}

Puede hacerlo usando python y wget en una máquina Linux:

import os # import the os package
os.system("wget -O index.html http://www.bing.com") # download the bing index
str1 = open('index.html', 'r').read() # extract the file path using split
str2=str1.split("g_img={url: \"")[1]
str3=str2.split(".jpg")[0]
os.system("wget -O daily_im.jpg http://www.bing.com" + str3 + ".jpg") # donwload the daily image

Descarga el fondo diario de bing en el directorio local con el nombre daily_im.jpg. Puede poner todo en un script.py e iniciarlo mediante programación.

EDITAR 27/09/2018: http://www.istartedsomething.com/bingimages responde 404 durante semanas. Puede que ya no exista. :-(

Puede utilizar el archivo de imágenes de Bing de istartedsomething.com . Es un archivo de imágenes de Bing no oficial. Utiliza un punto final casero que es útil para recuperar imágenes:

GET /bingimages/getimage.php?id=<image_id>

ides una cadena que contiene la fecha en que se publicó la imagen y el país donde se publicó. idtiene que cumplir con el siguiente formato:, YYYYMMDD-xxdonde:

• YYYY es el año, escrito con cuatro dígitos.
• MM es el mes, escrito con dos dígitos.
• DD es el día, escrito con dos dígitos.
• xxes el indicador de país. Bing Image Archive actualmente es compatible con los siguientes países:
  • au: Australia.
  • br: Brasil.
  • ca: Canadá.
  • cn: China.
  • de: Deutschland.
  • fr: Francia.
  • gb: Gran Bretaña.
  • jp: Japón.
  • nz: Nueva Zelanda.
  • uk: Reino Unido.
  • us: Estados Unidos de America.

Devuelve un objeto JSON útil si tiene alguna información o falso si no tiene nada.

Ejemplo 1: recuperar la imagen diaria de Bing que se publicó el 24 de mayo de 2014 en Nueva Zelanda

La identificación de la imagen se 20140524-nzdebe a que la imagen demandada se publicó el 24/05/2014 y se publicó en Nueva Zelanda, cuyo indicador de país es nz.

http://www.istartedsomething.com/bingimages/getimage.php?id=20140524-nz devuelve la siguiente pieza de JSON:

{
    "url":"\/az\/hprichbg\/rb\/LakeMagadiFlamingos_ROW9792683076_1366x768.jpg",
    "region":"nz",
    "date":"2014-05-24",
    "copyright":"Flamingos take flight, Lake Magadi, Kenya (\u00a9 Bobby Haas\/Getty Images)(Bing New Zealand)",
    "imageurl":"http:\/\/www.istartedsomething.com\/bingimages\/cache\/LakeMagadiFlamingos_ROW9792683076_1366x768.jpg",
    "hotspots":[],
    "video":[]
}

Puede utilizar el imageurlcampo o el campo url(Ruta URL de Bing) para obtener su imagen.

Ejemplo 2: recuperación de la imagen diaria de Bing que se publicó el 12 de julio de 1998 en Francia

La identificación de la imagen se 19980712-frdebe a que la imagen solicitada se publicó el 12/07/1998 y se publicó en Francia, cuyo indicador de país es fr.

http://www.istartedsomething.com/bingimages/getimage.php?id=19980712-fr regresa falseporque no hay una imagen diaria de Bing para Francia el 12/07/1998 (Bing ni siquiera existía en este momento).

OP no especifica el sistema operativo, por lo que aquí hay uno para usar en Linux. Modifiqué el script que se ofrece aquí. .

Básicamente, obtiene la URL de la imagen del día, descarga la imagen y la guarda en un archivo fijo ~/.config/wallpaper.jpg, y la usa fehpara configurar el fondo de pantalla. Al mismo tiempo envía una notificación.

#!/bin/sh

WP_FILE=$HOME/.config/wallpaper.jpg

bing="www.bing.com"

# $xmlURL is needed to get the xml data from which
# the relative URL for the Bing pic of the day is extracted
#
# The mkt parameter determines which Bing market you would like to
# obtain your images from.
# Valid values are: en-US, zh-CN, ja-JP, en-AU, en-UK, de-DE, en-NZ, en-CA or opted out.
#
# The idx parameter determines where to start from. 0 is the current day,
# 1 the previous day, etc.
xmlURL="http://www.bing.com/HPImageArchive.aspx?format=xml&idx=0&n=1&mkt=en-US"

# The desired Bing picture resolution to download
# Valid options: "_1024x768" "_1280x720" "_1366x768" "_1920x1200"
desiredPicRes="_1920x1080"

# The file extension for the Bing pic
picExt=".jpg"

# Extract the relative URL of the Bing pic of the day from
# the XML data retrieved from xmlURL, form the fully qualified
# URL for the pic of the day, and store it in $picURL

# Form the URL for the desired pic resolution
desiredPicURL=$bing$(curl -s $xmlURL | grep -oP "(?<=<urlBase>)(.*?)(?=</urlBase>)")$desiredPicRes$picExt

# Form the URL for the default pic resolution
defaultPicURL=$bing$(curl -s $xmlURL | grep -oP "(?<=<url>)(.*?)(?=</url>)")

# $picName contains the filename of the Bing pic of the day

# Attempt to download the desired image resolution. If it doesn't
# exist then download the default image resolution
if wget --quiet --spider "$desiredPicURL"
then

    # Download the Bing pic of the day at desired resolution
    curl -s -o "$WP_FILE" "$desiredPicURL"
else
    # Download the Bing pic of the day at default resolution
    curl -s -o "$WP_FILE" "$defaultPicURL"
fi

if [[ -f "${WP_FILE}" ]]; then
    feh --bg-scale "$WP_FILE" && \
        notify-send -i emblem-photos "Wallpaper" "Wallpaper changed" \
        -h int:suppress-sound:1 -h int:transient:1
fi