Madame de Pompadour didn’t just share King Louis XV ‘s bed, she also shared his power. As the most commanding mistress in the French court, she bettered the lives of many and became a beloved figure in European history and pop culture. But what do we really know about this fascinating woman? How did she gain the eye of the king? More importantly, how did she keep it? This is the entrancing tale of Madame de Pompadour.
Madame de Pompadour Facts
1. She was Destined to Make History
The woman who would become Madame de Pompadour entered the world as little Jeanne Antoinette Poisson. Born on December 29, 1721, she began life as a regular girl—but fate had other plans in store. When Pompadour was young, her mother took her to a fortune teller. The seer allegedly foretold that Pompadour “would one day reign over the heart of a king”. Pompadour would fulfill that prophecy, but her path to the top would be anything but smooth.
2. Her Father was a Criminal
A terrible scandal emerged when Pompadour was only a young girl. It turned out that her father, Francois Poisson, was deeply in debt. Desperate, the doomed financier went into exile in 1725 and couldn’t come home until the charges were cleared eight long years later. Frankly, though, he should’ve counted himself lucky. At the time, failure to pay debts carried the death penalty.
3. Her Legacy is Scandalous
Madame de Pompadour’s amorous legacy is alive and well even to this day. According to one long-standing legend, Louis XV based the shape of the French champagne glass, also known as the coupe , on a scandalous part of his mistress. He apparently modelled the decadent glass on the size and shape of his mistress’ breast.
{"4":"<h2>4. She Earned an Ominous Nickname<\/h2>\n<p>When Jeannette Poisson was young, she gained a suggestive nickname that would stay with her for the rest of her eventful life: Reinette, which means \u201clittle queen\u201d. For anyone else, this moniker would be a coy joke, but not Madame de Pompadour. As we&#8217;ll see, she would hold incredible power in the French court, effectively reigning even if she didn&#8217;t have a crown.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 892px\"><div class=\"media-credit-container alignnone\" style=\"width: 892px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567581\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2.jpg\" alt=\"Madame de Pompadour facts\" width=\"892\" height=\"678\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2.jpg 892w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2-768x584.jpg 768w\" sizes=\"(max-width: 892px) 100vw, 892px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567581\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2.jpg\" alt=\"Madame de Pompadour facts\" width=\"892\" height=\"678\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2.jpg 892w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_2-768x584.jpg 768w\" sizes=\"(max-width: 892px) 100vw, 892px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Franois_Boucher_-_La_Marquise_de_Pompadour.JPG\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","5":"<h2>5. She was a Beauty<\/h2>\n<p>How did Pompadour catch the French king&#8217;s eye? The answer is simple: She was beautiful. Pompadour had a stunning figure, and her face was even more eye-catching. Her blonde hair, blue eyes, alabaster skin, and rosy cheeks immediately entranced King Louis XV. But the way that she kept his interest for twenty long years?<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> That involved far more than just a pretty face.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 955px\"><div class=\"media-credit-container alignnone\" style=\"width: 955px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-251732\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour.jpg\" alt=\"History\u2019s Greatest Mistresses quiz\" width=\"955\" height=\"768\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour.jpg 955w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour-300x241.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour-768x618.jpg 768w\" sizes=\"(max-width: 955px) 100vw, 955px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-251732\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour.jpg\" alt=\"History\u2019s Greatest Mistresses quiz\" width=\"955\" height=\"768\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour.jpg 955w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour-300x241.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/02\/Fran\u00e7ois_Boucher_019_Madame_de_Pompadour-768x618.jpg 768w\" sizes=\"(max-width: 955px) 100vw, 955px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Franois_Boucher_019_(Madame_de_Pompadour).jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","6":"<h2>6. But She Also Had Brains<\/h2>\n<p>Pompadour was also whip smart. The future mistress received the best education a young girl could get at an Ursuline convent, with even the philosopher Voltaire admitting that he was impressed by how much she&#8217;d read. However, young Pompadour&#8217;s training wouldn&#8217;t last for long.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> Four years after her arrival, she caught such a dangerous bout of whooping cough that she had no choice but to go back home, where her mother&#8217;s disturbing plan kicked into gear.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 900px\"><div class=\"media-credit-container alignnone\" style=\"width: 900px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-240413\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4.jpg\" alt=\"Catherine The Great Quiz\" width=\"900\" height=\"699\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4.jpg 900w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4-300x233.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4-768x596.jpg 768w\" sizes=\"(max-width: 900px) 100vw, 900px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-240413\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4.jpg\" alt=\"Catherine The Great Quiz\" width=\"900\" height=\"699\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4.jpg 900w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4-300x233.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/01\/FotoJet-4-768x596.jpg 768w\" sizes=\"(max-width: 900px) 100vw, 900px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Nicolas_de_Largillire,_Franois-Marie_Arouet_dit_Voltaire_(vers_1724-1725)_-001.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","7":"<h2>7. She had a Wealthy Benefactor<\/h2>\n<p>When little Pompadour became ill and rushed home to recover, a mysterious man stepped in to help the young girl:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> the handsome tax collector Le Normant de Tournehem. After Pompadour\u2019s criminal father was exiled from the country, it was Tournehem who became her legal guardian. He also hired expensive tutors to educate Pompadour at home. But some say he didn&#8217;t do so just out of the goodness of his heart&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567597\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"608\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5-768x584.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567597\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"608\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_5-768x584.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Charles_Franois_Paul_Le_Normant_de_Tournehem#\/media\/File:Le_Normant_de_Tournehem.jpg\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","8":"<h2>8. Dark Rumors Swirled About Her<\/h2>\n<p>Because of Le Normant de Tournehem\u2019s devotion and care for Pompadour, a dark rumor emerged. According to the gossip on the streets of France, Le Normant wasn&#8217;t just a family friend.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> He was actually Pompadour&#8217;s biological father. While this claim could very well be idle speculation or even slander against Pompadour, it would explain Le Normant&#8217;s strangely generous treatment of the young girl&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567607\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"571\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o-300x214.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o-768x548.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567607\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"571\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o-300x214.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/2657466947_59f75cb3f2_o-768x548.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.flickr.com\/photos\/sacheverelle\/2657466947\">Flickr, Sacheverelle<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","9":"<h2>9. Her Birth was Mysterious<\/h2>\n<p>Apparently, Madame de Pompadour&#8217;s mom got around. It turns out that the little girl didn&#8217;t have just two contenders for her biological father.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> She had<em> three.<\/em> Pompadour&#8217;s godfather Jean P\u00e2ris may have also gotten it on with Mrs. Poisson and been Pompadour&#8217;s actual dad.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567608\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"609\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1-768x585.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567608\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"609\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1-300x228.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean_P\u00e2ris_de_Montmartel_-_1-768x585.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Jean_Pris_de_Monmartel\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n<div class=\"newsletter-signup-wrapper\">\n    <div class=\"col-md-8 col-sm-6 col-xs-6 newsletter-content-wrapper\">\n        <div class=\"col-md-2 col-sm-2 col-xs-2 no-padding newsletter-logo-wrapper\">\n            <div class=\"newsletter-signup-logo\">\n                <img class=\"lazy lazy-hidden\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/themes\/hood-theme\/assets\/img\/newsletter-logo.png\" \/><noscript><img src=\"https:\/\/www.factinate.com\/wp-content\/themes\/hood-theme\/assets\/img\/newsletter-logo.png\" \/><\/noscript>\n            <\/div>\n        <\/div>\n        <div class=\"col-md-4\">\n            <div class=\"newsletter-signup-title\">Sign up to our newsletter.<\/div>\n        <\/div>\n        <div class=\"col-md-6 col-sm-10 col-xs-10 newsletter-signup-text-wrapper\">\n            <div class=\"newsletter-signup-text\">History\u2019s most fascinating stories and darkest secrets, delivered to your inbox daily. Making distraction rewarding since 2017.<\/div>\n        <\/div>\n    <\/div>\n    <div class=\"col-md-4 col-sm-6 col-xs-6 newsletter-form-wrapper\">\n        <div class=\"newsletter-signup-form\">\n            <form action=\"https:\/\/factinate.us17.list-manage.com\/subscribe\/post-json?u=3989e65fd8daf9f4acfb349a4&id=4e13e72cb8&c=?\" class=\"subscribe_forms\" id=\"mc-embedded-subscribe-form\" name=\"mc-embedded-subscribe-form\" method=\"post\">\n                <input type=\"hidden\" name=\"mc_signupsource\" value=\"hosted\">\n                <div class=\"mc4wp-form-fields\">\n                    <div class=\"flytap-subscribe\">\n                        <p class=\"form-fields\">\n                            <input type=\"email\" placeholder=\"Enter Email\" class=\"mailchimp_email\" autocapitalize=\"off\" autocorrect=\"off\" required=\"required\" name=\"EMAIL\" id=\"EMAIL\" size=\"25\" value=\"\">\n                            <input type=\"submit\" class=\"formEmailButton mailchimp_submit\" name=\"submit\" value=\"SUBSCRIBE\">\n                        <\/p>\n                        <p class=\"subscribe-notice\"><\/p>\n                    <\/div>\n                <\/div>\n            <\/form>\n        <\/div>\n    <\/div>\n<\/div>","10":"<h2>10. Her Husband was Loaded<\/h2>\n<p>When Pompadour was 19 years old, her guardian and possibly her secret father, Le Normant de Tournehem, came to her with a proposition. When it came time for Pompadour to wed, he had just the man in mind:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> His nephew, the handsome financier Charles Guillaume Le Normant d\u2019Etiolles. The young couple was perfect on paper, but in practice, things wouldn&#8217;t be so rosy&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567609\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"637\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray-300x239.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray-768x612.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567609\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"637\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray-300x239.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Charles_le_Normant_du_Coudray-768x612.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Charles_Guillaume_Le_Normant_dtiolles#\/media\/File:Charles_le_Normant_du_Coudray.jpg\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","11":"<h2>11. She Aimed High<\/h2>\n<p>Apparently, Charles was absolutely besotted with his new bride. For a time, Pompadour returned his passion. From the get go, she said she&#8217;d never leave her husband&#8230;except for one man:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> the King. Poor Charles probably thought his wife was daydreaming. But in a few years, he&#8217;d learn not to doubt Pompadour when she put her mind to something, no matter how grand.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 2560px\"><div class=\"media-credit-container alignnone\" style=\"width: 2560px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567610\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-scaled.jpg\" alt=\"Madame de Pompadour facts\" width=\"2560\" height=\"2001\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-300x235.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-1024x801.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-768x600.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-1536x1201.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-2048x1601.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567610\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-scaled.jpg\" alt=\"Madame de Pompadour facts\" width=\"2560\" height=\"2001\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-300x235.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-1024x801.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-768x600.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-1536x1201.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/GettyImages-534304766-2048x1601.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.gettyimages.com\/\">Getty Images <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","12":"<h2>12. Her Mother was Callous<\/h2>\n<p>Here&#8217;s the thing: Pompadour wasn&#8217;t crazy for setting her sights on the king.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> Ever since little Jeanne Poisson came home from the convent, her mother had transformed from caregiver into a dicey blend of pimp and momager. She began to train her daughter for one purpose and one purpose alone: to be the king\u2019s ideal mistress. Tournehem called her \u201ca morsel fit for a king\u201d.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 834px\"><div class=\"media-credit-container alignnone\" style=\"width: 834px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567611\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1.png\" alt=\"Madame de Pompadour facts\" width=\"834\" height=\"567\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1.png 834w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1-300x204.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1-768x522.png 768w\" sizes=\"(max-width: 834px) 100vw, 834px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567611\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1.png\" alt=\"Madame de Pompadour facts\" width=\"834\" height=\"567\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1.png 834w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1-300x204.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991100-1-768x522.png 768w\" sizes=\"(max-width: 834px) 100vw, 834px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","13":"<h2>13. Drama Followed Her Wherever She Went<\/h2>\n<p>Charles and Pompadour&#8217;s marriage was controversial from the very beginning.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> Charles&#8217; uncle and Pompadour&#8217;s guardian\/secret dad, Le Normant de Tournehem sweetened the deal by making Charles his sole heir. Pompadour wouldn&#8217;t just marry anyone; she&#8217;d marry a loaded young man. But in order to do so, Le Normant ruthlessly removed all his other nieces and nephews from his will.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> You can bet that didn&#8217;t go down well in the Tourneham family.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 869px\"><div class=\"media-credit-container alignnone\" style=\"width: 869px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567613\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1.png\" alt=\"Madame de Pompadour facts\" width=\"869\" height=\"554\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1.png 869w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1-300x191.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1-768x490.png 768w\" sizes=\"(max-width: 869px) 100vw, 869px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567613\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1.png\" alt=\"Madame de Pompadour facts\" width=\"869\" height=\"554\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1.png 869w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1-300x191.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991101-1-768x490.png 768w\" sizes=\"(max-width: 869px) 100vw, 869px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","14":"<h2>14. She Rose to the Top<\/h2>\n<p>Pompadour was a bright child, but her reputation for being a witty woman didn\u2019t truly emerge until she became a regular member of French salons. These were the social hubs of the day and they allowed the future mistress to discuss philosophy and, of course, pick up the day&#8217;s hot gossip.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> In time, Pompadour rose to the top of the salons, despite her lowborn roots. She hosted an esteemed salon at Etiolles, her husband&#8217;s family&#8217;s estate, where she chatted with figures like the philosopher Voltaire.<\/p>\n<p>But even though Pompadour&#8217;s social life was flourishing, her personal life was a relentless tragedy.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 811px\"><div class=\"media-credit-container alignnone\" style=\"width: 811px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567616\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o.jpg\" alt=\"Madame de Pompadour facts\" width=\"811\" height=\"643\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o.jpg 811w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o-300x238.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o-768x609.jpg 768w\" sizes=\"(max-width: 811px) 100vw, 811px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567616\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o.jpg\" alt=\"Madame de Pompadour facts\" width=\"811\" height=\"643\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o.jpg 811w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o-300x238.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/15277582074_818e1a1b8e_o-768x609.jpg 768w\" sizes=\"(max-width: 811px) 100vw, 811px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.flickr.com\/photos\/dalbera\/15277582074\">Flickr, Jean-Pierre Dalb\u00e9ra<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","15":"<h2>15. She Endured the Worst<\/h2>\n<p>Pompadour and her husband, Charles Guillaume, had a brutal marriage almost from the get go. They had two children together, but tragically, both of them died while they were still very young. Their little son passed away just a year after his birth and their daughter, Alexandrine Le Normant D\u2019Etiolles, died of a stomach illness in 1755. She was nine years old.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1884px\"><div class=\"media-credit-container alignnone\" style=\"width: 1884px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567622\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch.jpg\" alt=\"Madame de Pompadour facts\" width=\"1884\" height=\"1422\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch.jpg 1884w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-300x226.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-1024x773.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-768x580.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-1536x1159.jpg 1536w\" sizes=\"(max-width: 1884px) 100vw, 1884px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567622\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch.jpg\" alt=\"Madame de Pompadour facts\" width=\"1884\" height=\"1422\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch.jpg 1884w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-300x226.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-1024x773.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-768x580.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Portrait_of_Alexandrine_Le_Normant_d\u00c9tiolles_daughter_of_Madame_de_Pompadour_playing_with_a_Goldfinch-1536x1159.jpg 1536w\" sizes=\"(max-width: 1884px) 100vw, 1884px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Alexandrine_Le_Normant_dtiolles#\/media\/File:Portrait_of_Alexandrine_Le_Normant_d\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","16":"<h2>16. She was Determined to Ensnare the King<\/h2>\n<p>Pompadour first tried to get the attention of her future beau King Louis XV with a show-stopping gesture. In 1744, the king went on a hunting expedition at Pompadour&#8217;s estate, allowing her to follow his entourage from a distance. But holding back didn&#8217;t satisfy a girl like Pompadour.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> She purposefully rode in the king\u2019s path several times and to make doubly sure that he couldn\u2019t miss her, she wore differently colored outfits each time. Subtle!<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 951px\"><div class=\"media-credit-container alignnone\" style=\"width: 951px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-544842\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"951\" height=\"540\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3.jpg 951w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3-300x170.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3-768x436.jpg 768w\" sizes=\"(max-width: 951px) 100vw, 951px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-544842\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"951\" height=\"540\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3.jpg 951w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3-300x170.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_12-3-768x436.jpg 768w\" sizes=\"(max-width: 951px) 100vw, 951px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","17":"<h2>17. She had Competition for Louis&#8217; Heart<\/h2>\n<p>No one becomes the king&#8217;s chief mistress overnight, and Madame de Pompadour learned this the hard way.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> In 1744, the main obstacle blocking her from King Louis XV\u2019s bed was a rival named Madame de Chateauroux, who was already the apple of Louis&#8217; eye. Naturally, she tried to prevent Louis from getting too close to Pompadour. But the rivalry between Pompadour and Chateauroux ended in an utterly brutal fashion.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 829px\"><div class=\"media-credit-container alignnone\" style=\"width: 829px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-525147\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"829\" height=\"635\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle.jpg 829w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle-300x230.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle-768x588.jpg 768w\" sizes=\"(max-width: 829px) 100vw, 829px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-525147\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"829\" height=\"635\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle.jpg 829w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle-300x230.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Marie-Anne_de_Mailly-Nesle-768x588.jpg 768w\" sizes=\"(max-width: 829px) 100vw, 829px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Marie_Anne_de_Mailly-Nesle#\/media\/File:Marie-Anne_de_Mailly-Nesle.jpg\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","18":"<h2>18. Her Rival Met a Brutal End<\/h2>\n<p>In December of 1744, Madame de Chateauroux entered Versailles and began to emit blood-curdling screams. She fell to her knees and convulsed because the pain in her stomach was so intense. It didn&#8217;t take long for the king&#8217;s mistress to die. To this day, no one knows what caused Chateuroux&#8217;s demise, but she went to the grave insisting on a dark explanation:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> She firmly believed that she had been poisoned.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 893px\"><div class=\"media-credit-container alignnone\" style=\"width: 893px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-461508\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1.jpg\" alt=\"Louis XV facts\" width=\"893\" height=\"551\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1.jpg 893w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1-300x185.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1-768x474.jpg 768w\" sizes=\"(max-width: 893px) 100vw, 893px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-461508\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1.jpg\" alt=\"Louis XV facts\" width=\"893\" height=\"551\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1.jpg 893w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1-300x185.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-20-1-768x474.jpg 768w\" sizes=\"(max-width: 893px) 100vw, 893px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","19":"<h2>19. One Paper Changed her Life<\/h2>\n<p>In 1745, one piece of paper would change Pompadour&#8217;s life forever. She received an invitation to a masked ball at the Palace of Versailles, proving that her overt flirting at the king&#8217;s hunt had worked its magic. The ball celebrated the wedding of the Dauphin Louis to Maria Teresa of Spain, but for Louis, the main event was Madame de Pompadour.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p><\/p>\n<p>In an effort to stay away from prying eyes, the king and several courtiers dressed in identical yew tree costumes so that Louis could walk around without being bothered. But his clever costume had nothing on Pompadour&#8217;s&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 823px\"><div class=\"media-credit-container alignnone\" style=\"width: 823px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-461558\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj.jpg\" alt=\"Louis XV facts\" width=\"823\" height=\"537\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj.jpg 823w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj-300x196.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj-768x501.jpg 768w\" sizes=\"(max-width: 823px) 100vw, 823px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-461558\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj.jpg\" alt=\"Louis XV facts\" width=\"823\" height=\"537\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj.jpg 823w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj-300x196.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/jhbj-768x501.jpg 768w\" sizes=\"(max-width: 823px) 100vw, 823px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","20":"<h2>20. She Always Got her Way<\/h2>\n<p>Pompadour attended the masked ball in a saucy costume.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> She dressed as Diana, the Roman goddess of the hunt, referencing how she\u2019d first pursued the king on his hunting trip. We can assume that Louis appreciated her suggestive clothing. At the ball, he unmasked himself to her and publicly declared his affection for Madame de Pompadour.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1551px\"><div class=\"media-credit-container alignnone\" style=\"width: 1551px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567629\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746.jpg\" alt=\"Madame de Pompadour facts\" width=\"1551\" height=\"1164\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746.jpg 1551w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-300x225.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-1024x768.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-768x576.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-1536x1153.jpg 1536w\" sizes=\"(max-width: 1551px) 100vw, 1551px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567629\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746.jpg\" alt=\"Madame de Pompadour facts\" width=\"1551\" height=\"1164\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746.jpg 1551w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-300x225.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-1024x768.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-768x576.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Jean-Marc_Nattier_Madame_de_Pompadour_en_Diane_1746-1536x1153.jpg 1536w\" sizes=\"(max-width: 1551px) 100vw, 1551px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Madame_de_Pompadour#\/media\/File:Jean-Marc_Nattier,_Madame_de_Pompadour_en_Diane_(1746).jpg\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","21":"<h2>21. She Made a Scandalous Move<\/h2>\n<p>Pompadour became the king\u2019s official mistress by March of 1745, when she took up her abode in the Palace of Versailles. Her apartment was right above the king\u2019s own chambers, in case anyone was confused by her reasons for being there.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 2560px\"><div class=\"media-credit-container alignnone\" style=\"width: 2560px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-516221\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057.jpg\" alt=\"Versailles Facts\" width=\"2560\" height=\"1707\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-300x200.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-1024x683.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-768x512.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-1536x1024.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-2048x1366.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-516221\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057.jpg\" alt=\"Versailles Facts\" width=\"2560\" height=\"1707\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-300x200.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-1024x683.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-768x512.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-1536x1024.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/06\/2560px-Chateau_de_Versailles_Petit_appartement_du_roi_057-2048x1366.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Chateau_de_Versailles_Petit_appartement_du_roi_057.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","22":"<h2>22. Her Step-Kids Hated Her<\/h2>\n<p>King Louis XV&#8217;s kids were not thrilled that Pompadour had moved into the palace and they weren&#8217;t shy about who knew it.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> They called her, and I quote, \u201cMommy Whore\u201d.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 923px\"><div class=\"media-credit-container alignnone\" style=\"width: 923px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567634\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6.jpg\" alt=\"Madame de Pompadour facts\" width=\"923\" height=\"506\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6.jpg 923w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6-300x164.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6-768x421.jpg 768w\" sizes=\"(max-width: 923px) 100vw, 923px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567634\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6.jpg\" alt=\"Madame de Pompadour facts\" width=\"923\" height=\"506\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6.jpg 923w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6-300x164.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_6-768x421.jpg 768w\" sizes=\"(max-width: 923px) 100vw, 923px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","23":"<h2>23. Her Spouse was Ticked<\/h2>\n<p>Pompadour was thrilled that she&#8217;d become the king&#8217;s mistress. However, her husband, Charles Guillaume le Normant, didn&#8217;t feel the same. He adored his bride and was deeply upset that she&#8217;d set her sights on another.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> Apparently, when he heard that she was planning to leave him, he fell to the ground in shock. Charles thought things couldn&#8217;t get worse, but he was wrong.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 933px\"><div class=\"media-credit-container alignnone\" style=\"width: 933px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567636\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1.png\" alt=\"Madame de Pompadour facts\" width=\"933\" height=\"557\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1.png 933w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1-768x458.png 768w\" sizes=\"(max-width: 933px) 100vw, 933px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567636\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1.png\" alt=\"Madame de Pompadour facts\" width=\"933\" height=\"557\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1.png 933w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991102-1-768x458.png 768w\" sizes=\"(max-width: 933px) 100vw, 933px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","24":"<h2>24. Everyone Betrayed Him<\/h2>\n<p>Another ugly betrayal quickly reared its head. As though his wife dumping him wasn&#8217;t bad enough, Charles&#8217; own family wasn&#8217;t exactly sympathetic to his heartbreak.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> In fact, Charles&#8217; father approved of Pompadour\u2019s social climbing! He even gave his cheating daughter-in-law his personal blessing to leave Charles and pursue the King. Ouch&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 931px\"><div class=\"media-credit-container alignnone\" style=\"width: 931px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567637\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1.png\" alt=\"Madame de Pompadour facts\" width=\"931\" height=\"557\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1.png 931w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1-768x459.png 768w\" sizes=\"(max-width: 931px) 100vw, 931px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567637\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1.png\" alt=\"Madame de Pompadour facts\" width=\"931\" height=\"557\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1.png 931w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991103-1-768x459.png 768w\" sizes=\"(max-width: 931px) 100vw, 931px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","25":"<h2>25. She Endured a Bitter Parting<\/h2>\n<p>Charles stayed furious at Pompadour&#8217;s betrayal for years. He never forgave her for preferring the French king, and he made sure everyone knew it.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> When King Louis XV offered Charles a prestigious position as the French Ambassador to Turkey, Charles stunned everyone by refusing the appointment. He interpreted the offer not as an olive branch but a convenient way to get him away from France, so that Pompadour and Louis could enjoy their affair without his lurking presence.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 928px\"><div class=\"media-credit-container alignnone\" style=\"width: 928px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567639\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1.png\" alt=\"Madame de Pompadour facts\" width=\"928\" height=\"562\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1.png 928w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1-300x182.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1-768x465.png 768w\" sizes=\"(max-width: 928px) 100vw, 928px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567639\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1.png\" alt=\"Madame de Pompadour facts\" width=\"928\" height=\"562\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1.png 928w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1-300x182.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991104-1-768x465.png 768w\" sizes=\"(max-width: 928px) 100vw, 928px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","26":"<h2>26. Her Ex was Furious<\/h2>\n<p>When Charles refused to give up his wife, King Louis started playing dirty. He set up a legal separation so that his new mistress could officially leave her unwilling husband. But don&#8217;t feel too bad for Charles. When he nursed his wounds, he imitated his enemy, the King, by enjoying several affairs.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> In time, he got the happy ending he wanted when he settled down with a famous dancer.<\/p>\n<p>This is where Charles drops out of history&#8230;and where Pompadour&#8217;s story kicks into high gear.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 938px\"><div class=\"media-credit-container alignnone\" style=\"width: 938px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567640\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1.png\" alt=\"Madame de Pompadour facts\" width=\"938\" height=\"561\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1.png 938w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1-768x459.png 768w\" sizes=\"(max-width: 938px) 100vw, 938px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567640\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1.png\" alt=\"Madame de Pompadour facts\" width=\"938\" height=\"561\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1.png 938w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1-300x179.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991105-1-768x459.png 768w\" sizes=\"(max-width: 938px) 100vw, 938px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","27":"<h2>27. Her Private Matters Made Their Way Into the Public<\/h2>\n<p>From 1755 to 1881, the British Army had a regiment called the 56th Regiment of Foot, also known as the West Essex.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> Their purple uniforms gained them the nickname the \u201cPompadours\u201d apparently because it had been her favorite color. But apparently, there&#8217;s a hidden meaning to the hue: It wasn&#8217;t just Pompadour&#8217;s favorite color, it was the color of her undergarments.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 878px\"><div class=\"media-credit-container alignnone\" style=\"width: 878px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567641\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7.jpg\" alt=\"Madame de Pompadour facts\" width=\"878\" height=\"533\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7.jpg 878w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7-300x182.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7-768x466.jpg 768w\" sizes=\"(max-width: 878px) 100vw, 878px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567641\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7.jpg\" alt=\"Madame de Pompadour facts\" width=\"878\" height=\"533\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7.jpg 878w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7-300x182.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_7-768x466.jpg 768w\" sizes=\"(max-width: 878px) 100vw, 878px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","28":"<h2>28. The King was Obsessed with her<\/h2>\n<p>When Madame de Pompadour moved into Versailles, she lived in a room directly above King Louis XV, but apparently, even that wasn&#8217;t close enough for the king.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> He made sure that their rooms were connected by a secret winding staircase so that he could covertly visit Pompadour whenever he liked. However, the &#8220;secret&#8221; staircase didn&#8217;t stay secret for long.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1280px\"><div class=\"media-credit-container alignnone\" style=\"width: 1280px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567643\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609.jpg\" alt=\"Madame de Pompadour facts\" width=\"1280\" height=\"854\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609.jpg 1280w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-300x200.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-1024x683.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-768x512.jpg 768w\" sizes=\"(max-width: 1280px) 100vw, 1280px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567643\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609.jpg\" alt=\"Madame de Pompadour facts\" width=\"1280\" height=\"854\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609.jpg 1280w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-300x200.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-1024x683.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1280px-The_Petit_Trianon_23935245609-768x512.jpg 768w\" sizes=\"(max-width: 1280px) 100vw, 1280px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:The_Petit_Trianon_(23935245609).jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","29":"<h2>29. Rivals Insulted Her<\/h2>\n<p>In the French court, jealous courtiers coined a cruel phrase to insult Pompadour. They whispered that the king &#8220;only loves her for her staircase&#8221;&#8230;also known as her bedroom-based charms.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 938px\"><div class=\"media-credit-container alignnone\" style=\"width: 938px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567662\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1.png\" alt=\"Madame de Pompadour facts\" width=\"938\" height=\"548\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1.png 938w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1-300x175.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1-768x449.png 768w\" sizes=\"(max-width: 938px) 100vw, 938px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567662\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1.png\" alt=\"Madame de Pompadour facts\" width=\"938\" height=\"548\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1.png 938w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1-300x175.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991106-1-768x449.png 768w\" sizes=\"(max-width: 938px) 100vw, 938px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","30":"<h2>30. She Could Charm Anyone&#8230;And I Mean Anyone<\/h2>\n<p>You\u2019re probably thinking about how awkward and toxic Pompadour\u2019s relationship with Louis XV\u2019s wife, Queen Marie, must\u2019ve been. However, their relationship was completely cordial, if the accounts are to be believed. But the reason for their cooperation isn&#8217;t so prim and proper:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> Pompadour made sure to suck up to her competition and went to disturbing lengths to make nice with the queen.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 891px\"><div class=\"media-credit-container alignnone\" style=\"width: 891px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567668\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8.jpg\" alt=\"Madame de Pompadour facts\" width=\"891\" height=\"522\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8.jpg 891w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8-300x176.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8-768x450.jpg 768w\" sizes=\"(max-width: 891px) 100vw, 891px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567668\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8.jpg\" alt=\"Madame de Pompadour facts\" width=\"891\" height=\"522\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8.jpg 891w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8-300x176.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_8-768x450.jpg 768w\" sizes=\"(max-width: 891px) 100vw, 891px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","31":"<h2>31. She Could be Deceitful<\/h2>\n<p>Pompadour won over her rival with a series of risky actions. She demanded that the king pay off his wife\u2019s significant gambling debts. With that done, she made Louis give his wife&#8217;s apartments a stylish renovation.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> But her last gesture was the most dangerous. Pompadour gave the queen a golden snuffbox that Louis had originally given to Pompadour. Apparently, the queen didn&#8217;t realize she&#8217;d been re-gifted as Marie reportedly quipped, &#8220;If there must be a mistress, better her than any other&#8221;.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 2560px\"><div class=\"media-credit-container alignnone\" style=\"width: 2560px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-416123\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-scaled.jpg\" alt=\"Madame De Pompadour Facts\" width=\"2560\" height=\"1668\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-300x195.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-1024x667.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-768x500.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-1536x1001.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-2048x1334.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-416123\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-scaled.jpg\" alt=\"Madame De Pompadour Facts\" width=\"2560\" height=\"1668\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-300x195.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-1024x667.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-768x500.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-1536x1001.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Golden_snuffbox_18th_c._France_GIM_by_shakko-2048x1334.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Golden_snuffbox_(18th_c.,_France)_GIM_by_shakko.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","32":"<h2>32. She Got an Awkward Promotion<\/h2>\n<p>At the height of Pompadour\u2019s influence, she served as a lady-in-waiting to Queen Marie. While working for your lover&#8217;s wife would have been a nightmare for anyone else, Pompadour managed to get the most of the awkward situation. The appointment gave her extreme power, and Pompadour wasn&#8217;t afraid to use it.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> One historian said that Pompadour had so much sway that she was France&#8217;s de facto &#8220;prime minister&#8221;.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 2560px\"><div class=\"media-credit-container alignnone\" style=\"width: 2560px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-544737\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-scaled.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"2560\" height=\"2051\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-300x240.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-1024x820.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-768x615.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-1536x1230.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-2048x1641.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-544737\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-scaled.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"2560\" height=\"2051\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-scaled.jpg 2560w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-300x240.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-1024x820.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-768x615.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-1536x1230.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Carle_Van_Loo_-_Marie_Leszczinska_reine_de_France_1703-1768_-_Google_Art_Project-2048x1641.jpg 2048w\" sizes=\"(max-width: 2560px) 100vw, 2560px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Marie_Leszczyska\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","33":"<h2>33. She Had Expensive Taste<\/h2>\n<p>Madame de Pompadour got used to the fancy life pretty quickly. Her favorite foods were chocolate, champagne, and truffle soup.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 952px\"><div class=\"media-credit-container alignnone\" style=\"width: 952px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-461513\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1.jpg\" alt=\"Louis XV facts\" width=\"952\" height=\"570\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1.jpg 952w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1-300x180.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1-768x460.jpg 768w\" sizes=\"(max-width: 952px) 100vw, 952px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-461513\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1.jpg\" alt=\"Louis XV facts\" width=\"952\" height=\"570\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1.jpg 952w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1-300x180.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-24-1-768x460.jpg 768w\" sizes=\"(max-width: 952px) 100vw, 952px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","34":"<h2>34. Her Lover had a Dark Side<\/h2>\n<p>On the surface, King Louis XV seemed like a total catch.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> But lurking beneath the handsome facade lay a truly disturbed man. The King was prone to intense melancholy and depressive moods. One of the few ways he could find solace was in his mistress Madame de Pompadour. She could always help him through his bad days and cheer him up.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> It sounds like the king and Pompadour had a great relationship, but court gossip insisted otherwise.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 949px\"><div class=\"media-credit-container alignnone\" style=\"width: 949px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-461514\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1.jpg\" alt=\"Louis XV facts\" width=\"949\" height=\"548\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1.jpg 949w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1-300x173.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1-768x443.jpg 768w\" sizes=\"(max-width: 949px) 100vw, 949px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-461514\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1.jpg\" alt=\"Louis XV facts\" width=\"949\" height=\"548\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1.jpg 949w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1-300x173.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/10\/Untitled-18-1-768x443.jpg 768w\" sizes=\"(max-width: 949px) 100vw, 949px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","35":"<h2>35. She was into Role Play<\/h2>\n<p>Rich people have always done crazy stuff, and here&#8217;s proof: One of the ways that Louis and Pompadour would relax was by visiting their numerous little chalets and pretending to be poor.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> For real. The couple would travel to one of their many countryside estates, go hunting, walk around nature, and live the simple life. Of course, once inside their humble abode, all the &#8220;rustic&#8221; jugs and bowls were actually made of incredibly expensive materials.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 910px\"><div class=\"media-credit-container alignnone\" style=\"width: 910px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567674\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1.png\" alt=\"Madame de Pompadour facts\" width=\"910\" height=\"556\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1.png 910w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1-300x183.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1-768x469.png 768w\" sizes=\"(max-width: 910px) 100vw, 910px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567674\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1.png\" alt=\"Madame de Pompadour facts\" width=\"910\" height=\"556\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1.png 910w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1-300x183.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991108-1-768x469.png 768w\" sizes=\"(max-width: 910px) 100vw, 910px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","36":"<h2>36. She Got Her Way<\/h2>\n<p>Jeanne Poisson received her now famous name Madame de Pompadour as a gift from her sugar daddy, King Louis XV.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> Since Ms. Poisson wasn&#8217;t born a noblewoman, the king gave her the next best thing: He bought her a noble title. In June 1745, she became the Marquise of the estate called Pompadour. But even that wasn&#8217;t enough. Pompadour had so much sway over the king that she got him to give her brother a noble title too.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p><\/p>\n<p>However, Pompadour&#8217;s enemies weren&#8217;t as enamoured with her as the French king.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 886px\"><div class=\"media-credit-container alignnone\" style=\"width: 886px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567675\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1.png\" alt=\"Madame de Pompadour facts\" width=\"886\" height=\"559\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1.png 886w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1-300x189.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1-768x485.png 768w\" sizes=\"(max-width: 886px) 100vw, 886px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567675\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1.png\" alt=\"Madame de Pompadour facts\" width=\"886\" height=\"559\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1.png 886w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1-300x189.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991109-1-768x485.png 768w\" sizes=\"(max-width: 886px) 100vw, 886px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","37":"<h2>37. Her Enemies Spread Rumors<\/h2>\n<p>Rival courtiers interpreted Louis&#8217; love for his mistress not as genuine affection, but as weakness. They thought that Pompadour was a power-hungry woman who manipulated the weakened king and used his melancholy moods to gain power.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> To be fair, they weren&#8217;t completely wrong. As we&#8217;ll see, Pompadour held a <em>lot\u00a0<\/em>of power and influence in her beau&#8217;s court&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 3284px\"><div class=\"media-credit-container alignnone\" style=\"width: 3284px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-308885\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour.jpg\" alt=\"History's Upper Class facts\" width=\"3284\" height=\"2431\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour.jpg 3284w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-300x222.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-768x569.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-1024x758.jpg 1024w\" sizes=\"(max-width: 3284px) 100vw, 3284px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-308885\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour.jpg\" alt=\"History's Upper Class facts\" width=\"3284\" height=\"2431\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour.jpg 3284w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-300x222.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-768x569.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Madame_de_Pompadour-1024x758.jpg 1024w\" sizes=\"(max-width: 3284px) 100vw, 3284px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Madame_de_Pompadour.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","38":"<h2>38. The Public Hated Her<\/h2>\n<p>In 1750, the public began to pressure King Louis XV to clean up his act, get rid of his mistresses, and live as a good Christian ruler.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> For Pompadour, this was as good as a death sentence. If the people wanted her gone, she&#8217;d be out of the streets. Luckily, Pompadour wasn&#8217;t just pretty, she was smart too. She immediately rebranded, pitching herself as &#8220;the friend of the king&#8221; with an elaborate gesture.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> She commissioned two wildly expensive sculptures of&#8230;herself. It&#8217;s safe to say the people weren&#8217;t thrilled.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 957px\"><div class=\"media-credit-container alignnone\" style=\"width: 957px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567677\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9.jpg\" alt=\"Madame de Pompadour facts\" width=\"957\" height=\"552\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9.jpg 957w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9-300x173.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9-768x443.jpg 768w\" sizes=\"(max-width: 957px) 100vw, 957px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567677\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9.jpg\" alt=\"Madame de Pompadour facts\" width=\"957\" height=\"552\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9.jpg 957w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9-300x173.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_9-768x443.jpg 768w\" sizes=\"(max-width: 957px) 100vw, 957px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","39":"<h2>39. She was a Top Tier Schemer<\/h2>\n<p>Even when the public demanded that Pompadour get the heck out of Versailles, she managed to swing a deal in her favor. She agreed to live in another set of apartments to appease the court.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> She just didn&#8217;t mention one little detail: Pompadour&#8217;s new digs were even fancier and more expensive than her old place. Honestly, I should be mad, but I&#8217;m just impressed.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1280px\"><div class=\"media-credit-container alignnone\" style=\"width: 1280px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-378144\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces.jpg\" alt=\"Mansions Of Disturbed Minds Facts\" width=\"1280\" height=\"850\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces.jpg 1280w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-300x199.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-1024x680.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-768x510.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-340x225.jpg 340w\" sizes=\"(max-width: 1280px) 100vw, 1280px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-378144\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces.jpg\" alt=\"Mansions Of Disturbed Minds Facts\" width=\"1280\" height=\"850\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces.jpg 1280w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-300x199.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-1024x680.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-768x510.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2020\/01\/1280px-Chateau_Versailles_Galerie_des_Glaces-340x225.jpg 340w\" sizes=\"(max-width: 1280px) 100vw, 1280px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/File:Chateau_Versailles_Galerie_des_Glaces.jpg\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","40":"<h2>40. She and the King Endured Tragedies<\/h2>\n<p>Amid all Madame de Pompadour&#8217;s missteps, she and the king really did share a deep connection.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> But sadly, there was one thing they&#8217;re never share: a child. Pompadour was plagued by ill health and even though she became pregnant multiple times, all of her pregnancies ended in the same tragic way. She miscarried her and the king&#8217;s child every single time.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 845px\"><div class=\"media-credit-container alignnone\" style=\"width: 845px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567680\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10.jpg\" alt=\"Madame de Pompadour facts\" width=\"845\" height=\"520\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10.jpg 845w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10-300x185.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10-768x473.jpg 768w\" sizes=\"(max-width: 845px) 100vw, 845px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567680\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10.jpg\" alt=\"Madame de Pompadour facts\" width=\"845\" height=\"520\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10.jpg 845w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10-300x185.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_10-768x473.jpg 768w\" sizes=\"(max-width: 845px) 100vw, 845px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.bbc.com\/\">Doctor Who (2005\u2013 ), BBC<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","41":"<h2>41. Her Actions Made Waves<\/h2>\n<p>Such was Pompadour\u2019s influence in Louis XV\u2019s court that foreign diplomats often asked for her help with political negotiations. The esteemed diplomat Wenzel Anton Graf Kaunitz requested Pompadour\u2019s assistance with the seminal 1756 Treaty of Versailles. Pompadour knew this was a crucial moment for her budding political prowess, but she had no idea that her actions would have utterly disastrous consequences.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1045px\"><div class=\"media-credit-container alignnone\" style=\"width: 1045px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-416128\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112.png\" alt=\"Madame De Pompadour Facts\" width=\"1045\" height=\"794\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112.png 1045w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-300x228.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-1024x778.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-768x584.png 768w\" sizes=\"(max-width: 1045px) 100vw, 1045px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-416128\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112.png\" alt=\"Madame De Pompadour Facts\" width=\"1045\" height=\"794\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112.png 1045w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-300x228.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-1024x778.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991112-768x584.png 768w\" sizes=\"(max-width: 1045px) 100vw, 1045px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Wenzel_Anton_Graf_von_Kaunitz-Riethberg.jpg\"> Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","42":"<h2>42. She Doomed Her Country<\/h2>\n<p>The Treaty of Versailles made waves in 18th century Europe and one of its biggest developments was turning the former enemies of France and Austria into allies. This alliance was the reason that France entered the brutal Seven Years\u2019 War. This massive global conflict began just months after the treaty was signed, and unfortunately for Pompadour, it could not have gone worse.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 927px\"><div class=\"media-credit-container alignnone\" style=\"width: 927px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-544833\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"927\" height=\"528\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1.jpg 927w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1-300x171.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1-768x437.jpg 768w\" sizes=\"(max-width: 927px) 100vw, 927px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-544833\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"927\" height=\"528\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1.jpg 927w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1-300x171.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_18-1-768x437.jpg 768w\" sizes=\"(max-width: 927px) 100vw, 927px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","43":"<h2>43. Her Enemies were Vicious<\/h2>\n<p>After seven years of violence, the war ended but France had no reason to celebrate. The country had lost brutally, giving up their claim to territory in what is now the United States. Pompadour\u2019s enemies immediately pounced on the opportunity to malign her. They didn&#8217;t blame the king for France&#8217;s embarrassing defeat, but his close advisor, Madame de Pompadour.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> But that&#8217;s not the full story&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 807px\"><div class=\"media-credit-container alignnone\" style=\"width: 807px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567688\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11.jpg\" alt=\"Madame de Pompadour facts\" width=\"807\" height=\"531\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11.jpg 807w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-300x197.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-768x505.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-340x225.jpg 340w\" sizes=\"(max-width: 807px) 100vw, 807px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567688\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11.jpg\" alt=\"Madame de Pompadour facts\" width=\"807\" height=\"531\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11.jpg 807w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-300x197.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-768x505.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_11-340x225.jpg 340w\" sizes=\"(max-width: 807px) 100vw, 807px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","44":"<h2>44. They Hid the True Story<\/h2>\n<p>The irony is that while Pompadour&#8217;s responsibility for France\u2019s defeat was indirect at best, it is historical fact that Pompadour supported a number of important ministers such as Bertin and Machaut. These ministers would implement reforms to France\u2019s infrastructure, trade, and taxes which would eventually lead to France becoming \u201cthe richest nation in the world\u201d.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 825px\"><div class=\"media-credit-container alignnone\" style=\"width: 825px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567690\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12.jpg\" alt=\"Madame de Pompadour facts\" width=\"825\" height=\"539\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12.jpg 825w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12-300x196.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12-768x502.jpg 768w\" sizes=\"(max-width: 825px) 100vw, 825px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567690\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12.jpg\" alt=\"Madame de Pompadour facts\" width=\"825\" height=\"539\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12.jpg 825w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12-300x196.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_12-768x502.jpg 768w\" sizes=\"(max-width: 825px) 100vw, 825px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","45":"<h2>45. She Made a Dark Prophecy<\/h2>\n<p>Even so, there is a dark detail about Pompadour&#8217;s involvement in the War and it involves a now-famous quotation.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> Pompadour said \u201cafter us, the flood\u201d to comfort her love, King Louis, after France\u2019s terrible defeat at the Battle of Rossbach in 1757. But what did she mean? Pompadour either meant that whatever happens after Louis doesn&#8217;t matter, or far more darkly, that everything will collapse after his reign.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 2208px\"><div class=\"media-credit-container alignnone\" style=\"width: 2208px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567691\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach.jpg\" alt=\"Madame de Pompadour facts\" width=\"2208\" height=\"1704\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach.jpg 2208w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-300x232.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-1024x790.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-768x593.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-1536x1185.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-2048x1581.jpg 2048w\" sizes=\"(max-width: 2208px) 100vw, 2208px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567691\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach.jpg\" alt=\"Madame de Pompadour facts\" width=\"2208\" height=\"1704\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach.jpg 2208w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-300x232.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-1024x790.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-768x593.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-1536x1185.jpg 1536w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Schlacht_bei_Ro\u00dfbach-2048x1581.jpg 2048w\" sizes=\"(max-width: 2208px) 100vw, 2208px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Battle_of_Rossbach\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","46":"<h2>46. She was a Trend Setter<\/h2>\n<p>Pompadour began a controversial trend. Almost daring people to bring up her bourgeois background, she&#8217;d dress up in a milkmaid&#8217;s attire and pretend to be a peasant. The trend was so influential that even <a href=\"https:\/\/www.factinate.com\/people\/44-grandiose-facts-marie-antoinette\/\" target=\"_blank\" rel=\"noopener noreferrer\">Marie Antoinette<\/a> kept the fad going. She commissioned golden milk churns for her poor person cosplay&#8230;you know, because nothing makes you think of French peasantry more than solid gold.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1362px\"><div class=\"media-credit-container alignnone\" style=\"width: 1362px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-381757\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200.png\" alt=\"Marie Antoinette Facts\" width=\"1362\" height=\"964\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200.png 1362w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-300x212.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-1024x725.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-768x544.png 768w\" sizes=\"(max-width: 1362px) 100vw, 1362px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-381757\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200.png\" alt=\"Marie Antoinette Facts\" width=\"1362\" height=\"964\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200.png 1362w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-300x212.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-1024x725.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/02\/Selection_200-768x544.png 768w\" sizes=\"(max-width: 1362px) 100vw, 1362px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Gautier-Dagoty_-_Marie-Antoinette,_1775.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","47":"<h2>47. She was Vain<\/h2>\n<p>As a patron of the arts, it made sense for Madame de Pompadour to cover the walls of her boudoir with expensive custom paintings. What raised more eyebrows was the paintings&#8217; shared content: Many of them featured glamorous depictions of Pompadour and not only that, many showed her dressed up as an actual goddess.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> She, uh, clearly didn&#8217;t have issues with self-confidence.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 890px\"><div class=\"media-credit-container alignnone\" style=\"width: 890px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567701\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1.png\" alt=\"Madame de Pompadour facts\" width=\"890\" height=\"560\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1.png 890w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1-300x189.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1-768x483.png 768w\" sizes=\"(max-width: 890px) 100vw, 890px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567701\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1.png\" alt=\"Madame de Pompadour facts\" width=\"890\" height=\"560\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1.png 890w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1-300x189.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991110-1-768x483.png 768w\" sizes=\"(max-width: 890px) 100vw, 890px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","48":"<h2>48. She was the Most Hated Woman in France<\/h2>\n<p>Because of Pompadour&#8217;s disastrous involvement with the Seven Years War, she became the most hated woman in France. Angry courtiers even campaigned to make the king kick her out. But such was Pompadour&#8217;s power over the ruler:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> The whole country could demand that he cut his mistress loose and he still wouldn&#8217;t budge. Pompadour stayed at the palace.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 819px\"><div class=\"media-credit-container alignnone\" style=\"width: 819px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567703\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13.jpg\" alt=\"Madame de Pompadour facts\" width=\"819\" height=\"539\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13.jpg 819w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-300x197.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-768x505.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-340x225.jpg 340w\" sizes=\"(max-width: 819px) 100vw, 819px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567703\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13.jpg\" alt=\"Madame de Pompadour facts\" width=\"819\" height=\"539\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13.jpg 819w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-300x197.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-768x505.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_13-340x225.jpg 340w\" sizes=\"(max-width: 819px) 100vw, 819px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","49":"<h2>49. She Played it Cool<\/h2>\n<p>Louis was not a one-woman man. During his affair with Pompadour, he sated his physical desires on the side with casual sojourns in his \u201cParc-aux-Cerfs\u201d or \u201cStag Park,&#8221; a building specifically for the king&#8217;s affairs. Rumors swirled that Pompadour was the mastermind behind the king&#8217;s debauched palace, gleefully setting up her lover with a harem of women.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> In reality, Pompadour just accepted the king&#8217;s side pieces. Later on, she revealed the chilling reason for her acquiescence&#8230;<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 924px\"><div class=\"media-credit-container alignnone\" style=\"width: 924px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567704\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1.png\" alt=\"Madame de Pompadour facts\" width=\"924\" height=\"547\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1.png 924w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1-300x178.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1-768x455.png 768w\" sizes=\"(max-width: 924px) 100vw, 924px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567704\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1.png\" alt=\"Madame de Pompadour facts\" width=\"924\" height=\"547\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1.png 924w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1-300x178.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991115-1-768x455.png 768w\" sizes=\"(max-width: 924px) 100vw, 924px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","50":"<h2>50. She Wasn&#8217;t Afraid of Competition<\/h2>\n<p>Pompadour told one of her friends that Louis&#8217; side dalliances didn&#8217;t bother her because, \u201cIt is his heart I want! All these little girls with no education will not take it from me.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> I would not be so calm if I saw some pretty woman of the court or the capital trying to conquer it&#8221;. But as we&#8217;ll see, there were far more reasons for her to be so relaxed about Louis&#8217; side pieces.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 917px\"><div class=\"media-credit-container alignnone\" style=\"width: 917px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567705\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1.png\" alt=\"Madame de Pompadour facts\" width=\"917\" height=\"553\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1.png 917w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-300x181.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-768x463.png 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-845x510.png 845w\" sizes=\"(max-width: 917px) 100vw, 917px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567705\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1.png\" alt=\"Madame de Pompadour facts\" width=\"917\" height=\"553\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1.png 917w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-300x181.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-768x463.png 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991116-1-845x510.png 845w\" sizes=\"(max-width: 917px) 100vw, 917px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","51":"<h2>51. She Got Into a Brutal Public Spat<\/h2>\n<p>Madame de Pompadour&#8217;s shameless quest to get to the top of the French court didn&#8217;t always make her the most popular person in the room, but when she got on the wrong side of the Comte de Maurepas, she learned to regret it.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> He wrote an utterly vicious poem about Pompadour where he made fun of her&#8230;for her recent miscarriage. And as though that&#8217;s not bad enough, some historians believe the poem had an even crueller meaning.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-525442\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"800\" height=\"653\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1-300x245.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1-768x627.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-525442\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"800\" height=\"653\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1-300x245.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/Screenshot_2-1-768x627.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Jean-Frdric_Phlypeaux,_Count_of_Maurepas\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","52":"<h2>52. Her Rival Was Intense<\/h2>\n<p>In Maurepas&#8217; infamous poem, he refers to Pompadour&#8217;s &#8220;white flowers&#8221;.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> It sounds innocent, but nothing could be further from the truth. Everyone at the court knew Maurepas&#8217; scandalous double meaning: He alleged that Pompadour&#8217;s nether regions produces a thick, odorous discharge. But it gets even worse: Apparently, this wasn&#8217;t just a cruel jibe. It might have been true.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> Scholars believe that Pompadour may have had &#8220;leucorrhoea&#8221;.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 807px\"><div class=\"media-credit-container alignnone\" style=\"width: 807px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-416163\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118.png\" alt=\"Madame De Pompadour Facts\" width=\"807\" height=\"637\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118.png 807w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118-300x237.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118-768x606.png 768w\" sizes=\"(max-width: 807px) 100vw, 807px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-416163\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118.png\" alt=\"Madame De Pompadour Facts\" width=\"807\" height=\"637\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118.png 807w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118-300x237.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991118-768x606.png 768w\" sizes=\"(max-width: 807px) 100vw, 807px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Maurepas.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","53":"<h2>53. She Punished her Enemies<\/h2>\n<p>Pompadour was deeply offended by Maurepas&#8217; cruel poem and she used her significant power to make her enemy regret his words. She quickly got her lover King Louis to exile her enemy Maurepas. Pompadour: 1. Maurepas: 0.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 827px\"><div class=\"media-credit-container alignnone\" style=\"width: 827px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567706\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14.jpg\" alt=\"Madame de Pompadour facts\" width=\"827\" height=\"524\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14.jpg 827w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14-300x190.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14-768x487.jpg 768w\" sizes=\"(max-width: 827px) 100vw, 827px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567706\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14.jpg\" alt=\"Madame de Pompadour facts\" width=\"827\" height=\"524\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14.jpg 827w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14-300x190.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_14-768x487.jpg 768w\" sizes=\"(max-width: 827px) 100vw, 827px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","54":"<h2>54. She Made her Mark<\/h2>\n<p>Pompadour pops up in all sorts of places.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> Not only did her breast form the shape of the French champagne glass, there&#8217;s also a long-standing rumor that she influenced a famous engagement ring style. King Louis XV may have commissioned the \u201cmarquise cut\u201d diamond as a scandalous homage to his beloved mistress. Apparently, its shape is based on Pompadour\u2019s mouth.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 877px\"><div class=\"media-credit-container alignnone\" style=\"width: 877px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-544927\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"877\" height=\"555\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1.jpg 877w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1-300x190.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1-768x486.jpg 768w\" sizes=\"(max-width: 877px) 100vw, 877px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-544927\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"877\" height=\"555\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1.jpg 877w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1-300x190.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_25-1-768x486.jpg 768w\" sizes=\"(max-width: 877px) 100vw, 877px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","55":"<h2>55. She Secretly Controlled France<\/h2>\n<p>Pompadour made her mark on French history not just as a mistress and a sly politician but a tastemaker.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> She was an important patron of the arts whose commissions supported painters, writers, and porcelain artisans. Do you ever wonder how Paris got a reputation for being such a fancy, cultured place? Thank Madame de Pompadour. She played a huge role in making the city the &#8220;capital of taste and culture in Europe&#8221;.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p><\/p>\n<p>Not all her legacies would be so positive, though.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-225802\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles.jpg\" alt=\"Madame de Pompadour Facts\" width=\"800\" height=\"504\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles-300x189.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles-768x484.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-225802\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles.jpg\" alt=\"Madame de Pompadour Facts\" width=\"800\" height=\"504\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles-300x189.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Divertissement_Versailles-768x484.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Divertissement_Versailles.jpg\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","56":"<h2>56. She Had Famous Haters<\/h2>\n<p>The French writer, critic, and philosopher Denis Diderot was\u00a0<em>not\u00a0<\/em>a fan of Madame de Pompadour. After her death, he let the world know how he really felt about the king&#8217;s great love. Diderot angrily wrote, \u201cWhat remains of this woman who cost us so much in men and money, left us without honor and without energy, and who overthrew the whole political system of Europe\u201d?<\/p>\n<p>Here&#8217;s where it gets even worse:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p> Diderot had sucked up to Pompadour when she was alive so that she&#8217;d fund his Encyclopedia. But after her death, the truth came out: Her so-called friend hated her guts.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1031px\"><div class=\"media-credit-container alignnone\" style=\"width: 1031px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-416165\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119.png\" alt=\"Madame De Pompadour Facts\" width=\"1031\" height=\"852\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119.png 1031w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-300x248.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-1024x846.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-768x635.png 768w\" sizes=\"(max-width: 1031px) 100vw, 1031px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-416165\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119.png\" alt=\"Madame De Pompadour Facts\" width=\"1031\" height=\"852\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119.png 1031w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-300x248.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-1024x846.png 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991119-768x635.png 768w\" sizes=\"(max-width: 1031px) 100vw, 1031px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/commons.wikimedia.org\/wiki\/File:Denis_Diderot_111.PNG\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","57":"<h2>57. Her Low Origins Haunted Her<\/h2>\n<p>The French court was full of backstabbing and in-fighting, and poor Madame de Pompadour had it worse than most people.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> High born courtiers constantly insulted her lowly background. Their jibes were so numerous that the nation had a specific term for attacks on Pompadour: These insults were called &#8220;poissonades&#8221; in a reference to her last name, the common &#8220;Poisson&#8221; aka &#8220;fish&#8221;.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567707\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1.png\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"590\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1.png 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1-300x221.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1-768x566.png 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567707\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1.png\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"590\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1.png 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1-300x221.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991120-1-768x566.png 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","58":"<h2>58. She Righted a Horrible Wrong<\/h2>\n<p>One of Madame de Pompadour&#8217;s final acts was also one of her most noble.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> In 1762, a Catholic merchant named Jean Calas was accused of killing his son and despite the father&#8217;s insistence that he was innocent, he died after being brutally tormented by the French police. Pompadour&#8217;s dear friend Voltaire told her about the miscarriage of justice, leading Pompadour to intervene.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> She got the king to overturn Calas&#8217; sentence.<\/p>\n<p>Though, to be fair, she wasn&#8217;t this nice to all religious minorities.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 930px\"><div class=\"media-credit-container alignnone\" style=\"width: 930px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567708\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1.png\" alt=\"Madame de Pompadour facts\" width=\"930\" height=\"564\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1.png 930w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1-300x182.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1-768x466.png 768w\" sizes=\"(max-width: 930px) 100vw, 930px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567708\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1.png\" alt=\"Madame de Pompadour facts\" width=\"930\" height=\"564\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1.png 930w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1-300x182.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991121-1-768x466.png 768w\" sizes=\"(max-width: 930px) 100vw, 930px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","59":"<h2>59. She Made Life Hard For Her People<\/h2>\n<p>Louis passed a bill that suppressed Jesuits, a rising Christian group. At the time, this issue was incredibly volatile. It divided not just France, but the royal family.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> Although Louis\u2019s son, daughters, and wife supported the Jesuits, Madame de Pompadour did not. Louis ultimately sided with his mistress, and the Jesuits saw their rights greatly reduced because of her sway.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1335px\"><div class=\"media-credit-container alignnone\" style=\"width: 1335px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567712\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1.jpg\" alt=\"Madame de Pompadour facts\" width=\"1335\" height=\"1080\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1.jpg 1335w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-300x243.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-1024x828.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-768x621.jpg 768w\" sizes=\"(max-width: 1335px) 100vw, 1335px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567712\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1.jpg\" alt=\"Madame de Pompadour facts\" width=\"1335\" height=\"1080\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1.jpg 1335w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-300x243.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-1024x828.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/1335px-Mus\u00e9e_du_Vieux_Toulouse_-_Larrestation_de_Calas_-_Casimir_Destrem_1879_Inv.92_12_1-768x621.jpg 768w\" sizes=\"(max-width: 1335px) 100vw, 1335px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Jean_Calas\">Wikipedia<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","60":"<h2>60. She Produced Kinky Plays<\/h2>\n<p>Pompadour didn&#8217;t just watch art from the sidelines, she took part in it herself.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> She learned to engrave gems from the craft&#8217;s greatest artisan, with one of Pompadour&#8217;s pieces displaying her little spaniel on a tiny gemstone. More scandalously, during her time as Louis XV\u2019s mistress, she staged over a hundred plays at Versailles. Pompadour would often flatter Louis XV by acting as a coy peasant in love with a god AKA the King, and people would lose their minds to get a part in her productions.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 827px\"><div class=\"media-credit-container alignnone\" style=\"width: 827px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567715\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15.jpg\" alt=\"Madame de Pompadour facts\" width=\"827\" height=\"536\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15.jpg 827w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15-300x194.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15-768x498.jpg 768w\" sizes=\"(max-width: 827px) 100vw, 827px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567715\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15.jpg\" alt=\"Madame de Pompadour facts\" width=\"827\" height=\"536\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15.jpg 827w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15-300x194.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_15-768x498.jpg 768w\" sizes=\"(max-width: 827px) 100vw, 827px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","61":"<h2>61. She was a Style Icon<\/h2>\n<p>Madame de Pompadour became well known for her love of feminine designs and the rococo art style. Over time, her artistry became part of her identity so much that a shade of pink was called &#8220;Pompadour Pink&#8221;.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 929px\"><div class=\"media-credit-container alignnone\" style=\"width: 929px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567716\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16.jpg\" alt=\"Madame de Pompadour facts\" width=\"929\" height=\"530\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16.jpg 929w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16-300x171.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16-768x438.jpg 768w\" sizes=\"(max-width: 929px) 100vw, 929px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567716\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16.jpg\" alt=\"Madame de Pompadour facts\" width=\"929\" height=\"530\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16.jpg 929w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16-300x171.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_16-768x438.jpg 768w\" sizes=\"(max-width: 929px) 100vw, 929px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","62":"<h2>62. Her Ending was Tragic<\/h2>\n<p>In 1764, Madame de Pompadour began to feel unwell. When the doctors examined her, they had terrible news:<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> the king&#8217;s great love had tuberculosis. Louis looked after Pompadour as best he could, but ultimately she succumbed to her illness and passed away at the place she loved more than anywhere else: Versailles. She was just 42 years old, but she had lived a hundred lives in her short time on Earth.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p><\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 924px\"><div class=\"media-credit-container alignnone\" style=\"width: 924px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567717\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1.png\" alt=\"Madame de Pompadour facts\" width=\"924\" height=\"556\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1.png 924w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1-300x181.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1-768x462.png 768w\" sizes=\"(max-width: 924px) 100vw, 924px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567717\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1.png\" alt=\"Madame de Pompadour facts\" width=\"924\" height=\"556\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1.png 924w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1-300x181.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991123-1-768x462.png 768w\" sizes=\"(max-width: 924px) 100vw, 924px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","63":"<h2>63. Her Loss was Felt<\/h2>\n<p>After Pompadour&#8217;s death, tributes poured in from all over France. King Louis XV described their bond not just as a passionate romance, but a &#8220;twenty year friendship&#8221;. Pompadour&#8217;s dear friend, the famous writer Voltaire, mourned her in writing. He referenced her great contribution to his career by saying, &#8220;I am indebted to her and I mourn her out of gratitude&#8221;.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> Even the weather seemed to mourn her loss. It rained heavily on the day that Pompadour&#8217;s coffin left the palace.<\/p>\n<p>However, shortly after Pompadour&#8217;s death, the king betrayed his great love in two brutal ways.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1181px\"><div class=\"media-credit-container alignnone\" style=\"width: 1181px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-525421\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"1181\" height=\"894\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1.jpg 1181w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-300x227.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-1024x775.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-768x581.jpg 768w\" sizes=\"(max-width: 1181px) 100vw, 1181px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-525421\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1.jpg\" alt=\"Marie Anne de Mailly-Nesle facts\" width=\"1181\" height=\"894\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1.jpg 1181w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-300x227.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-1024x775.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/08\/LouisXV-1-768x581.jpg 768w\" sizes=\"(max-width: 1181px) 100vw, 1181px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/en.wikipedia.org\/wiki\/Louis_XV\">Wikipedia <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","64":"<h2>64. Missing in Mourning<\/h2>\n<p>Although the king deeply grieved at Pompadour&#8217;s death, court protocol forbade him from attending her funeral.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> After all, Pompadour was still born as a Jeanne Poisson, a middle class woman. Because of this inconvenient fact, she was too low-ranking to deserve a royal funeral attendance, even if the King himself was her life partner.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 860px\"><div class=\"media-credit-container alignnone\" style=\"width: 860px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-544824\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"860\" height=\"541\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2.jpg 860w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2-300x189.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2-768x483.jpg 768w\" sizes=\"(max-width: 860px) 100vw, 860px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-544824\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2.jpg\" alt=\"Louise Julie de Mailly-Nesle facts\" width=\"860\" height=\"541\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2.jpg 860w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2-300x189.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2021\/10\/Screenshot_15-2-768x483.jpg 768w\" sizes=\"(max-width: 860px) 100vw, 860px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","65":"<h2>65. He Didn&#8217;t Mourn for Long<\/h2>\n<p>In 1762, Madame de Pompadour convinced Louis to construct the Petit Trianon, a luxurious mini ch\u00e2teau within Versailles that would serve as their love nest. Unfortunately, Pompadour passed away before construction could be finished.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> But don\u2019t worry, it didn\u2019t go to waste. The Petit Trianon went on to serve as home base to Pompadour\u2019s successor in the royal bed, <a href=\"https:\/\/www.factinate.com\/people\/facts-madame-du-barry\/\" target=\"_blank\" rel=\"noopener noreferrer\">Madame du Barry<\/a>.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1200px\"><div class=\"media-credit-container alignnone\" style=\"width: 1200px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-365933\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23.jpg\" alt=\"Madame du Barry Facts\" width=\"1200\" height=\"627\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23.jpg 1200w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-300x157.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-768x401.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-1024x535.jpg 1024w\" sizes=\"(max-width: 1200px) 100vw, 1200px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-365933\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23.jpg\" alt=\"Madame du Barry Facts\" width=\"1200\" height=\"627\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23.jpg 1200w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-300x157.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-768x401.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2019\/11\/internal-23-1024x535.jpg 1024w\" sizes=\"(max-width: 1200px) 100vw, 1200px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/commons.wikimedia.org\">Wikimedia Commons<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","66":"<h2>66. She Inspired Many<\/h2>\n<p>One of the most long-lasting aspects of Pompadour\u2019s legacy is the hairstyle that bears her name. The elaborate coif involves one\u2019s hair being worn straight up from the forehead and sides. This hairstyle has endured for centuries after Pompadour\u2019s death and not just on her female fans! Men who have adopted the pompadour hairstyle in one form or another include <a href=\"https:\/\/www.factinate.com\/people\/32-hysteria-inducing-facts-elvis-presley\/\" target=\"_blank\" rel=\"noopener noreferrer\">Elvis Presley<\/a>, <a href=\"https:\/\/www.factinate.com\/instant\/42-larger-than-life-facts-about-marlon-brando\/\" target=\"_blank\" rel=\"noopener noreferrer\">Marlon Brando<\/a>, <a href=\"https:\/\/www.factinate.com\/people\/45-fierce-facts-david-beckham\/\" target=\"_blank\" rel=\"noopener noreferrer\">David Beckham<\/a>, and <a href=\"https:\/\/www.factinate.com\/people\/38-fly-facts-justin-timberlake\/\" target=\"_blank\" rel=\"noopener noreferrer\">Justin Timberlake<\/a>.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 1024px\"><div class=\"media-credit-container alignnone\" style=\"width: 1024px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-525687\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962.jpg\" alt=\"Elvis Presley Facts\" width=\"1024\" height=\"815\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962-300x239.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962-768x611.jpg 768w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-525687\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962.jpg\" alt=\"Elvis Presley Facts\" width=\"1024\" height=\"815\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962.jpg 1024w, https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962-300x239.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2017\/04\/GettyImages-607399962-768x611.jpg 768w\" sizes=\"(max-width: 1024px) 100vw, 1024px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.gettyimages.com\/\">Getty Images<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n","67":"<h2>67. She Continues to Fascinate<\/h2>\n<p>In one of her more recent appearances in pop culture, Pompadour showed up as a character in the <em>Doctor Who<\/em> episode \u201cThe Girl in the Fireplace\u201d. The episode follows the Doctor jumping in and out of Pompadour\u2019s life in order to save her from a group of aliens. Pompadour is played by Sophia Myles, who bizarrely kept her British accent for the role.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p><\/p>\n<p>Thanks to good writing\u2014and an ending that we know made some of you cry\u2014\u201cThe Girl in the Fireplace\u201d won a Hugo Award for Best Dramatic Presentation and is one of the highest-rated episodes of David Tennant\u2019s era as the Doctor.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 932px\"><div class=\"media-credit-container alignnone\" style=\"width: 932px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567718\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17.jpg\" alt=\"Madame de Pompadour facts\" width=\"932\" height=\"494\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17.jpg 932w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-300x159.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-768x407.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-348x183.jpg 348w\" sizes=\"(max-width: 932px) 100vw, 932px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567718\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17.jpg\" alt=\"Madame de Pompadour facts\" width=\"932\" height=\"494\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17.jpg 932w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-300x159.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-768x407.jpg 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_17-348x183.jpg 348w\" sizes=\"(max-width: 932px) 100vw, 932px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.bbc.com\/\">Doctor Who (2005\u2013 ), BBC<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div>\n","68":"<h2>68. The Couple Hid a Dark Secret<\/h2>\n<p>While on the<span style=\"font-weight: 400;\">\u00a0outside, their relationship was happy and healthy, modern historians now know that the couple hid a dark secret behind bedroom doors.\u00a0<\/span>From 1750 onwards, Pompadour ceased being a sexual partner to Louis XV.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div><p> Just five years into their relationship, they stopped making love. But the reason for their abstinence was so shocking that it&#8217;s impossible to forget.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 984px\"><div class=\"media-credit-container alignnone\" style=\"width: 984px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567719\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1.png\" alt=\"Madame de Pompadour facts\" width=\"984\" height=\"497\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1.png 984w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1-300x152.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1-768x388.png 768w\" sizes=\"(max-width: 984px) 100vw, 984px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567719\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1.png\" alt=\"Madame de Pompadour facts\" width=\"984\" height=\"497\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1.png 984w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1-300x152.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991125-1-768x388.png 768w\" sizes=\"(max-width: 984px) 100vw, 984px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div>\n","69":"<h2>69. Pompadour Suffered in Silence<\/h2>\n<p>In public, the reason for Pompadour&#8217;s shifting role was chalked up to her poor health. She suffered multiple miscarriages, her childhood bout with whooping cough had weakened her, and she always seemed to have a cold or bronchitis.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF2\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF1\"><\/div><p> But behind closed doors, there was another reason: Pompadour just wasn&#8217;t that interested in bedroom-based activities.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 869px\"><div class=\"media-credit-container alignnone\" style=\"width: 869px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567720\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18.jpg\" alt=\"Madame de Pompadour facts\" width=\"869\" height=\"544\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18.jpg 869w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18-300x188.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18-768x481.jpg 768w\" sizes=\"(max-width: 869px) 100vw, 869px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567720\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18.jpg\" alt=\"Madame de Pompadour facts\" width=\"869\" height=\"544\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18.jpg 869w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18-300x188.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_18-768x481.jpg 768w\" sizes=\"(max-width: 869px) 100vw, 869px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div>\n","70":"<h2>70. She Had a Strange Secret<\/h2>\n<p>It turns out that despite Madame de Pompadour&#8217;s reputation as a beautiful mistress, she didn&#8217;t actually have a voracious sexual appetite. She even went on a bizarre celery, truffle, and vanilla diet to try to feel more &#8220;in the mood&#8221;.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF3\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF2\"><\/div><p> Unsurprisingly, this nauseating combination of flavors did not end up doing anything to help the royal mistress feel randy.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 839px\"><div class=\"media-credit-container alignnone\" style=\"width: 839px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567721\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19.jpg\" alt=\"Madame de Pompadour facts\" width=\"839\" height=\"524\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19.jpg 839w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19-300x187.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19-768x480.jpg 768w\" sizes=\"(max-width: 839px) 100vw, 839px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567721\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19.jpg\" alt=\"Madame de Pompadour facts\" width=\"839\" height=\"524\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19.jpg 839w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19-300x187.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_19-768x480.jpg 768w\" sizes=\"(max-width: 839px) 100vw, 839px\" \/><\/noscript><span class=\"media-credit\"><a href=\"http:\/\/www.lesfilmsdici.fr\/en\/\">Louis XV, The black sun (2009), Les Films d'Ici<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div>\n","71":"<h2>71. Her Portrait Hid a Scandalous Secret<\/h2>\n<p>There are numerous portraits of Madame de Pompadour\u2014but only one reveals her darkest secret. Towards the end of her life, Pompadour commissioned a painting of her embroidering fabric.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF4\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF3\"><\/div><p> It seemed like an innocent activity, but the truth wasn\u2019t so simple: Pompadour would meet with world leaders and negotiate power while demurely embroidering.<\/p>\n<p>Pompadour&#8217;s portrait was nowhere near as meek and unassuming as it seemed.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 800px\"><div class=\"media-credit-container alignnone\" style=\"width: 800px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567722\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"613\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20-300x230.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20-768x588.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567722\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20.jpg\" alt=\"Madame de Pompadour facts\" width=\"800\" height=\"613\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20.jpg 800w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20-300x230.jpg 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Screenshot_20-768x588.jpg 768w\" sizes=\"(max-width: 800px) 100vw, 800px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.flickr.com\/photos\/sacheverelle\/2658292592\">Flickr, Sacheverelle<\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div>\n","72":"<h2>72. She Betrayed her Love<\/h2>\n<p>Madame de Pompadour was King Louis XV\u2019s great love, but few people know she betrayed him with an utterly brutal act. Pompadour was deeply engaged in arts and culture, and one of her project was editing the first French Encyclopedia by her frenemy Diderot and his co-writer d&#8217;Alembert.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF5\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF4\"><\/div><p> The book championed science and criticized both the law and the church. Historians now call it the \u201cintellectual prologue\u201d to the French Revolution. The violent uprising would see Louis\u2019 grandson beheaded at the guillotine.<\/p>\n<figure class=\"wp-caption alignnone\" style=\"width: 835px\"><div class=\"media-credit-container alignnone\" style=\"width: 835px\"><img loading=\"lazy\" class=\"lazy lazy-hidden size-full wp-image-567723\" src=\"\/\/www.factinate.com\/wp-content\/plugins\/a3-lazy-load\/assets\/images\/lazy_placeholder.gif\" data-lazy-type=\"image\" data-src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1.png\" alt=\"Madame de Pompadour facts\" width=\"835\" height=\"550\" srcset=\"\" data-srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1.png 835w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-300x198.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-768x506.png 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-340x225.png 340w\" sizes=\"(max-width: 835px) 100vw, 835px\" \/><noscript><img loading=\"lazy\" class=\"size-full wp-image-567723\" src=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1.png\" alt=\"Madame de Pompadour facts\" width=\"835\" height=\"550\" srcset=\"https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1.png 835w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-300x198.png 300w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-768x506.png 768w, https:\/\/www.factinate.com\/wp-content\/uploads\/2018\/12\/Selection_9991124-1-340x225.png 340w\" sizes=\"(max-width: 835px) 100vw, 835px\" \/><\/noscript><span class=\"media-credit\"><a href=\"https:\/\/www.france.tv\/france-2\/\">Madame De Pompadour: The King's Favourite(2006), France 2 <\/a><\/span><\/div><\/figure><div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF7\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF6\"><\/div>\n<p><span class=\"s1\"><strong>Sources:<\/strong> <span style=\"color: #0000ff;\" data-darkreader-inline-color=\"\"><a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Madame_de_Pompadour\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">1<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Monsieur_Beaucaire_(1924_film)\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">2<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Charles_Guillaume_Le_Normant_d%27%C3%89tiolles\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">3<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/The_Girl_in_the_Fireplace\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">4<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Maurice_Quentin_de_La_Tour\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">5<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/www.imdb.com\/title\/tt4397438\/?ref_=nv_sr_5\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">6<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/youtu.be\/0fJSxibj-tc?t=1311\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">7<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Pompadour_(hairstyle)\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">8<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Apr%C3%A8s_nous_le_d%C3%A9luge\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">9<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Treaty_of_Versailles_(1756)\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">10<\/a>, <\/span><\/span><span style=\"color: #0000ff;\" data-darkreader-inline-color=\"\"><a style=\"color: #0000ff;\" href=\"https:\/\/www.npr.org\/2016\/05\/10\/477369874\/more-than-a-mistress-madame-de-pompadour-was-a-minister-of-the-arts\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">11<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Marie_Anne_de_Mailly\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">12<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/www.nationalgallery.org.uk\/paintings\/learn-about-art\/paintings-in-depth\/the-real-madame-de-pompadour?viewPage=2\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">13<\/a>, <a style=\"color: #0000ff;\" href=\"http:\/\/en.chateauversailles.fr\/discover\/history\/great-characters\/madame-pompadour\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">14<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/www.factinate.com\/people\/facts-king-louis-xv-france\/\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">15<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/www.newyorker.com\/magazine\/2002\/10\/07\/eminence-rose\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">16<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/books.google.ca\/books?id=-l7hDwAAQBAJ&amp;pg=PA175&amp;lpg=PA175&amp;dq=maurepas+epigram+pompadour&amp;source=bl&amp;ots=fML_lXhycq&amp;sig=ACfU3U2Zgz5W531dklFEIv-ZDPgzwflJVg&amp;hl=en&amp;sa=X&amp;ved=2ahUKEwifvqrE18LpAhXbG80KHX5UAhMQ6AEwAXoECAsQAQ#v=onepage&amp;q=maurepas%20ep\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">17<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/www.britannica.com\/biography\/Jeanne-Antoinette-Poisson-marquise-de-Pompadour\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">18<\/a>, <a style=\"color: #0000ff;\" href=\"https:\/\/en.wikipedia.org\/wiki\/Jean_Calas\" target=\"_blank\" rel=\"noopener noreferrer\" data-darkreader-inline-color=\"\">19<\/a><\/span><\/p>\n<p><em>A previous version of this article stated Louis XVI was the son of Louis XV. It has been corrected to state that Louis XVI was Louis XV&#8217;s grandson.<div class=\"partial_slot\" data-msp=\"\/82634262\/Fact_ROS_Mobile_300x250_BTF6\" data-dsp=\"\/82634262\/Fact_ROS_Desktop_728x90_BTF5\"><\/div><p>\u00a0<\/em><\/p>\n"}